Example #1
0
def test_plot(expect, ans, options=0):
  xd = pylab.linspace(0,1,100)
  expr = '[ %s for x in xd]' % ans
  try:
    yd = eval(expr)
  except Exception as err:
    msg = "Sorry, cannot evaluate your expression, err=%s" % str(err).replace('<','&lt;')
    return dict(ok=False, msg=msg)
  imgdata = StringIO.StringIO()

  fig = pylab.figure()
  ax = fig.add_subplot(111)
  ax.plot(xd, yd, 'ro')
  ax.plot(xd, yd)
  ax.grid()
  fig.savefig(imgdata, format='png')
  pylab.close()

  imgdata.seek(0)  # rewind the data
  uri = 'data:image/png;base64,' + urllib.quote(base64.b64encode(imgdata.buf))
  msg = '<html><img src = "%s"/>' % uri

  area = sum(yd)/(1.0*len(xd))
  msg += '<p>Area=%s, expected area=%s</p></html>' % (area, options)
  ok = abs(area-float(options))<0.001

  return dict(ok=bool(ok), msg=msg)
def plotKerasExperimentcifar10():

    index = 5
    for experiment_number in range(1,index+1):
        outputPath_part_final = os.path.realpath( "/home/jie/docker_folder/random_keras/output_cifar10_mlp/errorFile/hyperopt_experiment_withoutparam_accuracy" + str(experiment_number) + ".txt")
        output_plot = os.path.realpath(
                "/home/jie/docker_folder/random_keras/output_cifar10_mlp/errorFile/plotErrorCurve" + str(experiment_number) + ".pdf")

        df = pd.read_csv(outputPath_part_final,delimiter='\t',header=None)
        df.drop(df.columns[[600]], axis=1, inplace=True)

        i=1
        epochnum = []
        while i<=250:
            epochnum.append(i)
            i = i+1
        i=0
        while i<10:
            df_1=df[df.columns[0:250]].ix[i]
            np.reshape(df_1, (1,250))
            plt.plot(epochnum,df_1)

            i = i+1
        # plt.show()
        # plt.show()
        plt.savefig(output_plot)
        plt.close()
Example #3
0
def Doplots_monthly(mypathforResults,PlottingDF,variable_to_fill, Site_ID,units,item):   
    ANN_label=str(item+"_NN")     #Do Monthly Plots
    print "Doing MOnthly  plot"
    #t = arange(1, 54, 1)
    NN_label='Fc'
    Plottemp = PlottingDF[[NN_label,item]][PlottingDF['day_night']!=1]
    #Plottemp = PlottingDF[[NN_label,item]].dropna(how='any')
    figure(1)
    pl.title('Nightime ANN v Tower by year-month for '+item+' at '+Site_ID)

    try:
	xdata1a=Plottemp[item].groupby([lambda x: x.year,lambda x: x.month]).mean()
	plotxdata1a=True
    except:
	plotxdata1a=False
    try:
	xdata1b=Plottemp[NN_label].groupby([lambda x: x.year,lambda x: x.month]).mean()
	plotxdata1b=True
    except:
	plotxdata1b=False 
    if plotxdata1a==True:
	pl.plot(xdata1a,'r',label=item) 
    if plotxdata1b==True:
	pl.plot(xdata1b,'b',label=NN_label)
    pl.ylabel('Flux')    
    pl.xlabel('Year - Month')       
    pl.legend()
    pl.savefig(mypathforResults+'/ANN and Tower plots by year and month for variable '+item+' at '+Site_ID)
    #pl.show()
    pl.close()
    time.sleep(1)
Example #4
0
def plot_elecs_and_neurons(neuron_dict, ext_sim_dict, neural_sim_dict):
    pl.close('all')
    fig_all = pl.figure(figsize=[15,15])
    ax_all = fig_all.add_axes([0.1, 0.1, 0.8, 0.8], frameon=False)
    for elec in xrange(len(ext_sim_dict['elec_z'])):
        ax_all.plot(ext_sim_dict['elec_z'][elec], ext_sim_dict['elec_y'][elec], color='b',\
                marker='$E%i$'%elec, markersize=20 )    
    legends = []
    for i, neur in enumerate(neuron_dict):
        folder = os.path.join(neural_sim_dict['output_folder'], neuron_dict[neur]['name'])
        coor = np.load(os.path.join(folder,'coor.npy'))
        x,y,z = coor
        n_compartments = len(x)
        fig = pl.figure(figsize=[10, 10])
        ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], frameon=False)
        # Plot the electrodes
        for elec in xrange(len(ext_sim_dict['elec_z'])):
            ax.plot(ext_sim_dict['elec_z'][elec], ext_sim_dict['elec_y'][elec], color='b',\
                   marker='$%i$'%elec, markersize=20 )
        # Plot the neuron
        xmid, ymid, zmid = np.load(folder + '/coor.npy')
        xstart, ystart,zstart = np.load(folder + '/coor_start.npy')
        xend, yend, zend = np.load(folder + '/coor_end.npy')
        diam = np.load(folder + '/diam.npy')
        length = np.load(folder + '/length.npy')
        n_compartments = len(diam)
        for comp in xrange(n_compartments):
            if comp == 0:
                xcoords = pl.array([xmid[comp]])
                ycoords = pl.array([ymid[comp]])
                zcoords = pl.array([zmid[comp]])
                diams = pl.array([diam[comp]])    
            else:
                if zmid[comp] < 0.400 and zmid[comp] > -.400:  
                    xcoords = pl.r_[xcoords, pl.linspace(xstart[comp],
                                                         xend[comp], length[comp]*3*1000)]   
                    ycoords = pl.r_[ycoords, pl.linspace(ystart[comp],
                                                         yend[comp], length[comp]*3*1000)]   
                    zcoords = pl.r_[zcoords, pl.linspace(zstart[comp],
                                                         zend[comp], length[comp]*3*1000)]   
                    diams = pl.r_[diams, pl.linspace(diam[comp], diam[comp],
                                                length[comp]*3*1000)]
        argsort = pl.argsort(-xcoords)
        ax.scatter(zcoords[argsort], ycoords[argsort], s=20*(diams[argsort]*1000)**2,
                       c=xcoords[argsort], edgecolors='none', cmap='gray')
        ax_all.plot(zmid[0], ymid[0], marker='$%i$'%i, markersize=20, label='%i: %s' %(i, neur))
        #legends.append('%i: %s' %(i, neur))
        ax.axis(ext_sim_dict['plot_range'])
        ax.axis('equal')
        ax.axis(ext_sim_dict['plot_range'])
        ax.set_xlabel('z [mm]')
        ax.set_ylabel('y [mm]')
        fig.savefig(os.path.join(neural_sim_dict['output_folder'],\
                  'neuron_figs', '%s.png' % neur))
    ax_all.axis('equal')
    ax.axis(ext_sim_dict['plot_range'])
    ax_all.set_xlabel('z [mm]')
    ax_all.set_ylabel('y [mm]')
    ax_all.legend()
    fig_all.savefig(os.path.join(neural_sim_dict['output_folder'], 'fig.png'))
Example #5
0
def plotEventTime(library, num, eventNames, sizes, times, events, filename = None):
  from pylab import close, legend, plot, savefig, show, title, xlabel, ylabel
  import numpy as np

  close()
  arches = sizes.keys()
  bs     = events[arches[0]].keys()[0]
  data   = []
  names  = []
  for event, color in zip(eventNames, ['b', 'g', 'r', 'y']):
    for arch, style in zip(arches, ['-', ':']):
      if event in events[arch][bs]:
        names.append(arch+'-'+str(bs)+' '+event)
        data.append(sizes[arch][bs])
        data.append(np.array(events[arch][bs][event])[:,0])
        data.append(color+style)
      else:
        print 'Could not find %s in %s-%d events' % (event, arch, bs)
  print data
  plot(*data)
  title('Performance on '+library+' Example '+str(num))
  xlabel('Number of Dof')
  ylabel('Time (s)')
  legend(names, 'upper left', shadow = True)
  if filename is None:
    show()
  else:
    savefig(filename)
  return
Example #6
0
def manhattonPlot(phenotype_ID, pvalues_lm, ouFprefix, pos, chromBounds):
    for ip, p_ID in enumerate(phenotype_ID):
        pl.figure(figsize=[12,4])
        plot_manhattan(posCum=pos['pos_cum'],pv=pvalues_lm[p_ID].values,chromBounds=chromBounds,thr_plotting=0.05)
        pl.title(p_ID)
        pl.savefig(ouFprefix + '.' + p_ID + '.pdf')
        pl.close('all')
Example #7
0
 def testTelescope(self):
     import matplotlib
     matplotlib.use('AGG')
     import matplotlib.mlab as ml
     import pylab as pl
     import time        
     w0 = 8.0
     k = 2*np.pi/3.0
     gb = GaussianBeam(w0, k)
     lens = ThinLens(150, 150)
     gb2 = lens*gb
     self.assertAlmostEqual(gb2._z0, gb._z0 + 2*150.0)
     lens2 = ThinLens(300, 600)
     gb3 = lens2*gb2
     self.assertAlmostEqual(gb3._z0, gb2._z0 + 2*300.0)
     self.assertAlmostEqual(gb._w0, gb3._w0/2.0)
     z = np.arange(0, 150)
     z2 = np.arange(150, 600)
     z3 = np.arange(600, 900)
     pl.plot(z, gb.w(z, k), z2, gb2.w(z2, k), z3, gb3.w(z3, k))
     pl.grid()
     pl.xlabel('z')
     pl.ylabel('w')
     pl.savefig('testTelescope1.png')
     time.sleep(0.1)
     pl.close('all')        
Example #8
0
    def plot(self, outputDirectory):
        """
        Plot both the raw kinetics data and the Arrhenius fit versus 
        temperature. The plot is saved to the file ``kinetics.pdf`` in the
        output directory. The plot is not generated if ``matplotlib`` is not
        installed.
        """
        # Skip this step if matplotlib is not installed
        try:
            import pylab
        except ImportError:
            return

        Tlist = 1000.0/numpy.arange(0.4, 3.35, 0.05)
        klist = numpy.zeros_like(Tlist)
        klist2 = numpy.zeros_like(Tlist)
        for i in range(Tlist.shape[0]):
            klist[i] = self.reaction.calculateTSTRateCoefficient(Tlist[i])
            klist2[i] = self.reaction.kinetics.getRateCoefficient(Tlist[i])

        order = len(self.reaction.reactants)
        klist *= 1e6 ** (order-1)
        klist2 *= 1e6 ** (order-1)

        pylab.semilogy(1000.0 / Tlist, klist, 'ok')
        pylab.semilogy(1000.0 / Tlist, klist2, '-k')
        pylab.xlabel('1000 / Temperature (1000/K)')
        pylab.ylabel('Rate coefficient ({0})'.format(self.kunits))
        pylab.savefig(os.path.join(outputDirectory, 'kinetics.pdf'))
        pylab.close()
    def log_posterior(self,theta):

        model_g1 , model_g2, limit_mask , _ , _ = self.draw_model(theta)

        likelihood = self.log_likelihood(model_g1,model_g2,limit_mask)
        prior = self.log_prior(theta)
        if not np.isfinite(prior):
            posterior = -np.inf
        else:
            # use no info from prior for now
            posterior = likelihood 

        if logger.level == logging.DEBUG:
            n_progress = 10
        elif logger.level == logging.INFO:
            n_progress = 1000
        if self.n_model_evals % n_progress == 0:

            logger.info('%7d post=% 2.8e like=% 2.8e prior=% 2.4e M200=% 6.3e ' % (self.n_model_evals,posterior,likelihood,prior,theta[0]))

        if np.isnan(posterior):
            import pdb; pdb.set_trace()

        if self.save_all_models:

            self.plot_residual_g1g2(model_g1,model_g2,limit_mask)

            pl.suptitle('model post=% 10.8e M200=%5.2e' % (posterior,theta[0]) )
            filename_fig = 'models/res2.%04d.png' % self.n_model_evals
            pl.savefig(filename_fig)
            logger.debug('saved %s' % filename_fig)
            pl.close()


        return posterior
Example #10
0
 def save(self, name=None, format="png", dirc=None):
     """Saves Bloch sphere to file of type ``format`` in directory ``dirc``.
     
     Parameters
     ----------
     
     name : str 
         Name of saved image. Must include path and format as well.
         i.e. '/Users/Paul/Desktop/bloch.png'
         This overrides the 'format' and 'dirc' arguments.
     format : str 
         Format of output image.  
     dirc : str
         Directory for output images. Defaults to current working directory.
     
     Returns
     ------- 
     File containing plot of Bloch sphere.
     
     """
     self.make_sphere()
     if dirc:
         if not os.path.isdir(os.getcwd() + "/" + str(dirc)):
             os.makedirs(os.getcwd() + "/" + str(dirc))
     if name == None:
         if dirc:
             savefig(os.getcwd() + "/" + str(dirc) + "/bloch_" + str(self.savenum) + "." + format)
         else:
             savefig(os.getcwd() + "/bloch_" + str(self.savenum) + "." + format)
     else:
         savefig(name)
     self.savenum += 1
     if self.fig:
         close(self.fig)
Example #11
0
    def plot(self, filesuffix=('.png',)):

        pylab.figure()

        kPluses = 10**numpy.linspace(0, 3, 100)
        kMinuses = 10**numpy.linspace(6, 9, 100)
        figureOfMerits = numpy.zeros((len(kPluses), len(kMinuses), 4), 'd')
        for i, kPlus in enumerate(kPluses):
            for j, kMinus in enumerate(kMinuses):
                figureOfMerits[i, j, :] = self.figureOfMerit(self.generateData({'kPlus' : kPlus, 'kMinus' : kMinus}))
        data = self.generateData({'kPlus' : kPluses[0], 'kMinus' : kMinuses[0]})

        self._contourf(kMinuses, kPluses, figureOfMerits, data)

        pylab.xticks((10**6, 10**7, 10**8, 10**9), fontsize=self.fontsize)
        pylab.yticks((10**0, 10**1, 10**2, 10**3), fontsize=self.fontsize)
        pylab.xlabel(r'$k^-$ $\left(1\per\metre\right)$', fontsize=self.fontsize)
        pylab.ylabel(r'$k^+$ $\left(\power{\metre}{3}\per\mole\cdot\second\right)$', fontsize=self.fontsize)

        pylab.text(2 * 10**6, 7 * 10**2, r'I', fontsize=self.fontsize)
        pylab.text(3 * 10**7, 7 * 10**2, r'II', fontsize=self.fontsize)
        pylab.text(6 * 10**8, 7 * 10**2, r'III', fontsize=self.fontsize)
        pylab.text(6 * 10**8, 7 * 10**1, r'IV', fontsize=self.fontsize)

        for fP, kPlus, paxeslabel in ((1.143,3.51e+00, False), (0.975, 9.33e+00, False), (0.916, 3.51e+01, False), (0.89, 9.33e+01, False), (0.87, 3.51e+02, True)):
            for fM, kMinus, maxeslabel in ((1.4, 2.48e+06, False), (1.07, 7.05e+6, False), (0.96, 2.48e+07, False), (0.91, 7.05e+7, False), (0.88, 2.48e+08, True)):
                xpos = (numpy.log10(kMinus) - 6.) / 3. *  fM
                ypos = numpy.log10(kPlus) / 3. * fP        
                self.makeBackGroundPlot({'kPlus' : kPlus, 'kMinus' : kMinus}, xpos, ypos, axeslabel=paxeslabel and maxeslabel)

        for fs in filesuffix:
            pylab.savefig('kPlusVkMinus' + fs)
            pylab.close('all')
Example #12
0
def plot_cumulative_score(smod,
                          seqs,
                          size=(6, 2),
                          fname=None):
    """plot_cumulative_score."""
    sig = cumulative_score(seqs, smod)
    plt.figure(figsize=size)
    sigp = np.copy(sig)
    sigp[sigp < 0] = 0
    plt.bar(range(len(sigp)), sigp, alpha=0.3, color='g')
    sign = np.copy(sig)
    sign[sign >= 0] = 0
    plt.bar(range(len(sign)), sign, alpha=0.3, color='r')
    plt.grid()
    plt.xlabel('Position')
    plt.ylabel('Importance score')
    if fname:
        plt.draw()
        figname = '%s_importance.png' % (fname)
        plt.savefig(
            figname, bbox_inches='tight', transparent=True, pad_inches=0)
    else:
        figname = None
        plt.show()
    plt.close()
    return figname
Example #13
0
def plot_anat(brain):
    import os.path
    import pylab as pl
    from nibabel import load
    from nipy.labs import viz   
    import numpy as np

    img = load(brain)
    data = img.get_data()
    data[np.isnan(data)] = 0
    affine = img.get_affine() 
    viz.plot_anat(anat=data, anat_affine=affine, draw_cross=False, slicer='x')
    
    x_view = os.path.abspath('x_view.png')
    y_view = os.path.abspath('y_view.png')
    z_view = os.path.abspath('z_view.png')
    
    pl.savefig(x_view,bbox_inches='tight')
    
    viz.plot_anat(anat=data, anat_affine=affine, draw_cross=False, slicer='y')
    pl.savefig(y_view,bbox_inches='tight')
    
    viz.plot_anat(anat=data, anat_affine=affine, draw_cross=False, slicer='z')
    pl.savefig(z_view,bbox_inches='tight')
    
    images = [x_view, y_view, z_view]
    pl.close()
    return images
Example #14
0
def plot_location(needle, haystack,
                  cluster_id=None, nbins=20, size=(17, 2), fname=None):
    """plot_location."""
    locs = []
    for h, s in haystack:
        for match in re.finditer(needle, s):
            s = match.start()
            e = match.end()
            m = s + (e - s) / 2
            locs.append(m)
    plt.figure(figsize=size)
    n, bins, patches = plt.hist(
        locs, nbins, normed=0, facecolor='blue', alpha=0.3)
    plt.grid()
    plt.title(needle)
    plt.xlabel('Position')
    plt.ylabel('Num occurrences')
    if fname:
        plt.draw()
        figname = '%s_loc_%d.png' % (fname, cluster_id)
        plt.savefig(
            figname, bbox_inches='tight', transparent=True, pad_inches=0)
    else:
        figname = None
        plt.show()
    plt.close()
    return figname
Example #15
0
def plot_distance(cluster_id_i,
                  cluster_id_j,
                  regex_i,
                  regex_j,
                  distances,
                  nbins=5,
                  size=(6, 2),
                  fname=None):
    """plot_distance."""
    ds = distances[(cluster_id_i, cluster_id_j)]
    plt.figure(figsize=size)
    n, bins, patches = plt.hist(
        ds, nbins, normed=0, facecolor='green', alpha=0.3)
    plt.grid()
    plt.title('%s vs %s' % (regex_i, regex_j))
    plt.xlabel('Relative position')
    plt.ylabel('Num occurrences')
    if fname:
        plt.draw()
        figname = '%s_dist_%d_vs_%d.png' % (fname, cluster_id_i, cluster_id_j)
        plt.savefig(
            figname, bbox_inches='tight', transparent=True, pad_inches=0)
    else:
        figname = None
        plt.show()
    plt.close()
    return figname
Example #16
0
def mamPlot(funct,args):
	pl=args[0]
	x=np.array([])
	ymin=np.array([])
	yavg=np.array([])
	ymax=np.array([])
	f=np.array([])
	x=np.append(x,funct.rmsSet[:,0])
	ymin=np.append(ymin,funct.rmsSet[:,1])
	ymax=np.append(ymax,funct.rmsSet[:,2])
	t1=funct.rmsSet[:,3]
	t2=funct.rmsSet[:,5]
	yavg=np.append(yavg,t1/t2)
	f=np.append(f,funct.rmsSet[:,5])
	if centroidP(x,yavg):
		pl.set_yscale('log')
		pl.set_xscale('log')
	else:
		pl.ticklabel_format(axis='both', style='sci', scilimits=(-2,5),pad=5,direction="bottom")
	pl.axis([0, np.amax(x)+(2*np.amax(x)/100), 0, np.amax(ymax)+(2*np.amax(ymax)/100)])
	pl.set_xlabel('read memory size',fontsize=8)
	pl.set_ylabel("cost",fontsize=8)
	pl.grid(True)
	pl.set_title("Min/Avg/Max Cost",fontsize=14)
	pl.tick_params(axis='x', labelsize=7)
	pl.tick_params(axis='y', labelsize=7)
	sc=pl.scatter(x,ymax,s=7,c='r', marker = 'o',lw=0.0)
	sc1=pl.scatter(x,yavg,s=5.5,c='g', marker = 'o',lw=0.0)	
	sc2=pl.scatter(x,ymin,s=4,c='b', marker = 'o',lw=0.0)	
	pl.legend((sc2,sc1,sc),("Min","Avg","Max"),scatterpoints=1,ncol=3,bbox_to_anchor=[0.5, mamAdjust],loc="lower center",fontsize=8)
	pylab.close()
Example #17
0
def CostVariancePlot(funct,args):
	pl=args[0]
	x=np.array([])
	y=np.array([])
	f=np.array([])
	z=np.array([])
	x=np.append(x,funct.rmsSet[:,0])
	y=np.append(y,funct.rmsSet[:,3])
	f=np.append(f,funct.rmsSet[:,5])
	z=np.append(z,funct.rmsSet[:,4])
	v=np.array([])
	v=np.append(v,[0])
	i=0
	while i<len(x):
		v=np.append(v,(z[i]/f[i])-(y[i]/f[i])*(y[i]/f[i]))
		i+=1
	v=np.delete(v,0)
	if centroidP(x,v):
		pl.set_yscale('log')
		pl.set_xscale('log') 
	else:
		pl.ticklabel_format(axis='both', style='sci', scilimits=(-2,5),pad=5,direction="bottom")
	pl.axis([0, np.amax(x)+(10*np.amax(x)/100), 0, np.amax(v)+(10*np.amax(v)/100)])
	pl.set_xlabel("read memory size",fontsize=8)
	pl.set_ylabel("cost",fontsize=8)
	pl.set_title("Variance Cost",fontsize=14)
	pl.grid(True)
	pl.tick_params(axis='x', labelsize=7)
	pl.tick_params(axis='y', labelsize=7)
	sc=pl.scatter(x,v,c=f,s=6,marker = 'o',lw=0.0,cmap=cmap,norm=norm)
	pylab.close()		
Example #18
0
def explore_data(data, images, target):

	# try to determine the type of data...
	print "data_type belonging to key data:"
	try: 
		print np.dtype(data)
	except TypeError as err:
		print err
	
	print "It has dimension", np.shape(data)

	# plot a 3
	
	# get indices of all threes in target
	threes = np.where(target == 3)
	#assert threes is not empty
	assert(len(threes) > 0)
	# choose the first 3
	three_indx = threes[0]
	# get the image
	img = images[three_indx][0]

	#plot it
	plot.figure()
	plot.gray()
	plot.imshow(img, interpolation = "nearest")
	plot.show()
	plot.close()
def plot_worker(jobq,mask,pid,lineshape,range):
    '''
    args[0] = array file name
    args[1] = output figure name
    if mask, where masked==0 is masked
    '''

    if lineshape:
        lines = shapefile.load_shape_list(lineshape)
    else:
        lines = None
    while True:
        #--get some args from the queue
        args = jobq.get()
        #--check if this is a sentenial
        if args == None:
            break
        #--load
        if args[2]:
            arr = np.fromfile(args[0],dtype=np.float32)
            arr.resize(bro.nrow,bro.ncol)
        else:
            arr = np.loadtxt(args[0])
        
        if mask != None:
            arr = np.ma.masked_where(mask==0,arr)        
        #print args[0],arr.min(),arr.max(),arr.mean()
        #--generic plotting
        fig = pylab.figure()
        ax = pylab.subplot(1,1,1,aspect='equal')
        
        if range:
            vmax = range[1]
            vmin = range[0]
        else:
            vmax = arr.max()
            vmin = arr.min()

        #p = ax.imshow(arr,interpolation='none')        
        p = ax.pcolor(bro.X,bro.Y,np.flipud(arr),vmax=vmax,vmin=vmin)
        pylab.colorbar(p)
        if lines:
            for line in lines:
                ax.plot(line[0,:],line[1,:],'k-',lw=1.0)
                #break
        ax.set_xticklabels([])
        ax.set_yticklabels([])
        ax.set_xlim(bro.plt_x)
        ax.set_ylim(bro.plt_y)
        ax.set_title(args[0])
        fmt = args[1].split('.')[-1]
        pylab.savefig(args[1],dpi=300,format=fmt)
        pylab.close(fig)
        #--mark this task as done
        jobq.task_done()
        print 'plot worker',pid,' finished',args[0]

    #--mark the sentenial as done
    jobq.task_done()
    return
Example #20
0
def arcRVs(booSave = False, booShow = True, booFit = False):
    arcRVs = np.load('npy/arcRVs.npy')
    MJDs = np.load('npy/JDs.npy')
    
    colors = ['b','g','r','c']

    for epoch,MJD in enumerate(MJDs):
        for cam in range(4):
            y = arcRVs[:,epoch,cam]
            plt.plot(y,'.'+colors[cam])
            if booFit==True:
                x = np.arange(len(y))
                p = np.polyfit(x[-np.isnan(y)],y[-np.isnan(y)],1)
                plt.plot(x,x*p[0]+p[1])
                
        plt.title('MJD='+str(MJD))
        if booSave==True: 
            try:
                plotName = 'plots/arcRVs_'+str(epoch)
                print 'Attempting to save', plotName
                plt.savefig(plotName)

            except Exception,e: 
                print str(e)
                print 'FAILED'
        if booShow==True: plt.show()
        plt.close()        
Example #21
0
def generate_glassbrain_image(image_pk):
    from neurovault.apps.statmaps.models import Image
    import neurovault
    import matplotlib as mpl
    mpl.rcParams['savefig.format'] = 'jpg'
    my_dpi = 50
    fig = plt.figure(figsize=(330.0/my_dpi, 130.0/my_dpi), dpi=my_dpi)
    
    img = Image.objects.get(pk=image_pk)    
    f = BytesIO()
    try:
        glass_brain = plot_glass_brain(img.file.path, figure=fig)
        glass_brain.savefig(f, dpi=my_dpi)
    except:
        # Glass brains that do not produce will be given dummy image
        this_path = os.path.abspath(os.path.dirname(__file__))
        f = open(os.path.abspath(os.path.join(this_path,
                                              "static","images","glass_brain_empty.jpg"))) 
        raise
    finally:
        plt.close('all')
        f.seek(0)
        content_file = ContentFile(f.read())
        img.thumbnail.save("glass_brain_%s.jpg" % img.pk, content_file)
        img.save()
def plot_quality_scores(pp, data):
    names = data.keys()

    # Plot mean quality
    for name in names:

        mean_quality = data[name][QUALITY_SCORE_NAME]['mean_quality']
        indices = range(0, len(mean_quality))
        pl.plot(indices, mean_quality, linewidth=2)

    pl.ylim([0, 40])
    pl.xlabel("Base position")
    pl.ylabel("Mean Phred Score")
    pl.title("Mean quality score by position")
    pl.legend(names, loc="lower left")
    pl.savefig(pp, format='pdf')
    pl.close()

    # Plot >q30 fraction
    for name in names:

        q30_fraction = data[name][QUALITY_SCORE_NAME]['fraction_q30']
        indices = range(0, len(q30_fraction))
        pl.plot(indices, q30_fraction)

    pl.xlabel("Base position")
    pl.ylabel("Fraction at least Q30")
    pl.title("Fraction of bases at least Q30")
    pl.legend(names, loc="lower left")
    pl.savefig(pp, format='pdf')
    pl.close()    
def plot_gc_distribution(pp, data):
    names = data.keys()

    # Plot the 2D histogram of coverage vs gc
    for name in names:
        x = [ i * 100 for i in data[name][GC_DISTRIBUTION_NAME]['gc_samples'] ]
        y = data[name][GC_DISTRIBUTION_NAME]['cov_samples']
        

        # Use the median to determine the range to show and round
        # to nearest 100 to avoid aliasing artefacts 
        m = np.median(y)
        y_limit = math.ceil( 2*m / 100) * 100
        hist,xedges,yedges = np.histogram2d(x,y, bins=[20, 50], range=[ [0, 100.0], [0, y_limit] ])

        # draw the plot
        extent = [xedges[0], xedges[-1], yedges[0], yedges[-1] ]
        pl.imshow(hist.T,extent=extent,interpolation='nearest',origin='lower', aspect='auto')

        pl.colorbar()
        pl.title(name + ' GC Bias')
        pl.xlabel("GC %")
        pl.ylabel("k-mer coverage")
        pl.savefig(pp, format='pdf')
        pl.close()
def test(cv,model,data,user,code,comp):
    test_power=np.array([float(r[2+comp])/max_power for r in data ])
    times=[datetime.datetime.strptime(r[0],'%Y-%m-%d %H:%M:%S UTC') for r in data]
    features=np.array([d[8:] for d in data],dtype=np.float)
    features[:,0]=features[:,0]/time_scale
    jobs=list(set([(r[1],r[2]) for r in data]))
    name_features=cv.transform([d[2] for d in data]).toarray()
    features=np.hstack((features,name_features))
    job_ids=[r[1] for r in data]
    prediction=model.predict(features)
    rmse=math.sqrt(np.average(((prediction-test_power)*max_power)**2))
    nrmse=math.sqrt(np.average(((prediction-test_power)/test_power)**2))
    corr=np.corrcoef(prediction,test_power)[0,1]
    r2=1-(sum((prediction-test_power)**2)/sum((test_power-np.average(test_power))**2))
    pl.figure(figsize=(6,7))
    pl.subplot(211)
    pl.plot(prediction*max_power,test_power*max_power,'+')
    if math.isnan(corr) or  math.isnan(r2) or math.isnan(rmse): 
        pl.title("RMSPE="+str(nrmse)+"RMSE="+str(rmse)+" Corr="+str(corr)+" R2="+str(r2))
    else:
        pl.title("RMSPE="+str(int(nrmse*1000)/1000.0)+" RMSE="+str(int(rmse*1000)/1000.0)+" Corr="+str(int(corr*1000)/1000.0)+" R2="+str(int(r2*1000)/1000.0))
    pl.xlabel('Predicted power')
    pl.ylabel('Real power')
    pl.plot([max(pl.xlim()[0],pl.ylim()[0]),min(pl.xlim()[1],pl.ylim()[1])],[max(pl.xlim()[0],pl.ylim()[0]),min(pl.xlim()[1],pl.ylim()[1])])
    pl.subplot(212)
    pl.plot(test_power*max_power)
    pl.plot(prediction*max_power)
    pl.ylabel('Power')
    pl.xlabel('Data point')
    #pl.legend(('Real power','Predicted power'))
    pl.subplots_adjust(hspace=0.35)
    pl.savefig('results'+str(month)+'global'+str(min_train)+'/'+user+code+'.pdf')
    pl.close()
    pkl.dump((nrmse,rmse,corr,r2,prediction*max_power,test_power*max_power,times,job_ids),file=gzip.open('results'+str(month)+'global'+str(min_train)+'/'+user+'test'+code+'.pkl.gz','w'))
    return prediction*max_power
Example #25
0
def on_key_press(event):
    global old_t
    new_t=time.time()
    print old_t-new_t
    old_t=new_t
    if event.key == '+':
        a = axis()
        w = a[1] - a[0]
        axis([a[0] + w * .2, a[1] - w * .2, a[2], a[3]])
        draw()

    if event.key in ['-', '\'']:
        a = axis()
        w = a[1] - a[0]
        axis([a[0] - w / 3.0, a[1] + w / 3.0, a[2], a[3]])
        draw()

    if event.key == '.':
        a = axis()
        w = a[1] - a[0]
        axis([a[0] + w * .2, a[1] + w * .2, a[2], a[3]])
        draw()

    if event.key == ',':
        a = axis()
        w = a[1] - a[0]
        axis([a[0] - w * .2, a[1] - w * .2, a[2], a[3]])
        draw()

    if event.key == 'q':
        close()
def plot_values(X, Y, xlabel, ylabel, suffix, ptype='plot'):
    output_filename = constants.ATTRACTIVENESS_FOLDER_NAME + constants.DATASET + '_' + suffix

    X1 = [X[i] for i in range(len(X)) if X[i]>0 and Y[i]>0]
    Y1 = [Y[i] for i in range(len(X)) if X[i]>0 and Y[i]>0]
    X = X1
    Y = Y1
    
    pylab.close("all")
    
    pylab.figure(figsize=(8, 7))

    #pylab.rcParams.update({'font.size': 20})

    pylab.scatter(X, Y)
    
    #pylab.axis(vis.get_bounds(X, Y, False, False))

    #pylab.xscale('log')
    pylab.yscale('log')

    pylab.xlabel(xlabel)
    pylab.ylabel(ylabel)   
    #pylab.xlim(0.1,1)
    #pylab.ylim(ymin=0.01)
    #pylab.tight_layout()

    pylab.savefig(output_filename + '.pdf')
Example #27
0
def main():
    base_path = "/caps2/tsupinie/1kmf-control/"
    temp = goshen_1km_temporal(start=14400, end=14400)
    grid = goshen_1km_grid()
    n_ens_members = 40

    np.seterr(all='ignore')

    ens = loadEnsemble(base_path, [ 11 ], temp.getTimes(), ([ 'pt', 'p' ], computeDensity))
    ens = ens[0, 0]

    zs = decompressVariable(nio.open_file("%s/ena001.hdfgrdbas" % base_path, mode='r', format='hdf').variables['zp'])
    xs, ys = grid.getXY()
    xs = xs[np.newaxis, ...].repeat(zs.shape[0], axis=0)
    ys = ys[np.newaxis, ...].repeat(zs.shape[0], axis=0)

    eff_buoy = effectiveBuoyancy(ens, (zs, ys, xs), plane={'z':10})
    print eff_buoy

    pylab.figure()
    pylab.contourf(xs[0], ys[0], eff_buoy[0], cmap=matplotlib.cm.get_cmap('RdBu_r'))
    pylab.colorbar()

    grid.drawPolitical()

    pylab.suptitle("Effective Buoyancy")
    pylab.savefig("eff_buoy.png")
    pylab.close()
    return
def plot_fragment_sizes(pp, data):

    # Trim outliers from the histograms
    names = data.keys()
    for name in names:
        h = data[name][FRAGMENT_SIZE_NAME]['sizes']
        sizes = {}
        for i in h:
            if i not in sizes:
                sizes[i] = 1
            else:
                sizes[i] += 1
        n = len(h)
        x = list()
        y = list()
        sum  = 0
        for i,j in sorted(sizes.items()):
            f = float(j) / n
            x.append(i)
            y.append(f)
            sum += f
        pl.plot(x, y)

    pl.xlim([0, 1000])
    pl.xlabel("Fragment Size (bp)")
    pl.ylabel("Proportion")
    pl.title("Estimated Fragment Size Histogram")
    pl.legend(names)
    pl.savefig(pp, format='pdf')
    pl.close()    
Example #29
0
    def test_varying_inclination(self):
        #""" Test that the waveform is consistent for changes in inclination
        #"""
        sigmas = []
        incs = numpy.arange(0, 21, 1.0) * lal.PI / 10.0

        for inc in incs:
            # WARNING: This does not properly handle the case of SpinTaylor*
            # where the spin orientation is not relative to the inclination
            hp, hc = get_waveform(self.p, inclination=inc)
            s = sigma(hp, low_frequency_cutoff=self.p.f_lower)        
            sigmas.append(s)
         
        f = pylab.figure()
        pylab.axes([.1, .2, 0.8, 0.70])   
        pylab.plot(incs, sigmas)
        pylab.title("Vary %s inclination, $\\tilde{h}$+" % self.p.approximant)
        pylab.xlabel("Inclination (radians)")
        pylab.ylabel("sigma (flat PSD)")
        
        info = self.version_txt
        pylab.figtext(0.05, 0.05, info)
        
        if self.save_plots:
            pname = self.plot_dir + "/%s-vary-inclination.png" % self.p.approximant
            pylab.savefig(pname)

        if self.show_plots:
            pylab.show()
        else:
            pylab.close(f)

        self.assertAlmostEqual(sigmas[-1], sigmas[0], places=7)
        self.assertAlmostEqual(max(sigmas), sigmas[0], places=7)
        self.assertTrue(sigmas[0] > sigmas[5])
Example #30
0
def plot(x, z):             # plot input x versus convolution z
    pylab.close(1)
    pylab.figure(1)
    pylab.plot (x, 'b', label="sine")
    pylab.plot ([abs(i/max(z)) for i in z], 'r', label="convolution")
    pylab.title ("convolution of pure sine")
    pylab.legend()
Example #31
0
File: polar.py Project: o-hill/MVS
    trajectory = []
    ideal = []

    # Start at the origin.
    trajectory.append(movement.cartesian)
    ideal.append([ideal_num, ideal_num])

    for i in range(300):
        # Move the object to cartesian coordinates (3, 3)
        movement.move(delta)
        # Create a list of points the object visited.
        trajectory.append(movement.cartesian)
        # Create a list of the ideal path.
        ideal_num += ideal_delta
        ideal.append([ideal_num, ideal_num])

    # Create numpy arrays out of the coordinate lists.
    trajectory = np.array(trajectory)
    ideal = np.array(ideal)

    # Plot the lists.
    plt.close('all')
    plt.plot(trajectory[:, 0], trajectory[:, 1], label='polar')
    plt.plot(ideal[:, 0], ideal[:, 1], label='ideal')
    plt.legend()

    print("Final cartesian coordinates: " + str(movement.cartesian))

# --------------------------------------------------------------------------
Example #32
0
def manually_refine_components(Y,
                               xxx_todo_changeme,
                               A,
                               C,
                               Cn,
                               thr=0.9,
                               display_numbers=True,
                               max_number=None,
                               cmap=None,
                               **kwargs):
    """Plots contour of spatial components
     against a background image and allows to interactively add novel components by clicking with mouse

     Args:
         Y: ndarray
                   movie in 2D

         (dx,dy): tuple
                   dimensions of the square used to identify neurons (should be set to the galue of gsiz)

         A:   np.ndarray or sparse matrix
                   Matrix of Spatial components (d x K)

         Cn:  np.ndarray (2D)
                   Background image (e.g. mean, correlation)

         thr: scalar between 0 and 1
                   Energy threshold for computing contours (default 0.995)

         display_number:     Boolean
                   Display number of ROIs if checked (default True)

         max_number:    int
                   Display the number for only the first max_number components (default None, display all numbers)

         cmap:     string
                   User specifies the colormap (default None, default colormap)

     Returns:
         A: np.ndarray
             matrix A os estimated spatial component contributions

         C: np.ndarray
             array of estimated calcium traces
    """
    (dx, dy) = xxx_todo_changeme
    if issparse(A):
        A = np.array(A.todense())
    else:
        A = np.array(A)

    d1, d2 = np.shape(Cn)
    d, nr = np.shape(A)
    if max_number is None:
        max_number = nr

    x, y = np.mgrid[0:d1:1, 0:d2:1]

    pl.imshow(Cn, interpolation=None, cmap=cmap)
    cm = com(A, d1, d2)

    Bmat = np.zeros((np.minimum(nr, max_number), d1, d2))
    for i in range(np.minimum(nr, max_number)):
        indx = np.argsort(A[:, i], axis=None)[::-1]
        cumEn = np.cumsum(A[:, i].flatten()[indx]**2)
        cumEn /= cumEn[-1]
        Bvec = np.zeros(d)
        Bvec[indx] = cumEn
        Bmat[i] = np.reshape(Bvec, np.shape(Cn), order='F')

    T = np.shape(Y)[-1]

    pl.close()
    fig = pl.figure()
    ax = pl.gca()
    ax.imshow(Cn,
              interpolation=None,
              cmap=cmap,
              vmin=np.percentile(Cn[~np.isnan(Cn)], 1),
              vmax=np.percentile(Cn[~np.isnan(Cn)], 99))
    for i in range(np.minimum(nr, max_number)):
        pl.contour(y, x, Bmat[i], [thr])

    if display_numbers:
        for i in range(np.minimum(nr, max_number)):
            ax.text(cm[i, 1], cm[i, 0], str(i + 1))

    A3 = np.reshape(A, (d1, d2, nr), order='F')
    while True:
        pts = fig.ginput(1, timeout=0)

        if pts != []:
            print(pts)
            xx, yy = np.round(pts[0]).astype(np.int)
            coords_y = np.array(list(range(yy - dy, yy + dy + 1)))
            coords_x = np.array(list(range(xx - dx, xx + dx + 1)))
            coords_y = coords_y[(coords_y >= 0) & (coords_y < d1)]
            coords_x = coords_x[(coords_x >= 0) & (coords_x < d2)]
            a3_tiny = A3[coords_y[0]:coords_y[-1] + 1,
                         coords_x[0]:coords_x[-1] + 1, :]
            y3_tiny = Y[coords_y[0]:coords_y[-1] + 1,
                        coords_x[0]:coords_x[-1] + 1, :]

            dy_sz, dx_sz = np.shape(a3_tiny)[:-1]
            y2_tiny = np.reshape(y3_tiny, (dx_sz * dy_sz, T), order='F')
            a2_tiny = np.reshape(a3_tiny, (dx_sz * dy_sz, nr), order='F')
            y2_res = y2_tiny - a2_tiny.dot(C)

            y3_res = np.reshape(y2_res, (dy_sz, dx_sz, T), order='F')
            a__, c__, center__, b_in__, f_in__ = greedyROI(
                y3_res,
                nr=1,
                gSig=[
                    np.floor(old_div(dx_sz, 2)),
                    np.floor(old_div(dy_sz, 2))
                ],
                gSiz=[dx_sz, dy_sz])

            a_f = np.zeros((d, 1))
            idxs = np.meshgrid(coords_y, coords_x)
            a_f[np.ravel_multi_index(idxs, (d1, d2),
                                     order='F').flatten()] = a__

            A = np.concatenate([A, a_f], axis=1)
            C = np.concatenate([C, c__], axis=0)
            indx = np.argsort(a_f, axis=None)[::-1]
            cumEn = np.cumsum(a_f.flatten()[indx]**2)
            cumEn /= cumEn[-1]
            Bvec = np.zeros(d)
            Bvec[indx] = cumEn
            bmat = np.reshape(Bvec, np.shape(Cn), order='F')
            pl.contour(y, x, bmat, [thr])
            pl.pause(.01)

        elif pts == []:
            break

        nr += 1
        A3 = np.reshape(A, (d1, d2, nr), order='F')

    return A, C
Example #33
0
        xpositions = y[:, 0]
        ypositions = y[:, 1]

        plot.clf()

        if LABELS:
            for x, y, nr in zip(xpositions, ypositions,
                                range(len(xpositions))):
                plot.scatter(x, y, 2, marker='*', color='green')
                plot.annotate(nr, xy=(x, y), size=2, color='green')
            out = "{}_{}_labels".format(word, year)
        else:
            plot.scatter(xpositions, ypositions, 5, marker='*', color='green')
            out = "{}_{}".format(word, year)
        plot.tick_params(axis='x',
                         which='both',
                         bottom=False,
                         top=False,
                         labelbottom=False)
        plot.tick_params(axis='y',
                         which='both',
                         left=False,
                         right=False,
                         labelleft=False)
        plot.title("{} in {}'s".format(word, year))

        plot.savefig(out + '_PCA.png', dpi=300, bbox_inches='tight')
        plot.close()
        plot.clf()
Example #34
0
def plot_seis(stat, filename, label, units, outfile, rrup=None):
    """
    Plots the seismogram for station stat, and outputs a png file outfile
    """
    ts1 = []
    ns1 = []
    ew1 = []
    ver1 = []

    cmt1 = ["", ""]

    # Read input file
    input_file = open(filename, 'r')
    for data in input_file:
        # Remove leading spaces
        data = data.strip()
        # Skip comments
        if data.startswith('#') or data.startswith('%'):
            if cmt1[0] == "":
                cmt1[0] = data
        else:
            tmp = []
            tmp = data.split()
            ts1.append(float(tmp[0]))
            ns1.append(float(tmp[1]))
            ew1.append(float(tmp[2]))
            ver1.append(float(tmp[3]))
    # Don't forget to close the file
    input_file.close()

    min_x, max_x = calculate_x_coords(ts1, rrup)
    min_horiz_y = 1.1 * min([min(ns1), min(ew1)])
    max_horiz_y = 1.1 * max([max(ns1), max(ew1)])
    min_vert_y = 1.1 * min(ver1)
    max_vert_y = 1.1 * max(ver1)

    pylab.clf()
    pylab.suptitle('Seismograms for run %s, station %s' %
                   (label, stat), size=14)
    pylab.subplots_adjust(hspace=0.4)
    pylab.subplot(311, title='N/S')
    pylab.plot(ts1, ns1, lw=plot_config.line_width)
    pylab.xlim(min_x, max_x)
    pylab.ylim(min_horiz_y, max_horiz_y)
    if units == 'vel':
        pylab.ylabel("Velocity (cm/s)")
    elif units == 'acc':
        pylab.ylabel("Acceleration (cm/s/s)")

    pylab.subplot(312, title='E/W')
    pylab.plot(ts1, ew1, lw=plot_config.line_width)
    pylab.xlim(min_x, max_x)
    pylab.ylim(min_horiz_y, max_horiz_y)
    if units == 'vel':
        pylab.ylabel("Velocity (cm/s)")
    elif units == 'acc':
        pylab.ylabel("Acceleration (cm/s/s)")

    pylab.subplot(313, title='Ver')
    pylab.plot(ts1, ver1, lw=plot_config.line_width)
    pylab.xlim(min_x, max_x)
    pylab.ylim(min_vert_y, max_vert_y)
    if units == 'vel':
        pylab.ylabel("Velocity (cm/s)")
    elif units == 'acc':
        pylab.ylabel("Acceleration (cm/s/s)")

    pylab.gcf().set_size_inches(6, 7)
    pylab.savefig(outfile, format="png", dpi=plot_config.dpi)
    pylab.close()
Example #35
0
def plot_overlay_with_arias(stat, obs_filename, comp_filename,
                            obs_arias_n_filename, obs_arias_e_filename,
                            obs_arias_z_filename, comp_arias_n_filename,
                            comp_arias_e_filename, comp_arias_z_filename,
                            obs_label, comp_label, outfile, rrup=None,
                            y_label="Velocity (cm/s)",
                            goflabel=None, gofdata=None):
    """
    This function plots observed and computed seismograms side by side
    for easy comparison
    """
    # Initialize variables
    textx = 0.53
    texty = 0.05
    fig = pylab.plt.figure()
    fig.clf()

    # Read all files
    (ts1, ns1, ew1, ver1) = read_seismogram_file(obs_filename)
    (ts2, ns2, ew2, ver2) = read_seismogram_file(comp_filename)
    ta1, tmp1, tmp2, an1 = read_seismogram_file(obs_arias_n_filename)
    ta1, tmp1, tmp2, ae1 = read_seismogram_file(obs_arias_e_filename)
    ta1, tmp1, tmp2, az1 = read_seismogram_file(obs_arias_z_filename)
    ta2, tmp1, tmp2, an2 = read_seismogram_file(comp_arias_n_filename)
    ta2, tmp1, tmp2, ae2 = read_seismogram_file(comp_arias_e_filename)
    ta2, tmp1, tmp2, az2 = read_seismogram_file(comp_arias_z_filename)

    # Determine min and max X and Y for N/S/E/W, and Ver, for scaling
    min_x = 0
    #max_x = min(max([max(ts1), max(ts2)]), 100)
    max_x = max([max(ts1), max(ts2)])
    min_horiz_y = 1.1 * min([min(ns1), min(ns2), min(ew1), min(ew2)])
    max_horiz_y = 1.1 * max([max(ns1), max(ns2), max(ew1), max(ew2)])

    # Adjust so min and max are equal
    if abs(min_horiz_y) > abs(max_horiz_y):
        max_horiz_y = -1 * min_horiz_y
    else:
        min_horiz_y = -1 * max_horiz_y

    min_vert_y = 1.1 * min([min(ver1), min(ver2)])
    max_vert_y = 1.1 * max([max(ver1), max(ver2)])

    if abs(min_vert_y) > abs(max_vert_y):
        max_vert_y = -1 * min_vert_y
    else:
        min_vert_y = -1 * max_vert_y
    # For arias plots, min=0, max=100%
    min_y_arias = 0
    max_y_arias = 100

    if goflabel is None or gofdata is None:
        fig.suptitle('%s vs. %s, station %s' % (obs_label, comp_label, stat), size=14)
    else:
        txt = '$%s_{%s}$=%.1f %%' % (goflabel[0], goflabel[1], gofdata[0])
        fig.suptitle('%s vs. %s, station %s (%s)' %
                     (obs_label, comp_label, stat, txt), size=14)
    fig.subplots_adjust(top=0.85)
    fig.subplots_adjust(left=0.075)
    fig.subplots_adjust(right=0.925)
    fig.subplots_adjust(hspace=0.4)
    fig.subplots_adjust(wspace=0.3)

    # FS: May 2013: for 3-comp plot below is #331
    ax = fig.add_subplot(321, title='%s, N/S' % obs_label)
    ax.plot(ts1, ns1, color='black', label=obs_label, lw=plot_config.line_width)
    ax.set_xlim(min_x, max_x)
    ax.set_ylim(min_horiz_y, max_horiz_y)
    ax.set_ylabel(y_label)
    # FS: May 2013: for 3-comp plot below is #334
    ax = fig.add_subplot(323, title='%s, N/S' % comp_label)
    ax.plot(ts2, ns2, color='red', label=comp_label, lw=plot_config.line_width)
    ax.set_xlim(min_x, max_x)
    ax.set_ylim(min_horiz_y, max_horiz_y)
    ax.set_ylabel(y_label)
#       print "GOFLABEL, GOFDATA", goflabel, gofdata
    if goflabel is not None and gofdata is not None:
        txt = '$%s_{%s}$=%.1f %%' % (goflabel[0], goflabel[1], gofdata[2])
        ax.text(textx, texty, txt, transform=ax.transAxes,
                bbox=dict(facecolor='red', alpha=0.5))

    #legend(prop=matplotlib.font_manager.FontProperties(size=10))
    # FS: May 2013: for 3-comp plot below is #332
    ax = fig.add_subplot(322, title='%s, E/W' % obs_label)
    ax.plot(ts1, ew1, color='black', label=obs_label, lw=plot_config.line_width)
    ax.set_xlim(min_x, max_x)
    ax.set_ylim(min_horiz_y, max_horiz_y)
    #ylabel(y_label)

    # FS: May 2013: for 3-comp plot below is #335
    ax = fig.add_subplot(324, title='%s, E/W' % comp_label)
    ax.plot(ts2, ew2, color='red', label=comp_label, lw=plot_config.line_width)
    ax.set_xlim(min_x, max_x)
    ax.set_ylim(min_horiz_y, max_horiz_y)
    if goflabel is not None and gofdata is not None:
        txt = '$%s_{%s}$=%.1f %%' % (goflabel[0], goflabel[1], gofdata[1])
        ax.text(textx, texty, txt, transform=ax.transAxes,
                bbox=dict(facecolor='red', alpha=0.5))
    #ylabel(y_label)
    #legend(prop=matplotlib.font_manager.FontProperties(size=10))

    # FS: May 2013: Code commented out to remove vertical component
    # ax = fig.add_subplot(333, title='%s, ver' % obs_label)
    # ax.plot(ts1, ver1, color='black', label=obs_label,
    #         lw=plot_config.line_width)
    # ax.set_xlim(min_x, max_x)
    # ax.set_ylim(min_vert_y, max_vert_y)
    # #ylabel(y_label)
    # ax = fig.add_subplot(336, title='%s, ver' % comp_label)
    # ax.plot(ts2, ver2, color='red', label=comp_label,
    #         lw=plot_config.line_width)
    # ax.set_xlim(min_x, max_x)
    # ax.set_ylim(min_vert_y, max_vert_y)
    # if goflabel is not None and gofdata is not None:
    #     txt = '$%s_{%s}$=%.1f %%' % (goflabel[0], goflabel[1], gofdata[3])
    #     ax.text(textx, texty, txt, transform=ax.transAxes,
    #             bbox=dict(facecolor='red', alpha=0.5))

    #Ylabel(y_label)
    #legend(prop=matplotlib.font_manager.FontProperties(size=10))
    # FS: May 2013: for 3-comp plot below is #337
    ax = fig.add_subplot(325, title='Arias N/S')
    ax.plot(ta1, an1, color='black', lw=plot_config.line_width)
    ax.plot(ta2, an2, color='red', lw=plot_config.line_width)
    ax.set_xlim(min_x, max_x)
    ax.set_ylim(min_y_arias, max_y_arias)
    ax.set_ylabel("Norm Arias Int (%)")

    # FS: May 2013: for 3-comp plot below is #338
    ax = fig.add_subplot(326, title='Arias E/W')
    ax.plot(ta1, ae1, color='black', lw=plot_config.line_width)
    ax.plot(ta2, ae2, color='red', lw=plot_config.line_width)
    ax.set_xlim(min_x, max_x)
    ax.set_ylim(min_y_arias, max_y_arias)

    # FS: May 2013: Code commented out to remove vertical component
    # ax = fig.add_subplot(339, title='Arias ver')
    # ax.plot(ta1, az1, color='black', lw=plot_config.line_width)
    # ax.plot(ta2, az2, color='red', lw=plot_config.line_width)
    # ax.set_xlim(min_x, max_x)
    # ax.set_ylim(min_y_arias, max_y_arias)

    pylab.gcf().set_size_inches(10, 7.5)
    pylab.savefig(outfile, format="png", dpi=plot_config.dpi)
    pylab.close()
Example #36
0
def plot_overlay(stat, obs_filename, comp_filename, obs_label, comp_label,
                 outfile, y_label="Velocity (cm/s)",
                 goflabel=None, gofdata=None):
    """
    This function plots observed and computed seismograms side by side
    for easy comparison
    """
    # Initialize variables
    textx = 0.53
    texty = 0.05
    fig = pylab.plt.figure()
    fig.clf()

    ts1, ns1, ew1, ver1 = read_seismogram_file(obs_filename)
    ts2, ns2, ew2, ver2 = read_seismogram_file(comp_filename)

    # Determine min and max X and Y for N/S/E/W, and Ver, for scaling
    min_x = 0
    max_x = min(max([max(ts1), max(ts2)]), 100)
    min_horiz_y = 1.1 * min([min(ns1), min(ns2), min(ew1), min(ew2)])
    max_horiz_y = 1.1 * max([max(ns1), max(ns2), max(ew1), max(ew2)])
    # Adjust so min and max are equal
    if abs(min_horiz_y) > abs(max_horiz_y):
        max_horiz_y = -1 * min_horiz_y
    else:
        min_horiz_y = -1 * max_horiz_y

    min_vert_y = 1.1 * min([min(ver1), min(ver2)])
    max_vert_y = 1.1 * max([max(ver1), max(ver2)])

    if abs(min_vert_y) > abs(max_vert_y):
        max_vert_y = -1 * min_vert_y
    else:
        min_vert_y = -1 * max_vert_y
    if goflabel is None or gofdata is None:
        fig.suptitle('%s vs. %s, station %s' % (obs_label, comp_label, stat), size=14)
    else:
        txt = '$%s_{%s}$=%.1f %%' % (goflabel[0], goflabel[1], gofdata[0])
        fig.suptitle('%s vs. %s, station %s (%s)' %
                     (obs_label, comp_label, stat, txt), size=14)
    fig.subplots_adjust(top=0.85)
    fig.subplots_adjust(left=0.075)
    fig.subplots_adjust(right=0.925)
    fig.subplots_adjust(hspace=0.3)
    fig.subplots_adjust(wspace=0.3)

    ax = fig.add_subplot(231, title='%s, N/S' % obs_label)
    ax.plot(ts1, ns1, color='black', label=obs_label, lw=plot_config.line_width)
    ax.set_xlim(min_x, max_x)
    ax.set_ylim(min_horiz_y, max_horiz_y)
    ax.set_ylabel(y_label)
    ax = fig.add_subplot(234, title='%s, N/S' % comp_label)
    ax.plot(ts2, ns2, color='red', label=comp_label, lw=plot_config.line_width)
    ax.set_xlim(min_x, max_x)
    ax.set_ylim(min_horiz_y, max_horiz_y)
    ax.set_ylabel(y_label)
#       print "GOFLABEL, GOFDATA", goflabel, gofdata
    if goflabel is not None and gofdata is not None:
        txt = '$%s_{%s}$=%.1f %%' % (goflabel[0], goflabel[1], gofdata[2])
        ax.text(textx, texty, txt, transform=ax.transAxes,
                bbox=dict(facecolor='red', alpha=0.5))

    #legend(prop=matplotlib.font_manager.FontProperties(size=10))

    ax = fig.add_subplot(232, title='%s, E/W' % obs_label)
    ax.plot(ts1, ew1, color='black', label=obs_label, lw=plot_config.line_width)
    ax.set_xlim(min_x, max_x)
    ax.set_ylim(min_horiz_y, max_horiz_y)
    #ylabel(y_label)
    ax = fig.add_subplot(235, title='%s, E/W' % comp_label)
    ax.plot(ts2, ew2, color='red', label=comp_label, lw=plot_config.line_width)
    ax.set_xlim(min_x, max_x)
    ax.set_ylim(min_horiz_y, max_horiz_y)
    if goflabel is not None and gofdata is not None:
        txt = '$%s_{%s}$=%.1f %%' % (goflabel[0], goflabel[1], gofdata[1])
        ax.text(textx, texty, txt, transform=ax.transAxes,
                bbox=dict(facecolor='red', alpha=0.5))
    #ylabel(y_label)
    #legend(prop=matplotlib.font_manager.FontProperties(size=10))

    ax = fig.add_subplot(233, title='%s, ver' % obs_label)
    ax.plot(ts1, ver1, color='black', label=obs_label,
            lw=plot_config.line_width)
    ax.set_xlim(min_x, max_x)
    ax.set_ylim(min_vert_y, max_vert_y)
    #ylabel(y_label)
    ax = fig.add_subplot(236, title='%s, ver' % comp_label)
    ax.plot(ts2, ver2, color='red', label=comp_label, lw=plot_config.line_width)
    ax.set_xlim(min_x, max_x)
    ax.set_ylim(min_vert_y, max_vert_y)
    if goflabel is not None and gofdata is not None:
        txt = '$%s_{%s}$=%.1f %%' % (goflabel[0], goflabel[1], gofdata[3])
        ax.text(textx, texty, txt, transform=ax.transAxes,
                bbox=dict(facecolor='red', alpha=0.5))
    #ylabel(y_label)
    #legend(prop=matplotlib.font_manager.FontProperties(size=10))

    pylab.gcf().set_size_inches(10, 5)
    pylab.savefig(outfile, format="png", dpi=plot_config.dpi)
    pylab.close()
Example #37
0
for counter, evtid in enumerate(evtids):
    if evt_plotted > max_evts:
        break
    run, subrun, gate, phys_evt = decode_eventid(evtid)
    print('{0} - {1} - {2} - {3}'.format(run, subrun, gate, phys_evt))
    targ = labels[counter]
    evt = []
    if data_x is not None:
        evt.append(data_x[counter])
    if data_u is not None:
        evt.append(data_u[counter])
    if data_v is not None:
        evt.append(data_v[counter])
    fig = pylab.figure(figsize=(9, 3))
    gs = pylab.GridSpec(1, len(evt))
    # print np.where(evt == np.max(evt))
    # print np.max(evt)
    for i in range(len(evt)):
        ax = pylab.subplot(gs[i])
        ax.axis('off')
        # images are normalized such the max e-dep has val 1, independent
        # of view, so set vmin, vmax here to keep matplotlib from
        # normalizing each view on its own
        ax.imshow(evt[i][0], cmap=pylab.get_cmap('jet'),
                  interpolation='nearest', vmin=0, vmax=1)
    figname = 'evt_%s_%s_%s_%s_targ_%d.pdf' % \
        (run, subrun, gate, phys_evt, targ)
    pylab.savefig(figname)
    pylab.close()
    evt_plotted += 1
    def Metallicity(self, G):

        print('Plotting the metallicities')

        seed(2222)

        plt.figure()  # New figure
        ax = plt.subplot(111)  # 1 plot on the figure

        w = np.where((G.Type == 0) & (G.ColdGas /
                                      (G.StellarMass + G.ColdGas) > 0.1)
                     & (G.StellarMass > 0.01))[0]
        if (len(w) > dilute): w = sample(w, dilute)

        mass = np.log10(G.StellarMass[w] * 1.0e10 / self.Hubble_h)
        Z = np.log10((G.MetalsColdGas[w] / G.ColdGas[w]) / 0.02) + 9.0

        plt.scatter(mass,
                    Z,
                    marker='o',
                    s=1,
                    c='k',
                    alpha=0.5,
                    label='Model galaxies')

        # overplot Tremonti et al. 2003 (h=0.7)
        w = np.arange(7.0, 13.0, 0.1)
        Zobs = -1.492 + 1.847 * w - 0.08026 * w * w
        if (whichimf == 0):
            # Conversion from Kroupa IMF to Slapeter IMF
            plt.plot(np.log10((10**w * 1.5)),
                     Zobs,
                     'b-',
                     lw=2.0,
                     label='Tremonti et al. 2003')
        elif (whichimf == 1):
            # Conversion from Kroupa IMF to Slapeter IMF to Chabrier IMF
            plt.plot(np.log10((10**w * 1.5 / 1.8)),
                     Zobs,
                     'b-',
                     lw=2.0,
                     label='Tremonti et al. 2003')

        plt.ylabel(r'$12\ +\ \log_{10}[\mathrm{O/H}]$')  # Set the y...
        plt.xlabel(r'$\log_{10} M_{\mathrm{stars}}\ (M_{\odot})$'
                   )  # and the x-axis labels

        # Set the x and y axis minor ticks
        ax.xaxis.set_minor_locator(plt.MultipleLocator(0.05))
        ax.yaxis.set_minor_locator(plt.MultipleLocator(0.25))

        plt.axis([8.0, 12.0, 8.0, 9.5])

        leg = plt.legend(loc='lower right')
        leg.draw_frame(False)  # Don't want a box frame
        for t in leg.get_texts():  # Reduce the size of the text
            t.set_fontsize('medium')

        outputFile = OutputDir + '7.Metallicity' + OutputFormat
        plt.savefig(outputFile)  # Save the figure
        print('Saved file to', outputFile)
        plt.close()

        # Add this plot to our output list
        OutputList.append(outputFile)
    def BaryonicMassFunction(self, G):

        print('Plotting the baryonic mass function')

        plt.figure()  # New figure
        ax = plt.subplot(111)  # 1 plot on the figure

        binwidth = 0.1  # mass function histogram bin width

        # calculate BMF
        w = np.where(G.StellarMass + G.ColdGas > 0.0)[0]
        mass = np.log10(
            (G.StellarMass[w] + G.ColdGas[w]) * 1.0e10 / self.Hubble_h)

        mi = np.floor(min(mass)) - 2
        ma = np.floor(max(mass)) + 2
        NB = (ma - mi) / binwidth

        (counts, binedges) = np.histogram(mass, range=(mi, ma), bins=NB)

        # Set the x-axis values to be the centre of the bins
        xaxeshisto = binedges[:-1] + 0.5 * binwidth

        # Bell et al. 2003 BMF (h=1.0 converted to h=0.73)
        M = np.arange(7.0, 13.0, 0.01)
        Mstar = np.log10(5.3 * 1.0e10 / self.Hubble_h / self.Hubble_h)
        alpha = -1.21
        phistar = 0.0108 * self.Hubble_h * self.Hubble_h * self.Hubble_h
        xval = 10.0**(M - Mstar)
        yval = np.log(10.) * phistar * xval**(alpha + 1) * np.exp(-xval)

        if (whichimf == 0):
            # converted diet Salpeter IMF to Salpeter IMF
            plt.plot(np.log10(10.0**M / 0.7),
                     yval,
                     'b-',
                     lw=2.0,
                     label='Bell et al. 2003')  # Plot the SMF
        elif (whichimf == 1):
            # converted diet Salpeter IMF to Salpeter IMF, then to Chabrier IMF
            plt.plot(np.log10(10.0**M / 0.7 / 1.8),
                     yval,
                     'g--',
                     lw=1.5,
                     label='Bell et al. 2003')  # Plot the SMF

        # Overplot the model histograms
        plt.plot(xaxeshisto,
                 counts / self.volume * self.Hubble_h * self.Hubble_h *
                 self.Hubble_h / binwidth,
                 'k-',
                 label='Model')

        plt.yscale('log', nonposy='clip')
        plt.axis([8.0, 12.5, 1.0e-6, 1.0e-1])

        # Set the x-axis minor ticks
        ax.xaxis.set_minor_locator(plt.MultipleLocator(0.1))

        plt.ylabel(
            r'$\phi\ (\mathrm{Mpc}^{-3}\ \mathrm{dex}^{-1})$')  # Set the y...
        plt.xlabel(r'$\log_{10}\ M_{\mathrm{bar}}\ (M_{\odot})$'
                   )  # and the x-axis labels

        leg = plt.legend(loc='lower left', numpoints=1, labelspacing=0.1)
        leg.draw_frame(False)  # Don't want a box frame
        for t in leg.get_texts():  # Reduce the size of the text
            t.set_fontsize('medium')

        outputFile = OutputDir + '2.BaryonicMassFunction' + OutputFormat
        plt.savefig(outputFile)  # Save the figure
        print('Saved file to', outputFile)
        plt.close()

        # Add this plot to our output list
        OutputList.append(outputFile)
    def MassReservoirScatter(self, G):

        print(
            'Plotting the mass in stellar, cold, hot, ejected, ICS reservoirs')

        seed(2222)

        plt.figure()  # New figure
        ax = plt.subplot(111)  # 1 plot on the figure

        w = np.where((G.Type == 0) & (G.Mvir > 1.0) & (G.StellarMass > 0.0))[0]
        if (len(w) > dilute): w = sample(w, dilute)

        mvir = np.log10(G.Mvir[w] * 1.0e10)
        plt.scatter(mvir,
                    np.log10(G.StellarMass[w] * 1.0e10),
                    marker='o',
                    s=0.3,
                    c='k',
                    alpha=0.5,
                    label='Stars')
        plt.scatter(mvir,
                    np.log10(G.ColdGas[w] * 1.0e10),
                    marker='o',
                    s=0.3,
                    color='blue',
                    alpha=0.5,
                    label='Cold gas')
        plt.scatter(mvir,
                    np.log10(G.HotGas[w] * 1.0e10),
                    marker='o',
                    s=0.3,
                    color='red',
                    alpha=0.5,
                    label='Hot gas')
        plt.scatter(mvir,
                    np.log10(G.EjectedMass[w] * 1.0e10),
                    marker='o',
                    s=0.3,
                    color='green',
                    alpha=0.5,
                    label='Ejected gas')
        plt.scatter(mvir,
                    np.log10(G.IntraClusterStars[w] * 1.0e10),
                    marker='o',
                    s=10,
                    color='yellow',
                    alpha=0.5,
                    label='Intracluster stars')

        plt.ylabel(r'$\mathrm{stellar,\ cold,\ hot,\ ejected,\ ICS\ mass}$'
                   )  # Set the y...
        plt.xlabel(r'$\log\ M_{\mathrm{vir}}\ (h^{-1}\ M_{\odot})$'
                   )  # and the x-axis labels

        plt.axis([10.0, 14.0, 7.5, 12.5])

        leg = plt.legend(loc='upper left')
        leg.draw_frame(False)  # Don't want a box frame
        for t in leg.get_texts():  # Reduce the size of the text
            t.set_fontsize('medium')

        plt.text(13.5, 8.0, r'$\mathrm{All}')

        outputFile = OutputDir + '9.MassReservoirScatter' + OutputFormat
        plt.savefig(outputFile)  # Save the figure
        print('Saved file to', outputFile)
        plt.close()

        # Add this plot to our output list
        OutputList.append(outputFile)
    def VelocityDistribution(self, G):

        print('Plotting the velocity distribution of all galaxies')

        seed(2222)

        mi = -40.0
        ma = 40.0
        binwidth = 0.5
        NB = (ma - mi) / binwidth

        # set up figure
        plt.figure()
        ax = plt.subplot(111)

        pos_x = G.Pos[:, 0] / self.Hubble_h
        pos_y = G.Pos[:, 1] / self.Hubble_h
        pos_z = G.Pos[:, 2] / self.Hubble_h

        vel_x = G.Vel[:, 0]
        vel_y = G.Vel[:, 1]
        vel_z = G.Vel[:, 2]

        dist_los = np.sqrt(pos_x * pos_x + pos_y * pos_y + pos_z * pos_z)
        vel_los = (pos_x / dist_los) * vel_x + (pos_y / dist_los) * vel_y + (
            pos_z / dist_los) * vel_z
        dist_red = dist_los + vel_los / (self.Hubble_h * 100.0)

        tot_gals = len(pos_x)

        (counts, binedges) = np.histogram(vel_los / (self.Hubble_h * 100.0),
                                          range=(mi, ma),
                                          bins=NB)
        xaxeshisto = binedges[:-1] + 0.5 * binwidth
        plt.plot(xaxeshisto,
                 counts / binwidth / tot_gals,
                 'k-',
                 label='los-velocity')

        (counts, binedges) = np.histogram(vel_x / (self.Hubble_h * 100.0),
                                          range=(mi, ma),
                                          bins=NB)
        xaxeshisto = binedges[:-1] + 0.5 * binwidth
        plt.plot(xaxeshisto,
                 counts / binwidth / tot_gals,
                 'r-',
                 label='x-velocity')

        (counts, binedges) = np.histogram(vel_y / (self.Hubble_h * 100.0),
                                          range=(mi, ma),
                                          bins=NB)
        xaxeshisto = binedges[:-1] + 0.5 * binwidth
        plt.plot(xaxeshisto,
                 counts / binwidth / tot_gals,
                 'g-',
                 label='y-velocity')

        (counts, binedges) = np.histogram(vel_z / (self.Hubble_h * 100.0),
                                          range=(mi, ma),
                                          bins=NB)
        xaxeshisto = binedges[:-1] + 0.5 * binwidth
        plt.plot(xaxeshisto,
                 counts / binwidth / tot_gals,
                 'b-',
                 label='z-velocity')

        plt.yscale('log', nonposy='clip')
        plt.axis([mi, ma, 1e-5, 0.5])
        # plt.axis([mi, ma, 0, 0.13])

        plt.ylabel(r'$\mathrm{Box\ Normalised\ Count}$')  # Set the y...
        plt.xlabel(r'$\mathrm{Velocity / H}_{0}$')  # and the x-axis labels

        leg = plt.legend(loc='upper left', numpoints=1, labelspacing=0.1)
        leg.draw_frame(False)  # Don't want a box frame
        for t in leg.get_texts():  # Reduce the size of the text
            t.set_fontsize('medium')

        outputFile = OutputDir + '11.VelocityDistribution' + OutputFormat
        plt.savefig(outputFile)  # Save the figure
        print('Saved file to', outputFile)
        plt.close()

        # Add this plot to our output list
        OutputList.append(outputFile)
    def GasMassFunction(self, G):

        print('Plotting the cold gas mass function')

        plt.figure()  # New figure
        ax = plt.subplot(111)  # 1 plot on the figure

        binwidth = 0.1  # mass function histogram bin width

        # calculate all
        w = np.where(G.ColdGas > 0.0)[0]
        mass = np.log10(G.ColdGas[w] * 1.0e10 / self.Hubble_h)
        sSFR = (G.SfrDisk[w] + G.SfrBulge[w]) / (G.StellarMass[w] * 1.0e10 /
                                                 self.Hubble_h)
        mi = np.floor(min(mass)) - 2
        ma = np.floor(max(mass)) + 2
        NB = (ma - mi) / binwidth

        (counts, binedges) = np.histogram(mass, range=(mi, ma), bins=NB)

        # Set the x-axis values to be the centre of the bins
        xaxeshisto = binedges[:-1] + 0.5 * binwidth

        # additionally calculate red
        w = np.where(sSFR < 10.0**sSFRcut)[0]
        massRED = mass[w]
        (countsRED, binedges) = np.histogram(massRED, range=(mi, ma), bins=NB)

        # additionally calculate blue
        w = np.where(sSFR > 10.0**sSFRcut)[0]
        massBLU = mass[w]
        (countsBLU, binedges) = np.histogram(massBLU, range=(mi, ma), bins=NB)

        # Baldry+ 2008 modified data used for the MCMC fitting
        Zwaan = np.array([[6.933, -0.333], [7.057, -0.490], [7.209, -0.698],
                          [7.365, -0.667], [7.528, -0.823], [7.647, -0.958],
                          [7.809, -0.917], [7.971, -0.948], [8.112, -0.927],
                          [8.263, -0.917], [8.404, -1.062], [8.566, -1.177],
                          [8.707, -1.177], [8.853, -1.312], [9.010, -1.344],
                          [9.161, -1.448], [9.302, -1.604], [9.448, -1.792],
                          [9.599, -2.021], [9.740, -2.406], [9.897, -2.615],
                          [10.053, -3.031], [10.178, -3.677], [10.335, -4.448],
                          [10.492, -5.083]],
                         dtype=np.float32)

        ObrRaw = np.array([[7.300, -1.104], [7.576, -1.302], [7.847, -1.250],
                           [8.133, -1.240], [8.409, -1.344], [8.691, -1.479],
                           [8.956, -1.792], [9.231, -2.271], [9.507, -3.198],
                           [9.788, -5.062]],
                          dtype=np.float32)

        ObrCold = np.array([[8.009, -1.042], [8.215, -1.156], [8.409, -0.990],
                            [8.604, -1.156], [8.799, -1.208], [9.020, -1.333],
                            [9.194, -1.385], [9.404, -1.552], [9.599, -1.677],
                            [9.788, -1.812], [9.999, -2.312], [10.172, -2.656],
                            [10.362, -3.500], [10.551, -3.635],
                            [10.740, -5.010]],
                           dtype=np.float32)

        ObrCold_xval = np.log10(10**(ObrCold[:, 0]) / self.Hubble_h /
                                self.Hubble_h)
        ObrCold_yval = (10**(ObrCold[:, 1]) * self.Hubble_h * self.Hubble_h *
                        self.Hubble_h)
        Zwaan_xval = np.log10(10**(Zwaan[:, 0]) / self.Hubble_h /
                              self.Hubble_h)
        Zwaan_yval = (10**(Zwaan[:, 1]) * self.Hubble_h * self.Hubble_h *
                      self.Hubble_h)
        ObrRaw_xval = np.log10(10**(ObrRaw[:, 0]) / self.Hubble_h /
                               self.Hubble_h)
        ObrRaw_yval = (10**(ObrRaw[:, 1]) * self.Hubble_h * self.Hubble_h *
                       self.Hubble_h)

        plt.plot(ObrCold_xval,
                 ObrCold_yval,
                 color='black',
                 lw=7,
                 alpha=0.25,
                 label='Obr. \& Raw. 2009 (Cold Gas)')
        plt.plot(Zwaan_xval,
                 Zwaan_yval,
                 color='cyan',
                 lw=7,
                 alpha=0.25,
                 label='Zwaan et al. 2005 (HI)')
        plt.plot(ObrRaw_xval,
                 ObrRaw_yval,
                 color='magenta',
                 lw=7,
                 alpha=0.25,
                 label='Obr. \& Raw. 2009 (H2)')

        # Overplot the model histograms
        plt.plot(xaxeshisto,
                 counts / self.volume * self.Hubble_h * self.Hubble_h *
                 self.Hubble_h / binwidth,
                 'k-',
                 label='Model - Cold Gas')

        plt.yscale('log', nonposy='clip')
        plt.axis([8.0, 11.5, 1.0e-6, 1.0e-1])

        # Set the x-axis minor ticks
        ax.xaxis.set_minor_locator(plt.MultipleLocator(0.1))

        plt.ylabel(
            r'$\phi\ (\mathrm{Mpc}^{-3}\ \mathrm{dex}^{-1})$')  # Set the y...
        plt.xlabel(r'$\log_{10} M_{\mathrm{X}}\ (M_{\odot})$'
                   )  # and the x-axis labels

        leg = plt.legend(loc='lower left', numpoints=1, labelspacing=0.1)
        leg.draw_frame(False)  # Don't want a box frame
        for t in leg.get_texts():  # Reduce the size of the text
            t.set_fontsize('medium')

        outputFile = OutputDir + '3.GasMassFunction' + OutputFormat
        plt.savefig(outputFile)  # Save the figure
        print('Saved file to', outputFile)
        plt.close()

        # Add this plot to our output list
        OutputList.append(outputFile)
Example #43
0
        'z', 'th', 'u', 'ug', 'v', 'vg'))
for k in range(kmax):
    proffile.write(
        '{0:1.14E} {1:1.14E} {2:1.14E} {3:1.14E} {4:1.14E} {5:1.14E} \n'.
        format(z[k], th[k], u[k], ug[k], v[k], vg[k]))
proffile.close()

# write surface temperature
timefile = open('gabls4s3.time', 'w')
timefile.write('{0:^20s} {1:^20s} \n'.format('t', 'sbot[th]'))
for t in range(s3.t.size):
    timefile.write('{0:1.14E} {1:1.14E} \n'.format(s3.t[t], s3.ths[t]))
timefile.close()

# Plot
pl.close('all')

pl.figure()
pl.subplot(221)
pl.plot(th, z, 'k-', label='mhh')
pl.plot(s3.th, s3.z, 'go', mfc='none', label='s3')
pl.ylim(0, 1100)
pl.xlim(270, 285)
pl.legend(frameon=False, loc=2)

pl.subplot(222)
pl.plot(u, z, 'k-', label='mhh')
pl.plot(s3.u, s3.z, 'go', mfc='none', label='s3')
pl.plot(ug, z, 'k--', label='mhh')
pl.plot(s3.ug, s3.z, 'bo', mfc='none', label='s3')
pl.ylim(0, 1100)
    def StellarMassFunction(self, G):

        print('Plotting the stellar mass function')

        plt.figure()  # New figure
        ax = plt.subplot(111)  # 1 plot on the figure

        binwidth = 0.1  # mass function histogram bin width

        # calculate all
        w = np.where(G.StellarMass > 0.0)[0]
        mass = np.log10(G.StellarMass[w] * 1.0e10 / self.Hubble_h)
        sSFR = (G.SfrDisk[w] + G.SfrBulge[w]) / (G.StellarMass[w] * 1.0e10 /
                                                 self.Hubble_h)

        mi = np.floor(min(mass)) - 2
        ma = np.floor(max(mass)) + 2
        NB = (ma - mi) / binwidth

        (counts, binedges) = np.histogram(mass, range=(mi, ma), bins=NB)

        # Set the x-axis values to be the centre of the bins
        xaxeshisto = binedges[:-1] + 0.5 * binwidth

        # additionally calculate red
        w = np.where(sSFR < 10.0**sSFRcut)[0]
        massRED = mass[w]
        (countsRED, binedges) = np.histogram(massRED, range=(mi, ma), bins=NB)

        # additionally calculate blue
        w = np.where(sSFR > 10.0**sSFRcut)[0]
        massBLU = mass[w]
        (countsBLU, binedges) = np.histogram(massBLU, range=(mi, ma), bins=NB)

        # Baldry+ 2008 modified data used for the MCMC fitting
        Baldry = np.array([
            [7.05, 1.3531e-01, 6.0741e-02],
            [7.15, 1.3474e-01, 6.0109e-02],
            [7.25, 2.0971e-01, 7.7965e-02],
            [7.35, 1.7161e-01, 3.1841e-02],
            [7.45, 2.1648e-01, 5.7832e-02],
            [7.55, 2.1645e-01, 3.9988e-02],
            [7.65, 2.0837e-01, 4.8713e-02],
            [7.75, 2.0402e-01, 7.0061e-02],
            [7.85, 1.5536e-01, 3.9182e-02],
            [7.95, 1.5232e-01, 2.6824e-02],
            [8.05, 1.5067e-01, 4.8824e-02],
            [8.15, 1.3032e-01, 2.1892e-02],
            [8.25, 1.2545e-01, 3.5526e-02],
            [8.35, 9.8472e-02, 2.7181e-02],
            [8.45, 8.7194e-02, 2.8345e-02],
            [8.55, 7.0758e-02, 2.0808e-02],
            [8.65, 5.8190e-02, 1.3359e-02],
            [8.75, 5.6057e-02, 1.3512e-02],
            [8.85, 5.1380e-02, 1.2815e-02],
            [8.95, 4.4206e-02, 9.6866e-03],
            [9.05, 4.1149e-02, 1.0169e-02],
            [9.15, 3.4959e-02, 6.7898e-03],
            [9.25, 3.3111e-02, 8.3704e-03],
            [9.35, 3.0138e-02, 4.7741e-03],
            [9.45, 2.6692e-02, 5.5029e-03],
            [9.55, 2.4656e-02, 4.4359e-03],
            [9.65, 2.2885e-02, 3.7915e-03],
            [9.75, 2.1849e-02, 3.9812e-03],
            [9.85, 2.0383e-02, 3.2930e-03],
            [9.95, 1.9929e-02, 2.9370e-03],
            [10.05, 1.8865e-02, 2.4624e-03],
            [10.15, 1.8136e-02, 2.5208e-03],
            [10.25, 1.7657e-02, 2.4217e-03],
            [10.35, 1.6616e-02, 2.2784e-03],
            [10.45, 1.6114e-02, 2.1783e-03],
            [10.55, 1.4366e-02, 1.8819e-03],
            [10.65, 1.2588e-02, 1.8249e-03],
            [10.75, 1.1372e-02, 1.4436e-03],
            [10.85, 9.1213e-03, 1.5816e-03],
            [10.95, 6.1125e-03, 9.6735e-04],
            [11.05, 4.3923e-03, 9.6254e-04],
            [11.15, 2.5463e-03, 5.0038e-04],
            [11.25, 1.4298e-03, 4.2816e-04],
            [11.35, 6.4867e-04, 1.6439e-04],
            [11.45, 2.8294e-04, 9.9799e-05],
            [11.55, 1.0617e-04, 4.9085e-05],
            [11.65, 3.2702e-05, 2.4546e-05],
            [11.75, 1.2571e-05, 1.2571e-05],
            [11.85, 8.4589e-06, 8.4589e-06],
            [11.95, 7.4764e-06, 7.4764e-06],
        ],
                          dtype=np.float32)

        # Finally plot the data
        # plt.errorbar(
        #     Baldry[:, 0],
        #     Baldry[:, 1],
        #     yerr=Baldry[:, 2],
        #     color='g',
        #     linestyle=':',
        #     lw = 1.5,
        #     label='Baldry et al. 2008',
        #     )

        Baldry_xval = np.log10(10**Baldry[:, 0] / self.Hubble_h /
                               self.Hubble_h)
        if (whichimf == 1):
            Baldry_xval = Baldry_xval - 0.26  # convert back to Chabrier IMF
        Baldry_yvalU = (Baldry[:, 1] + Baldry[:, 2]
                        ) * self.Hubble_h * self.Hubble_h * self.Hubble_h
        Baldry_yvalL = (Baldry[:, 1] - Baldry[:, 2]
                        ) * self.Hubble_h * self.Hubble_h * self.Hubble_h

        plt.fill_between(Baldry_xval,
                         Baldry_yvalU,
                         Baldry_yvalL,
                         facecolor='purple',
                         alpha=0.25,
                         label='Baldry et al. 2008 (z=0.1)')

        # This next line is just to get the shaded region to appear correctly in the legend
        plt.plot(xaxeshisto,
                 counts / self.volume * self.Hubble_h * self.Hubble_h *
                 self.Hubble_h / binwidth,
                 label='Baldry et al. 2008',
                 color='purple',
                 alpha=0.3)

        # # Cole et al. 2001 SMF (h=1.0 converted to h=0.73)
        # M = np.arange(7.0, 13.0, 0.01)
        # Mstar = np.log10(7.07*1.0e10 /self.Hubble_h/self.Hubble_h)
        # alpha = -1.18
        # phistar = 0.009 *self.Hubble_h*self.Hubble_h*self.Hubble_h
        # xval = 10.0 ** (M-Mstar)
        # yval = np.log(10.) * phistar * xval ** (alpha+1) * np.exp(-xval)
        # plt.plot(M, yval, 'g--', lw=1.5, label='Cole et al. 2001')  # Plot the SMF

        # Overplot the model histograms
        plt.plot(xaxeshisto,
                 counts / self.volume * self.Hubble_h * self.Hubble_h *
                 self.Hubble_h / binwidth,
                 'k-',
                 label='Model - All')
        plt.plot(xaxeshisto,
                 countsRED / self.volume * self.Hubble_h * self.Hubble_h *
                 self.Hubble_h / binwidth,
                 'r:',
                 lw=2,
                 label='Model - Red')
        plt.plot(xaxeshisto,
                 countsBLU / self.volume * self.Hubble_h * self.Hubble_h *
                 self.Hubble_h / binwidth,
                 'b:',
                 lw=2,
                 label='Model - Blue')

        plt.yscale('log', nonposy='clip')
        plt.axis([8.0, 12.5, 1.0e-6, 1.0e-1])

        # Set the x-axis minor ticks
        ax.xaxis.set_minor_locator(plt.MultipleLocator(0.1))

        plt.ylabel(
            r'$\phi\ (\mathrm{Mpc}^{-3}\ \mathrm{dex}^{-1})$')  # Set the y...
        plt.xlabel(r'$\log_{10} M_{\mathrm{stars}}\ (M_{\odot})$'
                   )  # and the x-axis labels

        plt.text(12.2, 0.03, whichsimulation, size='large')

        leg = plt.legend(loc='lower left', numpoints=1, labelspacing=0.1)
        leg.draw_frame(False)  # Don't want a box frame
        for t in leg.get_texts():  # Reduce the size of the text
            t.set_fontsize('medium')

        outputFile = OutputDir + '1.StellarMassFunction' + OutputFormat
        plt.savefig(outputFile)  # Save the figure
        print('Saved file to', outputFile)
        plt.close()

        # Add this plot to our output list
        OutputList.append(outputFile)
Example #45
0
def generate_subject_stats_report(
        stats_report_filename,
        contrasts,
        z_maps,
        mask,
        design_matrices=None,
        subject_id=None,
        anat=None,
        display_mode="z",
        cut_coords=None,
        threshold=2.3,
        cluster_th=15,
        start_time=None,
        title=None,
        user_script_name=None,
        progress_logger=None,
        shutdown_all_reloaders=True,
        **glm_kwargs):
    """Generates a report summarizing the statistical methods and results

    Parameters
    ----------
    stats_report_filename: string:
        html file to which output (generated html) will be written

    contrasts: dict of arrays
        contrasts we are interested in; same number of contrasts as zmaps;
        same keys

    zmaps: dict of image objects or strings (image filenames)
        zmaps for contrasts we are interested in; one per contrast id

    mask: 'nifti image object'
        brain mask for ROI

    design_matrix: list of 'DesignMatrix', `numpy.ndarray` objects or of
    strings (.png, .npz, etc.) for filenames
        design matrices for the experimental conditions

    contrasts: dict of arrays
       dictionary of contrasts of interest; the keys are the contrast ids,
       the values are contrast values (lists)

    z_maps: dict of 3D image objects or strings (image filenames)
       dict with same keys as 'contrasts'; the values are paths of z-maps
       for the respective contrasts

    anat: 3D array (optional)
        brain image to serve bg unto which activation maps will be plotted

    anat_affine: 2D array (optional)
        affine data for the anat

    threshold: float (optional)
        threshold to be applied to activation maps voxel-wise

    cluster_th: int (optional)
        minimal voxel count for clusteres declared as 'activated'

    cmap: cmap object (default viz.cm.cold_hot)
        color-map to use in plotting activation maps

    start_time: string (optional)
        start time for the stats analysis (useful for the generated
        report page)

    user_script_name: string (optional, default None)
        existing filename, path to user script used in doing the analysis

    progress_logger: ProgressLogger object (optional)
        handle for logging progress

    shutdown_all_reloaders: bool (optional, default True)
        if True, all pages connected to the stats report page will
        be prevented from reloading after the stats report page
        has been completely generated

    **glm_kwargs:
        kwargs used to specify the control parameters used to specify the
        experimental paradigm and the GLM

    """
    # prepare for stats reporting
    if progress_logger is None:
        progress_logger = base_reporter.ProgressReport()

    output_dir = os.path.dirname(stats_report_filename)
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)

    # copy css and js stuff to output dir
    base_reporter.copy_web_conf_files(output_dir)

    # initialize gallery of design matrices
    design_thumbs = base_reporter.ResultsGallery(
        loader_filename=os.path.join(output_dir,
                                     "design.html")
        )

    # initialize gallery of activation maps
    activation_thumbs = base_reporter.ResultsGallery(
        loader_filename=os.path.join(output_dir,
                                     "activation.html")
        )

    # get caller module handle from stack-frame
    if user_script_name is None:
        user_script_name = sys.argv[0]
    user_source_code = base_reporter.get_module_source_code(
        user_script_name)

    methods = """
    GLM and Statistical Inference have been done using the <i>%s</i> script, \
powered by <a href="%s">nistats</a>.""" % (user_script_name,
                                           base_reporter.NISTATS_URL)

    # report the control parameters used in the paradigm and analysis
    design_params = ""
    glm_kwargs["contrasts"] = contrasts
    if len(glm_kwargs):
        design_params += ("The following control parameters were used for  "
                    " specifying the experimental paradigm and fitting the "
                    "GLM:<br/><ul>")

        # reshape glm_kwargs['paradigm']
        if "paradigm" in glm_kwargs:
            paradigm_ = glm_kwargs['paradigm']
            paradigm = {'name' : paradigm_['name'],
                        'onset' : paradigm_['onset']}
            if 'duration' in paradigm_.keys():
                paradigm['duration'] = paradigm_['duration']
            paradigm['n_conditions'] = len(set(paradigm['name']))
            paradigm['n_events'] = len(paradigm['name'])
            paradigm['type'] = 'event'
            if 'duration' in paradigm.keys() and paradigm['duration'][0] > 0:
                paradigm['type'] = 'block'
            glm_kwargs['paradigm'] = paradigm

        design_params += base_reporter.dict_to_html_ul(glm_kwargs)

    if start_time is None:
        start_time = base_reporter.pretty_time()

    if title is None:
        title = "GLM and Statistical Inference"
        if not subject_id is None:
            title += " for subject %s" % subject_id

    level1_html_markup = base_reporter.get_subject_report_stats_html_template(
        title=title,
        start_time=start_time,
        subject_id=subject_id,

        # insert source code stub
        source_script_name=user_script_name,
        source_code=user_source_code,

        design_params=design_params,
        methods=methods,
        threshold=threshold)

    with open(stats_report_filename, 'w') as fd:
        fd.write(str(level1_html_markup))
        fd.close()

    progress_logger.log("<b>Level 1 statistics</b><br/><br/>")

    # create design matrix thumbs
    if not design_matrices is None:
        if not hasattr(design_matrices, '__len__'):
            design_matrices = [design_matrices]

        for design_matrix, j in zip(design_matrices,
                                    range(len(design_matrices))):

            # Nistats: design matrices should be strings or pandas dataframes
            if isinstance(design_matrix, str):
                if not isinstance(design_matrix, pd.DataFrame):
                    # XXX should be a DataFrame pickle here ?
                    print(design_matrix)
                    design_matrix = pd.read_pickle(design_matrix)
                else:
                    raise TypeError(
                        "Unsupported design matrix type: %s" % type(
                            design_matrix))

            # plot design_matrix proper
            ax = plot_design_matrix(design_matrix)
            ax.set_position([.05, .25, .9, .65])
            dmat_outfile = os.path.join(output_dir,
                                        'design_matrix_%i.png' % (j + 1))
            pl.savefig(dmat_outfile, bbox_inches="tight", dpi=200)
            pl.close()

            thumb = base_reporter.Thumbnail()
            thumb.a = base_reporter.a(href=os.path.basename(dmat_outfile))
            thumb.img = base_reporter.img(src=os.path.basename(dmat_outfile),
                                     height="500px")
            thumb.description = "Design Matrix"
            thumb.description += " %s" % (j + 1) if len(
                design_matrices) > 1 else ""

            # commit activation thumbnail into gallery
            design_thumbs.commit_thumbnails(thumb)

    # create activation thumbs
    for contrast_id, contrast_val in contrasts.items():
        z_map = z_maps[contrast_id]

        # load the map
        if isinstance(z_map, str):
            z_map = nibabel.load(z_map)

        # generate level 1 stats table
        title = "Level 1 stats for %s contrast" % contrast_id
        stats_table = os.path.join(output_dir, "%s_stats_table.html" % (
                contrast_id))
        generate_level1_stats_table(
            z_map, mask, stats_table, cluster_th=cluster_th,
            z_threshold=threshold, title=title)

        # plot activation proper
        # XXX: nilearn's plotting bug's about rotations inf affine, etc.
        z_map = reorder_img(z_map, resample="continuous")
        if not anat is None:
            anat = reorder_img(anat, resample="continuous")
        plot_stat_map(z_map, anat, threshold=threshold,
                      display_mode=display_mode, cut_coords=cut_coords,
                      black_bg=True)

        # store activation plot
        z_map_plot = os.path.join(output_dir,
                                  "%s_z_map.png" % contrast_id)
        pl.savefig(z_map_plot, dpi=200, bbox_inches='tight', facecolor="k",
                   edgecolor="k")
        pl.close()

        # create thumbnail for activation
        thumbnail = base_reporter.Thumbnail(
            tooltip="Contrast vector: %s" % contrast_val)
        thumbnail.a = base_reporter.a(href=os.path.basename(stats_table))
        thumbnail.img = base_reporter.img(src=os.path.basename(z_map_plot),
                                          height="150px",)
        thumbnail.description = contrast_id
        activation_thumbs.commit_thumbnails(thumbnail)

    # we're done, shut down re-loaders
    progress_logger.log('<hr/>')

    # prevent stats report page from reloading henceforth
    progress_logger.finish(stats_report_filename)

    # prevent any related page from reloading
    if shutdown_all_reloaders:
        progress_logger.finish_dir(output_dir)

    # return generated html
    with open(stats_report_filename, 'r') as fd:
        stats_report = fd.read()
        fd.close()

        return stats_report
Example #46
0
    def threshold(self, x_train, y_train, x_valid, y_valid, plot_graph=True):
        """
        Obtain optimal threshold using FBeta as parameter using a range (0.1, 1.0, 200) for 
        evaluation
        """

        if self.sampling is None:
            class_weight = self.class_weight

        elif self.sampling == 'ALLKNN':
            x_train, y_train = under_sampling(x_train, y_train)
            class_weight = None

        else:
            x_train, y_train = over_sampling(x_train, y_train, model=self.sampling)
            class_weight = None

        if isinstance(x_train, pd.DataFrame):
            x_train = x_train.values
        if isinstance(y_train, (pd.DataFrame, pd.Series)):
            y_train = y_train.values
        if isinstance(x_valid, pd.DataFrame):
            x_valid = x_valid.values
        if isinstance(y_valid, (pd.DataFrame, pd.Series)):
            y_valid = y_valid.values

        min_sample_leaf = round(x_train.shape[0] * 0.01)
        min_sample_split = min_sample_leaf * 10
        max_features = None

        file_model = ensemble.ExtraTreesClassifier(criterion='gini', bootstrap=self.bootstrap,
                                                   min_samples_leaf=min_sample_leaf,
                                                   min_samples_split=min_sample_split,
                                                   n_estimators=self.n_estimators,
                                                   max_depth=self.max_depth, max_features=max_features,
                                                   oob_score=self.oob_score,
                                                   random_state=531, verbose=1, class_weight=class_weight,
                                                   n_jobs=1)
        cv = StratifiedKFold(n_splits=10, random_state=None)
        file_model.fit(x_train, y_train)

        thresholds = np.linspace(0.1, 1.0, 200)

        scores = []

        y_pred_score = cross_val_predict(file_model, x_valid,
                                         y_valid, cv=cv, method='predict_proba')

        y_pred_score = np.delete(y_pred_score, 0, axis=1)

        for threshold in thresholds:
            y_hat = (y_pred_score > threshold).astype(int)
            y_hat = y_hat.tolist()
            y_hat = [item for sublist in y_hat for item in sublist]

            scores.append([
                recall_score(y_pred=y_hat, y_true=y_valid),
                precision_score(y_pred=y_hat, y_true=y_valid),
                fbeta_score(y_pred=y_hat, y_true=y_valid,
                            beta=self.beta, average=self.metric_weight)])

        scores = np.array(scores)

        if plot_graph:
            plot.plot(thresholds, scores[:, 0], label='$Recall$')
            plot.plot(thresholds, scores[:, 1], label='$Precision$')
            plot.plot(thresholds, scores[:, 2], label='$F_2$')
            plot.ylabel('Score')
            plot.xlabel('Threshold')
            plot.legend(loc='best')
            plot.close()

        self.final_threshold = thresholds[scores[:, 2].argmax()]
        print(self.final_threshold)
        return self.final_threshold
Example #47
0
def sample(ndim,
           nwalkers,
           nsteps,
           burnin,
           start,
           ur,
           sigma_ur,
           nuvu,
           sigma_nuvu,
           age,
           id,
           ra,
           dec,
           get_c_one,
           use_table,
           thegrid,
           lu=None,
           savedir="./"):
    """ Function to implement the emcee EnsembleSampler function for the sample of galaxies input. Burn in is run and calcualted fir the length specified before the sampler is reset and then run for the length of steps specified. 
        
        :ndim:
        The number of parameters in the model that emcee must find. In this case it always 2 with tq, tau.
        
        :nwalkers:
        The number of walkers that step around the parameter space. Must be an even integer number larger than ndim. 
        
        :nsteps:
        The number of steps to take in the final run of the MCMC sampler. Integer.
        
        :burnin:
        The number of steps to take in the inital burn-in run of the MCMC sampler. Integer. 
        
        :start:
        The positions in the tq and tau parameter space to start for both disc and smooth parameters. An array of shape (1,4).
        
        
        :ur:
        Observed u-r colour of a galaxy; k-corrected. An array of shape (N,1) or (N,).
        
        :sigma_ur:
        Error on the observed u-r colour of a galaxy. An array of shape (N,1) or (N,).
        
        :nuvu:
        Observed nuv-u colour of a galaxy; k-corrected. An array of shape (N,1) or (N,).
        
        :sigma_nuvu:
        Error on the observed nuv-u colour of a galaxy. An array of shape (N,1) or (N,).
        
        :age:
        Observed age of a galaxy, often calculated from the redshift i.e. at z=0.1 the age ~ 12.5. Must be in units of Gyr. An array of shape (N,1) or (N,).
        
        :id:
        ID number to specify which galaxy this run is for.
        
        :ra:
        right ascension of source, used for identification purposes
        
        :dec:
        declination of source, used for identification purposes
        
        RETURNS:
        :samples:
        Array of shape (nsteps*nwalkers, 4) containing the positions of the walkers at all steps for all 4 parameters.
        :samples_save:
        Location at which the :samples: array was saved to. 
        
        """
    tq, tau, ages = thegrid
    grid = N.array(list(product(ages, tau, tq)))

    if use_table:
        global u
        global v
        a = N.searchsorted(ages, age)
        b = N.array([a - 1, a])
        print 'interpolating function, bear with...'
        g = grid[N.where(
            N.logical_or(grid[:, 0] == ages[b[0]], grid[:, 0] == ages[b[1]]))]
        values = lu[N.where(
            N.logical_or(grid[:, 0] == ages[b[0]], grid[:, 0] == ages[b[1]]))]
        f = LinearNDInterpolator(g, values, fill_value=(-N.inf))
        look = f(age, grid[:10000, 1], grid[:10000, 2])
        lunuv = look[:, 0].reshape(100, 100)
        v = interp2d(tq, tau, lunuv)
        luur = look[:, 1].reshape(100, 100)
        u = interp2d(tq, tau, luur)
    else:
        pass
    print 'emcee running...'
    p0 = [start + 1e-4 * N.random.randn(ndim) for i in range(nwalkers)]
    sampler = emcee.EnsembleSampler(nwalkers,
                                    ndim,
                                    lnprob,
                                    threads=2,
                                    args=(ur, sigma_ur, nuvu, sigma_nuvu, age,
                                          get_c_one))
    """ Burn in run here..."""
    pos, prob, state = sampler.run_mcmc(p0, burnin)
    lnp = sampler.flatlnprobability
    N.save(
        savedir + 'lnprob_burnin_' + str(int(id)) + '_' + str(ra) + '_' +
        str(dec) + '_' + str(time.strftime('%H_%M_%d_%m_%y')) + '.npy', lnp)
    samples = sampler.chain[:, :, :].reshape((-1, ndim))
    samples_save = savedir + 'samples_burn_in_' + str(
        int(id)) + '_' + str(ra) + '_' + str(dec) + '_' + str(
            time.strftime('%H_%M_%d_%m_%y')) + '.npy'
    N.save(samples_save, samples)
    sampler.reset()
    print 'Burn in complete...'
    """ Main sampler run here..."""
    sampler.run_mcmc(pos, nsteps)
    lnpr = sampler.flatlnprobability
    N.save(
        savedir + 'lnprob_run_' + str(int(id)) + '_' + str(ra) + '_' +
        str(dec) + '_' + str(time.strftime('%H_%M_%d_%m_%y')) + '.npy', lnpr)
    samples = sampler.chain[:, :, :].reshape((-1, ndim))
    samples_save = savedir + 'samples_' + str(
        int(id)) + '_' + str(ra) + '_' + str(dec) + '_' + str(
            time.strftime('%H_%M_%d_%m_%y')) + '.npy'
    N.save(samples_save, samples)
    print 'Main emcee run completed.'
    P.close('all')
    P.clf()
    P.cla()
    return samples, samples_save
Example #48
0
    bgr = histogram_equalize_hsv(frame2, size)
    cv2.imshow("equalizeHist_hsv", bgr)
    cv2.imwrite("equalizeHist_hsv.jpg", bgr)
    bgr = histogram_equalize_treat(frame2, size)
    cv2.imshow("equalize_treat", bgr)
    cv2.imwrite("equalizeHist_treat.jpg", bgr)

    fig, ax = plt.subplots(2, 3, figsize=(12, 4))
    histOrgY, histLutY = something(frame, frame2, 0)
    plot_hist(histOrgY, histLutY, 0, 0, "frame", "frame2")
    histOrgY, histLutY = something(frame, frame2, 1)
    plot_hist(histOrgY, histLutY, 0, 1, "frame", "frame2")
    histOrgY, histLutY = something(frame, frame2, 2)
    plot_hist(histOrgY, histLutY, 0, 2, "frame", "frame2")
    #plt.pause(1)
    #plt.close()

    #fig, ax = plt.subplots(1, 3, figsize=(12, 4))
    histOrgY, histLutY = something(frame, bgr, 0)
    plot_hist(histOrgY, histLutY, 1, 0, "frame", "bgr")
    histOrgY, histLutY = something(frame, bgr, 1)
    plot_hist(histOrgY, histLutY, 1, 1, "frame", "bgr")
    histOrgY, histLutY = something(frame, bgr, 2)
    plot_hist(histOrgY, histLutY, 1, 2, "frame", "bgr")
    plt.show()
    plt.close()

    k = cv2.waitKey(30) & 0xff
    if k == 27:
        break
Example #49
0
def lin_fit(crvfile,
            refcrvfile,
            outname,
            dump_frequency,
            Er,
            Ed,
            recoil_relaxation_time=10000,
            start_timeoffset=500):

    crv = CRV.CRV(crvfile)[0]
    eps = crv['lz']
    x = crv['step']
    pyy = crv['pyy']
    n_atoms = crv['atoms'][0]

    crv1 = CRV.CRV(refcrvfile)[0]
    eps_ref = crv1['lz']

    #  eps = np.subtract(eps,eps_ref)

    print eps

    nrecoils = []

    #pressure tensor component
    pxx = []
    ezz = []
    ezz_ref = []

    dump_factor = int(recoil_relaxation_time / dump_frequency)

    pressure_conversion = 1e9  #GPa -> Pa

    #reduce timeaxis to recoil axis
    for i in range(len(x) / dump_factor):
        nrecoils.append((x[i * dump_factor] - start_timeoffset) /
                        float(recoil_relaxation_time))
        pxx.append(pyy[i * dump_factor] * pressure_conversion)
        # ezz.append(((eps[i*dump_factor] - eps[0])/eps[0] - (eps_ref[i*dump_factor] - eps_ref[0])/eps_ref[0]))
        # ezz.append(abs( (eps[i*dump_factor] -eps_ref[i*dump_factor])/ (eps[0] - eps_ref[0])))
        ezz.append(((-eps[dump_factor] + eps[i * dump_factor])))
        ezz_ref.append(((-eps_ref[dump_factor] + eps_ref[i * dump_factor])))

    del nrecoils[0]
    del pxx[0]
    del ezz[0]
    del ezz_ref[0]

    #number of displacements per target atom
    ndpa = np.multiply(nrecoils, (Er / (2.5 * Ed * n_atoms)))

    fit_start = 0
    fit_end = 20

    dezz = np.multiply(np.subtract(ezz, ezz_ref), 1. / eps[dump_factor])

    #fit1
    popt1, pcov1 = opt.curve_fit(
        lambda ndpa, eta, offset: eta_lin(ndpa, pxx[0], eta, offset),
        ndpa[fit_start:fit_end], dezz[fit_start:fit_end])
    #popt1 = [1,1]

    #fit2
    # popt2, pcov2 = opt.curve_fit( lambda ndpa,eta,offset: eta_lin(ndpa,pxx[0],eta,offset), ndpa[0:fit_start], ezz[0:fit_start])
    #popt2 = [1,1]
    #anotate to add value to plot
    # print 'RIV (lin)= {:.4e}'.format(popt1[0])

    # npa interpolated
    ndpa_interp = np.linspace(0, ndpa[-1] * 1.5, 1000)

    fig = plt.figure(1, figsize=fsize)

    plt.xlim(0, ndpa_interp[-1])

    # plt.ylim(ezz[-1]*0.8, ezz[-1]*1.1)

    plt.grid()

    plt.plot(ndpa[fit_start:fit_end],
             dezz[fit_start:fit_end],
             'bs',
             markeredgecolor='blue',
             markerfacecolor='None',
             markeredgewidth=mew,
             markersize=ms,
             label='MD Simulation')
    # plt.plot(ndpa, ezz_ref, 'bs', markeredgecolor = 'magenta',  markerfacecolor= 'None', markeredgewidth=mew,  markersize = ms,  label = 'MD Simulation Reference')
    plt.plot(ndpa_interp,
             eta_lin(ndpa_interp, pxx[0], *popt1),
             'r-',
             linewidth=lw,
             label='Fit')
    #  plt.plot(ndpa_interp, eta_lin(ndpa_interp,pxx[0],*popt2), '-', color = 'black', linewidth = lw, label='Fit2')
    plt.xlabel('Number of displacements per atom')
    plt.ylabel(r'$ \Delta \varepsilon_{zz} $')

    # legtitle  = r'$ \eta_{ri,1} = $' + '{:.4e}'.format(popt1[0]) + ' $ \mathrm{Pa \cdot dpa} $' + '\n' +  r'$ \eta_{ri,2} = $' + '{:.4e}'.format(popt2[0]) + ' $ \mathrm{Pa \cdot dpa} $' + '\n'r'$\sigma_0 = $' + '{:.2e}'.format(abs(pxx[0])) + r'$\,\mathrm{Pa}$' + '\n' +  r'$E_D = ' + '{:.1e}'.format(Ed) + 'eV $'+ '\n' + r'$ E_R = $' + '{:.1e}'.format(Er) + ' $ eV $'
    legtitle = r'$ \eta^\prime = $' + '{:.4e}'.format(
        popt1[0]
    ) + ' $ \mathrm{Pa \cdot dpa} $' + '\n' r'$\sigma_0 = $' + '{:.2e}'.format(
        abs(pxx[0])
    ) + r'$\,\mathrm{Pa}$' + '\n' + r'$E_D = ' + '{:.1e}'.format(
        Ed) + '\mathrm{eV} $' + '\n' + r'$ E_R = $' + '{:.1e}'.format(
            Er) + ' $ \mathrm{eV} $'
    plt.legend(loc='best',
               shadow=False,
               title=legtitle,
               prop={'size': legpropsize},
               numpoints=1)

    #every other tick label
    for label in plt.gca().xaxis.get_ticklabels()[::2]:
        label.set_visible(False)

    #plt.show()
    fig.tight_layout()
    fig.savefig(outname)
    print "Png file written to " + outname
    plt.close("all")
Example #50
0
    def validate(self, epoch):
        preds = []
        dice_val = []
        loss_val = []
        if self.val_interval and ((epoch + 1) % self.val_interval
                                  == 0) and (epoch >= self.start_validation):
            if self.use_ADC:
                channel_idx = -2
            else:
                channel_idx = -1
            self.is_val = True
            for (i, idx) in enumerate(self.val_iter._batch_sampler):
                batch = nd.array(self.val_set[idx], ctx=self.ctx)
                if Training.use_ADC and Training.use_multi_branches:
                    x1 = batch[:-1, -2]
                    x2 = batch[:-1, [0, 1, -2]]
                else:
                    x = batch[:-1, :-1]
                gt = batch[:-1, -1]
                tmp = batch[-1, -1, 0].asnumpy()
                sl_idx = np.reshape(tmp[tmp > -999],
                                    (x.shape[0], -1)).astype('int')
                count_ = np.zeros((sl_idx.max() + 1))
                pred = np.zeros(
                    (2, sl_idx.max() + 1, x.shape[-2], x.shape[-1]))
                gt_wp = np.zeros(
                    (1, sl_idx.max() + 1, x.shape[-2], x.shape[-1]))
                x_wp = np.zeros(
                    (2, sl_idx.max() + 1, x.shape[-2], x.shape[-1]))
                tt = np.zeros(sl_idx.max() + 1)
                for ii in range(x.shape[0]):
                    if Training.use_ADC and Training.use_multi_branches:
                        if np.all((-100 < sl_idx[ii]) & (sl_idx[ii] <= 0)):
                            sl_idx[ii] = np.abs(sl_idx[ii])
                            pred[:, sl_idx[ii]] += np.flip(self.model.net(
                                x1[ii:ii + 1], x2[ii:ii + 1])[0].asnumpy(),
                                                           axis=-1)
                        elif np.all((-200 < sl_idx[ii])
                                    & (sl_idx[ii] <= -100)):
                            sl_idx[ii] = np.abs(sl_idx[ii] + 100)
                            pred[:, sl_idx[ii]] += np.flip(self.model.net(
                                x1[ii:ii + 1], x2[ii:ii + 1])[0].asnumpy(),
                                                           axis=-2)
                            # pred_tmp = self.model.net(x[ii:ii + 1])[0].asnumpy()
                            # pred[:, sl_idx[ii]] += ndimage.rotate(pred_tmp, angle=+5, axes=[-2, -1], reshape=False)
                        elif np.all(sl_idx[ii] >= 0):
                            pred[:, sl_idx[ii]] += self.model.net(
                                x1[ii:ii + 1], x2[ii:ii + 1])[0].asnumpy()
                            gt_wp[:, sl_idx[ii]] = gt[ii].asnumpy()
                            x_wp[:, sl_idx[ii]] = x[ii, channel_idx].asnumpy()
                    else:
                        if np.all((-100 < sl_idx[ii]) & (sl_idx[ii] <= 0)):
                            sl_idx[ii] = np.abs(sl_idx[ii])
                            pred[:, sl_idx[ii]] += np.flip(self.model.net(
                                x[ii:ii + 1])[0].asnumpy(),
                                                           axis=-1)
                        elif np.all((-200 < sl_idx[ii])
                                    & (sl_idx[ii] <= -100)):
                            sl_idx[ii] = np.abs(sl_idx[ii] + 100)
                            pred[:, sl_idx[ii]] += np.flip(self.model.net(
                                x[ii:ii + 1])[0].asnumpy(),
                                                           axis=-2)
                            # pred_tmp = self.model.net(x[ii:ii + 1])[0].asnumpy()
                            # pred[:, sl_idx[ii]] += ndimage.rotate(pred_tmp, angle=+5, axes=[-2, -1], reshape=False)
                        elif np.all(sl_idx[ii] >= 0):
                            pred[:, sl_idx[ii]] += self.model.net(
                                x[ii:ii + 1])[0].asnumpy()
                            gt_wp[:, sl_idx[ii]] = gt[ii].asnumpy()
                            x_wp[:, sl_idx[ii]] = x[ii, channel_idx].asnumpy()
                    tt[sl_idx[ii]] += 1
                    count_[sl_idx[ii]] += 1
                # pred /= count_[np.newaxis, :, np.newaxis, np.newaxis]
                # x_wp /= count_[np.newaxis, :, np.newaxis, np.newaxis]
                tt /= count_
                pred = post_proc(pred[np.newaxis].argmax(axis=1)[0])
                # pred = pred[np.newaxis].argmax(axis=1)[0]
                gt_wp = nd.array(gt_wp)
                pred = nd.array(pred[np.newaxis])

                dice_val.append(dice_wp(pred, gt_wp).expand_dims(0))
                loss_val.append(self.loss(pred, gt_wp).expand_dims(0))

                if self.show_val:
                    pred = pred[0].asnumpy()
                    fig = plt.figure(0)
                    for jj in range(pred.shape[0]):
                        plt.subplot(4, np.ceil(pred.shape[0] / 4), jj + 1)
                        plt.imshow(x_wp[-1, jj], cmap='gray', vmin=0, vmax=1)
                        if gt_wp[0, jj].sum() > 0:
                            plt.contour(gt_wp[0, jj].asnumpy(), linewidths=.2)
                        if pred[jj].sum() > 0:
                            plt.contour(pred[jj], colors='r', linewidths=.2)
                        plt.axis('off')
                    plt.savefig('{:s}/{:04d}_{:02d}_{:.2f}.png'.format(
                        self.dir_fig, epoch, i, dice_val[-1][0].asscalar()),
                                dpi=350)
                    plt.close('all')
                    if self.display_img:
                        plt.show()

            #     if self.file_suffix is "_full":
            #         pred_ = nd.zeros(shape=(pred.shape[0], pred.shape[1], 41, pred.shape[-1], pred.shape[-2]))
            #         pred_[:, :, :pred.shape[2]] = pred
            #         preds.append(pred_)
            #     else:
            #         preds.append(pred)
            # preds = nd.concat(*preds, dim=0).asnumpy()
            # dice_val = self.get_dice_wp(preds)

            logging.info(nd.concat(*dice_val)[0] * 100)
            logging.info((nd.concat(*dice_val)[0] * 100).mean())
        return dice_val, loss_val
Example #51
0
    # classes_txt文件中的每一行
    eachline = eachline.strip('\n')
    f = open(DATA_JSON + rf"\{eachline}.ndjson", 'r')
    for j in range(0, 10):
        line = f.readline()
        setting = json.loads(line)
        for i in range(0, len(setting['drawing'])):
            x = setting['drawing'][i][0]
            y = setting['drawing'][i][1]
            pl.plot(x, y, 'k')
        ax = pl.gca()
        ax.xaxis.set_ticks_position('top')
        ax.invert_yaxis()
        pl.axis('off')
        pl.savefig(
            rf"{BUTING_PATH}\code\static\dist\img\sp\{eachline}-{j}.png")
        pl.close()
        oldimg = cv2.imread(
            fr"{BUTING_PATH}\code\static\dist\img\sp\{eachline}-{j}.png",
            cv2.IMREAD_GRAYSCALE)
        newimg = cv2.resize(oldimg, (200, 200), interpolation=cv2.INTER_CUBIC)
        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (10, 10))
        dil = cv2.erode(newimg, kernel)
        plt.imsave(
            rf"{BUTING_PATH}\code\static\dist\img\sp\{eachline}-{j}.png",
            dil,
            cmap='gray')
    f.close()
    Log(f"{eachline} finished!")
f_data.close()
Example #52
0
    P.append(pdf(x))
    for itr in tqdm(range(nb_iter)):
        px = pdf(x)
        x_ = transition(x)
        px_ = pdf(x_)
        r = px_ / px
        if r > 1 or (np.random.rand() < r):
            x = x_
            if itr > 0.30 * nb_iter:
                X.append(x)
                P.append(px_)
    return X, P


if __name__ == "__main__":

    # Set up the parameters.
    max_x = 1
    max_y = 1
    X = []
    for k in range(5):
        X.extend(mcmc(pdf))
    X = np.array(X)

    plt.ion()
    plt.close("all")
    plt.plot(X[:, 0], X[:, 1], alpha=0.2)
    plt.plot(X[:, 0], X[:, 1], ".")
    plt.xlim([0, 1])
    plt.ylim([0, 1])
Example #53
0
def PlotOutput():

    x = len(LENGTH)
    y = len(CONTRAST)

    frameW = 1.5
    frameH = 1.5
    gapw = 0.05 * np.ones(x + 1)
    gapw[0] = 0.30
    gaph = 0.05 * np.ones(y + 1)
    #gaph[0] = 0.30
    gaph[4] = 0.30
    fig = FigArray(frameW, frameH, gapw, gaph)
    (W, H) = fig.dimensions()
    plt.figure(1, figsize=(W, H))

    objlist, objmaxlist = grab_files()

    ctr = 0

    plt.text(-0.1, 1.09, "L = 1.0 pix", fontsize=14, rotation=0, color='k')
    plt.text(0.11, 1.09, "L = 1.5 pix", fontsize=14, rotation=0, color='k')
    plt.text(0.32, 1.09, "L = 2.0 pix", fontsize=14, rotation=0, color='k')
    plt.text(0.53, 1.09, "L = 2.5 pix", fontsize=14, rotation=0, color='k')
    plt.text(0.74, 1.09, "L = 3.0 pix", fontsize=14, rotation=0, color='k')
    plt.text(0.95, 1.09, "L = 4.0 pix", fontsize=14, rotation=0, color='k')

    plt.text(-0.152, 1, "C = 5 mag", fontsize=14, rotation=90, color='k')
    plt.text(-0.152, 0.7, "C = 4 mag", fontsize=14, rotation=90, color='k')
    plt.text(-0.152, 0.4, "C = 3 mag", fontsize=14, rotation=90, color='k')
    plt.text(-0.152, 0.1, "C = 2 mag", fontsize=14, rotation=90, color='k')

    #plt.text(0.2,-0.11, "Detector Scale Truth Model", fontsize=16, rotation=0, color='k')

    plt.axis("off")

    for i in range(x):
        for j in range(y):

            dispim = np.power(objlist[ctr], PWR)
            dispim = dispim[35:45, 35:45]

            objmax = np.power(objmaxlist[ctr], PWR)

            #origin set in top-left corner
            a = plt.axes(fig.axes(i + 1, j + 1))

            #plt.text(0.1,6, "length = %.2f" %(LENGTH[i]), fontsize=5, rotation=0, color='w')
            #plt.text(0.1,13, "C = %.1f" %(CONTRAST[j]), fontsize=5, rotation=0, color='w')
            #plt.text(0.1, 20, "i = %d, j = %d"%(i,j), fontsize=5, rotation=0, color='y')
            #plt.text(0.1, 25, "ctr = %d"%(ctr), fontsize=5, rotation=0, color='y')

            p = plt.imshow(dispim,
                           vmax=objmax,
                           vmin=0,
                           cmap='gist_heat',
                           interpolation='nearest')

            a.xaxis.set_major_locator(plt.NullLocator())
            a.yaxis.set_major_locator(plt.NullLocator())
            plt.gray()  # overrides current and sets default

            ctr += 1

    plt.savefig(LOC + object_plot % (), dpi=150)
    plt.close()
Example #54
0
def exp_fit(crvfile,
            outname,
            dump_frequency,
            Er,
            Ed,
            Ebi,
            recoil_relaxation_time=30000,
            start_timeoffset=500):
    ## CRV File - renamed to .crv and manually changed header (crv format) from extracted data file

    ## PNG output

    ## timestep used in recoil.in during recoil insertion --> datapoint after each recoil

    crv = CRV.CRV(crvfile)[0]

    #extract mech. stress tensor in x or y
    pyy = crv['pyy']
    x = crv['step']
    n_atoms = crv['atoms'][0]
    #calc timeaxis out of pxx or pyy size
    #x = np.arange(0,len(pyy)*timestep,timestep)

    #number of recoils
    nrecoils = []

    #pressure tensor component
    pxx = []

    dump_factor = int(recoil_relaxation_time / dump_frequency)

    print dump_factor

    #reduce timeaxis to recoil axis
    for i in range(len(x) / dump_factor):
        nrecoils.append((x[i * dump_factor] - start_timeoffset) /
                        float(recoil_relaxation_time))
        pxx.append(abs(pyy[i * dump_factor] / pyy[0]))

    #number of displacements per target atom
    ndpa = np.multiply(nrecoils, (Er / (2.5 * Ed * n_atoms)))

    #fit
    popt, pcov = opt.curve_fit(lambda ndpa, eta: eta_exp(ndpa, Ebi, eta),
                               ndpa,
                               pxx,
                               p0=2e8)

    #anotate to add value to plot
    print 'RIV (exp)= {:.4e}'.format(popt[0])

    # npa interpolated
    ndpa_interp = np.linspace(0, ndpa[-1] * 5, 1000)

    fig = plt.figure(1, figsize=fsize)

    plt.xlim(0, ndpa_interp[-1])
    #plt.ylim(0.95*pxx[-1] , 1)
    plt.grid()

    plt.plot(ndpa,
             pxx,
             'bs',
             markeredgecolor='blue',
             markerfacecolor='None',
             markeredgewidth=mew,
             markersize=ms,
             label='MD Simulation')
    plt.plot(ndpa_interp,
             eta_exp(ndpa_interp, Ebi, *popt),
             'r-',
             linewidth=lw,
             label='Fit')
    plt.xlabel('Number of displacements per atom')
    plt.ylabel(r'$ \frac{\sigma}{\vert \sigma_0 \vert} $')

    legtitle = r'$ \eta_{ri} = $' + '{:.4e}'.format(
        popt[0]
    ) + ' $ Pa \cdot dpa $' + '\n' + r'$ E_{bi} = $' + '{:.3e}'.format(
        Ebi) + ' $ Pa $' + '\n' + r'$ E_D = $' + '{:.1e}'.format(
            Ed) + ' $ \mathrm{eV} $' + '\n' + r'$ E_R = $' + '{:.1e}'.format(
                Er) + ' $ \mathrm{eV} $'

    plt.legend(loc='best',
               shadow=False,
               title=legtitle,
               prop={'size': legpropsize},
               numpoints=1)

    #every other tick label
    for label in plt.gca().xaxis.get_ticklabels()[::2]:
        label.set_visible(False)

    #plt.show()
    fig.savefig(outname)
    print "Png file written to " + outname
    plt.close("all")

    return popt[0]
    summaryPlots[id]['N'] = yc.__len__()
    summaryPlots[id]['Litter'] = -1.
    summaryPlots[id]['LitterHa'] = -1.
    summaryPlots[id]['AgbHa'] = summaryPlots[id]['YcHa']

# write out summary ground truth for each plot
# write out summary ground truth for each plot
outFileName = 'C:\Data\Development\Projects\PhD GeoInformatics\Code\Results\Baviaans2017FieldTrialAnalysis\Summary - Woody & Litter.csv'
with open(outFileName, 'wb') as outfile:
    writer = DictWriter(outfile, summaryPlots.values()[0].keys())
    writer.writeheader()
    writer.writerows(summaryPlots.values())

# vars = [model['vars'] for model in allometricModels.values()]
# print np.unique(vars)
pylab.close('all')
i = 1
ycTtl = 0.
pylab.figure()
plotSummary = []
for plotKey, plot in plots.iteritems():
    yc = np.array([record['yc'] for record in plot])
    height = np.float64([record['height'] for record in plot])
    ycTtl += yc.sum()
    plotSummary.append({
        'ID': plotKey.replace('-', '_'),
        'Yc': yc.sum(),
        'N': yc.__len__()
    })

    kde = gaussian_kde(height)  #, bw_method=bandwidth / height.std(ddof=1))
# plots as PDF.

def plot_save_data(proc_data, binned_data, file_type = 'pdf'):      for sample in proc_data.keys()
        temp_data = proc_data[sample]
        temp_bin = binned_data[sample]
        PL.plot(proc_data[sample][:,1], proc_data[sample][:,3], '.', markersize = 12, \
        alpha = .05, label = "{0}".format(sample))
        PL.plot(temp_bin[:,0],temp_bin[:,3],'-k', linewidth = 2)
        PL.legend(loc = "upper left")
        PL.xlabel("SSC (Volume)")
        PL.ylabel("GFP Intensity (AU)")
        PL.ylim(0,1050)
        PL.xlim(0,1050)
        savepath = '{0}.{1}'.format(sample,file_type)
        PL.savefig(savepath)
        PL.close()

# New raw data is processed data


def analyze_data(fsc_thr, ssc_thr, bg_strain):
    print "Analyzing current folder..."
    print "Gating data..."
    data, strains = filter_all_data(fsc_thr, ssc_thr)
    print "Current folder data: {0}".format(strains)
    print "Binning data..."
    bin_data = bin_all(data)
    print "Performing background subtraction..."
    new_bin, new_raw = bg_sub_wrap(data, bin_data, bg_strain, strains)
    print "Plotting all data..."
    plot_save_data(new_raw, new_bin, file_type = "tif")
Example #57
0
    def visualize(self, dp, visual_params):

        w1, b1 = self.weights[1]
        w2, b2 = self.weights[-1]

        if visual_params['save']:
            if self.cfg.learning == "disc":
                num_filters = w1.shape[0]
                nn.show_images(w1, (4, num_filters / 4))
            if self.cfg.arch == "dense" and self.cfg.learning == "auto":
                # plt.figure(num=None, figsize=(30,90), dpi=80, facecolor='w', edgecolor='k')
                size = (10, 20)
                if self.cfg.dataset == "mnist":
                    # print size, w2.shape
                    nn.show_images(w2[:size[0] * size[1]], (size[0], size[1]),
                                   unit=1,
                                   scale=2)
                elif self.cfg.dataset in ("cifar10", "svhn-ram"):
                    nn.show_images(w2[:size[0] * size[1]].reshape(
                        size[0] * size[1], 3, 32, 32), (size[0], size[1]),
                                   unit=1)
                elif self.cfg.dataset == "faces":
                    nn.show_images(w2[:size[0] * size[1]].reshape(
                        size[0] * size[1], 1, 32, 32), (size[0], size[1]),
                                   unit=1)
                elif self.cfg.dataset == "faces48":
                    nn.show_images(w2[:size[0] * size[1]].reshape(
                        size[0] * size[1], 1, 48, 48), (size[0], size[1]),
                                   unit=1)
                elif self.cfg.dataset == "frey":
                    nn.show_images(w2[:size[0] * size[1]].reshape(
                        size[0] * size[1], 1, 20, 20), (size[0], size[1]),
                                   unit=1)
                elif self.cfg.dataset == "cifar10-patch":  #CIFAR10 dense patches
                    size = int(np.sqrt(self.cfg[0].shape / 3))
                    nn.show_images(w2[:256].reshape(256, 3, size, size),
                                   (16, 16),
                                   unit=1,
                                   scale=2)
                else:  #CIFAR10 dense patches
                    size = int(np.sqrt(self.cfg[0].shape))
                    # print size
                    nn.show_images(w2[:200].reshape(200, 1, size, size),
                                   (10, 20),
                                   unit=1,
                                   scale=2)
                    # nn.show_images(w2[:64].reshape(64,1,size,size),(8,8),unit=1,scale=2)

            if self.cfg.learning == "auto" and self.cfg.arch == "conv":

                # print w2.as_numpy_array()[:num_filters,:,:,:].shape
                num_filters = w2.shape[0]
                # print w2.shape
                nn.show_images(w2.as_numpy_array()[:num_filters, :, :, :],
                               (4, num_filters / 4),
                               unit=1,
                               scale=2)

                # plt.subplot(212)
                # num_filters = w1.shape[0]
                # nn.show_images(w1.as_numpy_array()[:num_filters,:,:,:],(4,num_filters/4),unit=1)

                # print w1.shape
                # nn.show_images(np.swapaxes(w2.as_numpy_array(),0,1)[:num_filters,:,:,:],(4,num_filters/4),unit=1)
                # plt.show()
            plt.savefig(self.cfg.directory + self.cfg.name + ".png",
                        format="png")
            plt.close()
        else:
            if not nn.is_interactive():
                if self.cfg.learning == "auto" and not (self.cfg.dataset in (
                        "cifar10-second", "svhn-second", "mnist-second")):
                    plt.figure(num=1,
                               figsize=(15, 10),
                               dpi=80,
                               facecolor='w',
                               edgecolor='k')
                else:
                    plt.figure(num=1,
                               figsize=(15, 5),
                               dpi=80,
                               facecolor='w',
                               edgecolor='k')
        # X = dp.X_id(0)
        # x = nn.data_convertor(X,0,1)
            w1, b1 = self.weights[1]
            w2, b2 = self.weights[-1]

            if self.cfg.arch == "dense" and self.cfg.learning == "disc":  #dense

                if nn.is_interactive():
                    plt.figure(num=1,
                               figsize=(15, 5),
                               dpi=80,
                               facecolor='w',
                               edgecolor='k')
                plt.figure(1)
                plt.subplot(131)
                self.plot_train()
                plt.subplot(132)
                self.plot_test()
                plt.subplot(133)

                if self.cfg.dataset == "mnist":
                    if w1.shape[1] > 25:
                        nn.show_images(w1[:, :25].T, (5, 5))  #MNIST dense
                    else:
                        nn.show_images(w1[:, :].T,
                                       (5, w1.shape[1] / 5))  #MNIST softmax
                elif self.cfg.dataset in ("cifar10", "svhn-ram"):
                    # print w1.shape
                    if w1.shape[1] > 25:
                        nn.show_images(w1.T[:25, :].reshape(25, 3, 32, 32),
                                       (5, 5))  #CIFAR10 dense
                    else:
                        nn.show_images(w1[:, :].reshape(3, 32, 32, 10),
                                       (5, 2))  #CIFAR10 softmax
                elif self.cfg.dataset in ("svhn-torch"):
                    # print w1.shape
                    if w1.shape[1] > 25:
                        nn.show_images(w1.T[:25, :].reshape(25, 3, 32, 32),
                                       (5, 5),
                                       yuv=True)  #CIFAR10 dense
                    else:
                        nn.show_images(w1[:, :].reshape(3, 32, 32, 10), (5, 2),
                                       yuv=True)  #CIFAR10 softmax
                elif self.cfg.dataset == "cifar10-patches":  #CIFAR10 dense patches
                    if u == None:
                        nn.show_images(w1[:, :25].reshape(3, 8, 8, 25), (5, 5))
                    else:
                        nn.show_images(whiten_undo(
                            w1[:, :25].T.as_numpy_array(), u,
                            s).T.reshape(3, 8, 8, 25), (5, 5),
                                       unit=True)
                elif self.cfg.dataset == "mnist-patches":  #MNIST dense patches
                    nn.show_images(w1[:, :25].T.as_numpy_array().T.reshape(
                        1, 8, 8, 16), (4, 4),
                                   unit=True)
                else:
                    channel = self.H[0].shape[1]
                    size = self.H[0].shape[2]
                    if w1.shape[1] > 25:
                        nn.show_images(
                            w1.T[:25, :].reshape(25, channel, size, size),
                            (5, 5))
                    else:
                        nn.show_images(
                            w1[:, :].reshape(10, channel, size, size), (5, 2))

            if self.cfg.arch == "dense" and self.cfg.learning == "auto" and not self.cfg.dataset_extra:  #dense
                if nn.is_interactive():
                    plt.figure(num=1,
                               figsize=(15, 10),
                               dpi=80,
                               facecolor='w',
                               edgecolor='k')
                plt.figure(1)
                plt.subplot2grid((2, 3), (0, 0), colspan=1)
                self.plot_train()

                plt.subplot2grid((2, 3), (0, 1), colspan=2)

                if self.cfg.dataset == "mnist":
                    nn.show_images(w2[:50], (5, 10))
                    # nn.show_images(w2[:25],(5,5))
                elif self.cfg.dataset in ("cifar10", "svhn-ram"):
                    # print w2.shape
                    nn.show_images(w2[:50].reshape(50, 3, 32, 32), (5, 10))
                elif self.cfg.dataset == "svhn-torch":  #CIFAR10 dense patches
                    nn.show_images(w2[:50].reshape(50, 3, 32, 32), (5, 10),
                                   yuv=True)
                elif self.cfg.dataset == "cifar10-patch":  #CIFAR10 dense patches
                    size = int(np.sqrt(self.H[0].shape[1] / 3))
                    # print size
                    nn.show_images(w2[:50].reshape(50, 3, size, size), (5, 10))
                    # if u==None: nn.show_images(w1[:,:25].reshape(3,8,8,25),(5,5))
                    # else: nn.show_images(whiten_undo(w1[:,:25].T.as_numpy_array(),u,s).T.reshape(3,8,8,25),(5,5),unit=True)
                elif self.cfg.dataset == "mnist-patches":  #MNIST dense patches
                    nn.show_images(w1[:, :25].T.as_numpy_array().T.reshape(
                        1, 8, 8, 16), (4, 4),
                                   unit=True)
                else:  #CIFAR10 dense patches
                    size = int(np.sqrt(self.H[0].shape[1]))
                    # print w2[:50].shape,size
                    nn.show_images(w2[:50].reshape(50, 1, size, size), (5, 10))

                plt.subplot2grid((2, 3), (1, 0), colspan=1)
                if self.cfg.dataset in ("natural", "mnist"):
                    nn.show_images(w1[:, :25].T, (5, 5))

                    # w1,b1 = self.weights[1]
                    # w2,b2 = self.weights[2]
                    # print w1[:5,:5]
                    # print w2[:5,:5].T
                    # print "------"

                plt.subplot2grid((2, 3), (1, 1), colspan=1)
                if self.cfg.dataset == "mnist":
                    nn.show_images(self.H[0][0].reshape(1, 1, 28, 28), (1, 1))
                elif self.cfg.dataset in ("cifar10", "svhn-ram"):
                    nn.show_images(self.H[0][0].reshape(1, 3, 32, 32), (1, 1))
                elif self.cfg.dataset == "svhn-torch":
                    nn.show_images(self.H[0][0].reshape(1, 3, 32, 32), (1, 1),
                                   yuv=True)
                elif self.cfg.dataset == "cifar10-patch":  #CIFAR10 dense patches
                    size = int(np.sqrt(self.H[0].shape[1] / 3))
                    nn.show_images(self.H[0][0].reshape(1, 3, size, size),
                                   (1, 1))
                else:  #CIFAR10 dense patches
                    size = int(np.sqrt(self.H[0].shape[1]))
                    nn.show_images(self.H[0][0].reshape(1, 1, size, size),
                                   (1, 1))

                plt.subplot2grid((2, 3), (1, 2), colspan=1)
                if self.cfg.dataset == "mnist":
                    nn.show_images(self.H[-1][0].reshape(1, 1, 28, 28), (1, 1))
                elif self.cfg.dataset in ("cifar10", "svhn-ram"):
                    nn.show_images(self.H[-1][0].reshape(1, 3, 32, 32), (1, 1))
                elif self.cfg.dataset == "svhn-torch":
                    nn.show_images(self.H[-1][0].reshape(1, 3, 32, 32), (1, 1),
                                   yuv=True)
                elif self.cfg.dataset == "cifar10-patch":  #CIFAR10 dense patches
                    size = int(np.sqrt(self.H[0].shape[1] / 3))
                    nn.show_images(self.H[-1][0].reshape(1, 3, size, size),
                                   (1, 1))
                else:  #CIFAR10 dense patches
                    size = int(np.sqrt(self.H[0].shape[1]))
                    nn.show_images(self.H[-1][0].reshape(1, 1, size, size),
                                   (1, 1))

            if self.cfg.arch == "conv" and self.cfg.learning == "disc":

                if nn.is_interactive():
                    plt.figure(num=1,
                               figsize=(15, 5),
                               dpi=80,
                               facecolor='w',
                               edgecolor='k')
                plt.figure(1)
                plt.subplot(131)
                self.plot_train()
                plt.subplot(132)
                self.plot_test()
                plt.subplot(133)

                nn.show_images(w1[:16, :, :, :], (4, 4))

            if self.cfg.arch == "conv" and self.cfg.learning == "auto":
                if nn.is_interactive():
                    plt.figure(num=1,
                               figsize=(15, 10),
                               dpi=80,
                               facecolor='w',
                               edgecolor='k')
                plt.figure(1)
                # w2,b2 = self.weights[-1]

                # x=X[:,:,:,:1]
                # self.feedforward(x)
                if self.cfg.dataset in ("cifar10-second", "svhn-second",
                                        "mnist-second"):  #CIFAR10
                    plt.subplot(131)
                    # print self.H[0].shape,self.H[-1].shape,self.H[-1].max()
                    nn.show_images(np.swapaxes(
                        self.H[0][:1, :16, :, :].as_numpy_array(), 0, 1),
                                   (4, 4),
                                   bg="white")
                    plt.subplot(132)
                    nn.show_images(np.swapaxes(
                        self.H[-1][:1, :16, :, :].as_numpy_array(), 0, 1),
                                   (4, 4),
                                   bg="white")
                    plt.subplot(133)
                    nn.show_images(np.swapaxes(
                        self.H[-2][:1, :16, :, :].as_numpy_array(), 0, 1),
                                   (4, 4),
                                   bg="white")
                    # print self.H[-1]
                else:
                    plt.subplot(231)
                    nn.show_images(
                        self.H[0][0, :, :, :].reshape(1, self.H[0].shape[1],
                                                      self.H[0].shape[2],
                                                      self.H[0].shape[3]),
                        (1, 1))
                    plt.subplot(232)
                    nn.show_images(
                        self.H[-1][0, :, :, :].reshape(1, self.H[-1].shape[1],
                                                       self.H[-1].shape[2],
                                                       self.H[-1].shape[3]),
                        (1, 1))

                    plt.subplot(233)

                    self.plot_train()
                    plt.subplot(234)
                    # if self.H[1].shape[1]>=16:

                    # H1 = self.H[1].as_numpy_array()
                    # H1 = H1.reshape(16*100,28*28)
                    # print np.nonzero(H1)[0].shape
                    nn.show_images(np.swapaxes(
                        self.H[-2][:1, :16, :, :].as_numpy_array(), 0, 1),
                                   (4, 4),
                                   bg="white")
                    # else:
                    # nn.show_images(np.swapaxes(self.H[1][:1,:8,:,:].as_numpy_array(),0,1),(2,4),bg="white")
                    plt.subplot(235)
                    # if w1.shape[0]>16:
                    nn.show_images(w1[:16, :, :, :], (4, 4))
                    # else:
                    # nn.show_images(w1[:8,:,:,:],(2,4))
                    plt.subplot(236)
                    # if w2.shape[0]>=16:
                    # print w2.shape
                    # if self.cfg.dataset == "svhn-torch":
                    # nn.show_images(np.swapaxes(w2.as_numpy_array(),0,1)[:16,:,:,:],(4,4),unit=1,yuv=1)

                    if self.cfg[-1].type == "convolution":
                        nn.show_images(np.swapaxes(w2.as_numpy_array(), 0,
                                                   1)[:16, :, :, :], (4, 4),
                                       unit=1)
                    if self.cfg[-1].type == "deconvolution":
                        nn.show_images(w2[:16, :, :, :], (4, 4), unit=1)
                # else:
                # nn.show_images(np.swapaxes(w2.as_numpy_array(),0,1)[:,:8,:,:],(2,4),unit=True)

            if nn.is_interactive(): plt.show()
            else:
                plt.draw()
                plt.pause(.01)

            if self.cfg.dataset_extra == "generate":  #dense
                for k in self.cfg.index_dense:
                    if self.cfg[k].l2_activity != None: index = k

                if nn.is_interactive():
                    plt.figure(num=1,
                               figsize=(15, 10),
                               dpi=80,
                               facecolor='w',
                               edgecolor='k')
                plt.figure(1)
                plt.subplot2grid((2, 3), (0, 0), colspan=1)
                self.plot_train()

                plt.subplot2grid((2, 3), (0, 1), colspan=2)

                if self.cfg.dataset == "mnist":
                    nn.show_images(w2[:50], (5, 10))
                plt.subplot2grid((2, 3), (1, 1), colspan=1)
                # if self.cfg.dataset == "mnist":
                # print self.H[index].shape
                x = self.H[index][:, 0].as_numpy_array()
                y = self.H[index][:, 1].as_numpy_array()
                plt.plot(x, y, 'bo')
                # plt.grid()

                x = self.T_sort[:, 0].as_numpy_array()
                y = self.T_sort[:, 1].as_numpy_array()
                plt.plot(x, y, 'ro')
                # plt.grid()

                # x = self.test_rand[:,0].as_numpy_array()
                # y = self.test_rand[:,1].as_numpy_array()
                # plt.plot(x,y,'go')
                plt.grid()

                # nn.show_images(self.H[0][0].reshape(1,1,28,28),(1,1))

                plt.subplot2grid((2, 3), (1, 2), colspan=1)
                if self.cfg.dataset == "mnist":
                    nn.show_images(self.H[-1][0].reshape(1, 1, 28, 28), (1, 1))

        if self.cfg.dataset == "mnist" and self.cfg.dataset_extra in (
                "vae", "generate"):
            plt.figure(num=5,
                       figsize=(15, 10),
                       dpi=80,
                       facecolor='w',
                       edgecolor='k')
            temp = nn.randn((64, 784))
            self.test_mode = True
            self.feedforward(temp)
            self.test_mode = False
            nn.show_images(self.H[-1].reshape(64, 1, 28, 28), (8, 8))
            if visual_params['save']:
                plt.savefig(self.cfg.directory + self.cfg.name +
                            "_samples.png",
                            format="png")
            else:
                plt.draw()
                plt.pause(.01)
Example #58
0
    def plot_splines(self,
                     pred_f_3d,
                     best_parameters_cv_array,
                     verbose_plot=False):
        if os.path.exists(self.directory_save_splines):
            shutil.rmtree(self.directory_save_splines)
        os.makedirs(self.directory_save_splines)

        directory_save_dfs = 'dataset/output_data/data_frames/'
        if os.path.exists(directory_save_dfs):
            shutil.rmtree(directory_save_dfs)
        os.makedirs(directory_save_dfs)

        pred_f_3d_avg = np.nanmean(pred_f_3d, axis=2)
        pred_f_3d_sd = np.nanstd(pred_f_3d, axis=2)
        pred_f_3d_max = np.nanmax(pred_f_3d, axis=2)
        pred_f_3d_min = np.nanmin(pred_f_3d, axis=2)

        spline_smooth = np.round(np.mean(best_parameters_cv_array[:, 1]), 2)
        for i in range(len(self.stable_feature_indices)):
            if verbose_plot:
                print(("Generating figure %i out of %i" %
                       (i + 1, len(self.stable_feature_indices))))
            sel_idx = self.stable_feature_indices[i]
            pl.figure(figsize=(16, 9), dpi=100, facecolor='w', edgecolor='k')
            ii = np.argsort(self.X_train[:, sel_idx])
            y_avg_splined, dummy_variable = model.train_spline(
                self.X_train[:, sel_idx][ii],
                pred_f_3d_avg[:, sel_idx][ii],
                self.X_train[:, sel_idx][ii],
                smooth_factor=spline_smooth)
            y_sd_lower, dummy_variable = model.train_spline(
                self.X_train[:, sel_idx][ii],
                y_avg_splined - pred_f_3d_sd[:, sel_idx][ii],
                self.X_train[:, sel_idx][ii],
                smooth_factor=spline_smooth)
            y_sd_upper, dummy_variable = model.train_spline(
                self.X_train[:, sel_idx][ii],
                y_avg_splined + pred_f_3d_sd[:, sel_idx][ii],
                self.X_train[:, sel_idx][ii],
                smooth_factor=spline_smooth)
            pl.plot(self.X_train[:, sel_idx][ii], y_avg_splined, "r-")
            pl.plot(self.X_train[:, sel_idx][ii],
                    pred_f_3d_avg[:, sel_idx][ii], "k.")
            #            pl.errorbar(self.X_train[:, sel_idx][ii],pred_f_3d_avg[:, sel_idx][ii],
            #                    yerr=pred_f_3d_sd[:, sel_idx][ii],fmt='go')
            pl.fill_between(self.X_train[:, sel_idx][ii],
                            y_sd_lower,
                            y_sd_upper,
                            alpha=1,
                            edgecolor='gainsboro',
                            facecolor='gainsboro')
            pl.xlabel("Feature value")
            pl.ylabel("Prediction f(x) value")
            pl.title("Predictions for feature " + self.feature_names[sel_idx])
            pl.grid()
            pl.savefig(self.directory_save_splines + 'spam_feature_' +
                       str(sel_idx) + '.png')
            pl.close()
            dataframe_data = np.transpose(
                np.array([
                    self.X_train[:, sel_idx][ii],
                    pred_f_3d_avg[:, sel_idx][ii], pred_f_3d_sd[:,
                                                                sel_idx][ii],
                    pred_f_3d_max[:, sel_idx][ii], pred_f_3d_min[:,
                                                                 sel_idx][ii]
                ]))
            dataframe_columns = [
                'feat_values_sorted', 'pred_f_3d_avg_sorted',
                'pred_f_3d_sd_sorted', 'pred_f_3d_max_sorted',
                'pred_f_3d_min_sorted'
            ]
            df_save = pd.DataFrame(data=dataframe_data,
                                   columns=dataframe_columns)
            df_save.to_csv(directory_save_dfs + 'spam_feature_' +
                           str(sel_idx) + '.txt',
                           header=True,
                           index=False,
                           sep='\t',
                           float_format='%.5f')

        return True
def process_summary(summary_filename):
    if ('fake' in summary_filename) or \
            ('H3' in summary_filename) or \
            ('H4' in summary_filename) or \
            ('H7' in summary_filename) or \
            ('H8' in summary_filename):
        logging.debug("Skipping %s" % summary_filename)
        return
    summary = physio.summary.Summary(summary_filename)
    logging.debug("Processing %s" % summary._filename)

    # cull trials by success
    trials = summary.get_trials()
    if len(trials) == 0:
        logging.error("No trails for %s" % summary._filename)
        return
    trials = trials[trials['outcome'] == 0]
    # and gaze
    gaze = clean_gaze(summary.get_gaze())

    if len(gaze) > 0:
        logging.debug("N Trials before gaze culling: %i" % len(trials))
        trials = cull_trials_by_gaze(trials, gaze)
        logging.debug("N Trials after gaze culling: %i" % len(trials))

    for ch in xrange(1, 33):
        for cl in summary.get_cluster_indices(ch):
            outdir = '%s/%s_%i_%i' % \
                    (resultsdir, os.path.basename(summary._filename), ch, cl)

            info_dict = {}

            logging.debug("ch: %i, cl: %i" % (ch, cl))
            # rate
            spike_times = summary.get_spike_times(ch, cl)

            # find start of isolation
            isolation_start = physio.spikes.times.\
                    find_isolation_start_by_isi(spike_times)
            spike_times = spike_times[spike_times >= isolation_start]

            nspikes = len(spike_times)
            info_dict['nspikes'] = nspikes
            if nspikes < min_spikes:
                logging.warning("\t%i < min_spikes[%i]" % \
                        (nspikes, min_spikes))
                continue
            trange = (spike_times.min(), spike_times.max())
            # trange = summary.get_epoch_range()
            rate = nspikes / (trange[1] - trange[0])
            info_dict['rate'] = rate
            if rate < min_rate:
                logging.warning("\t%i < min_rate[%i]" % \
                        (rate, min_rate))
                continue

            # filter trials
            dtrials = summary.filter_trials(trials, \
                    {'name': {'value': 'BlueSquare', 'op': '!='}}, \
                    timeRange=trange)
            if len(dtrials) == 0:
                logging.error("Zero trials for %i %i %s" % \
                        (ch, cl, summary._filename))
                continue

            # snr TODO

            # location
            try:
                location = summary.get_location(ch)
            except Exception as E:
                location = (0, 0, 0)
                print "Attempt to get location failed: %s" % str(E)
            info_dict['location'] = list(location)

            # significant bins
            #bins = summary.get_significant_bins(ch, cl, attr="name", \
            #        blacklist="BlueSquare", spike_times=spike_times, \
            #        timeRange=trange)
            if default_bins is None:
                bins = summary.get_significant_bins(ch, cl, trials=dtrials, \
                        spike_times=spike_times)
            else:
                bins = default_bins
            info_dict['bins'] = bins

            baseline = summary.get_baseline(ch, cl, prew, trials=trials, \
                    spike_times=spike_times)
            info_dict['baseline'] = baseline

            # selectivity
            #resps, means, stds, ns = summary.get_binned_response( \
            #        ch, cl, 'name', bins=bins, spike_times=spike_times, \
            #        blacklist="BlueSquare", timeRange=trange)
            resps, means, stds, ns = summary.get_binned_response( \
                    ch, cl, 'name', bins=bins, spike_times=spike_times, \
                    trials=dtrials, timeRange=trange)
            if len(resps) == 0:
                logging.warning("No responses")
                continue
            sel_index = physio.spikes.selectivity.selectivity(resps.values())
            #if numpy.isnan(sel_index):
            #    raise Exception("Selectivity is nan")
            sorted_names = sorted(resps, key=lambda k: resps[k])
            info_dict['selectivity'] = sel_index
            info_dict['sorted_names'] = sorted_names

            if not os.path.exists(outdir):
                os.makedirs(outdir)
            with open(outdir + '/info_dict.p', 'w') as f:
                pickle.dump(info_dict, f, 2)

            with open(outdir + '/sel_info.p', 'w') as f:
                pickle.dump({'resps': resps, 'means': means, 'stds': stds, \
                        'ns': ns}, f, 2)

            x = pylab.arange(len(resps))
            y = pylab.zeros(len(resps))
            err = pylab.zeros(len(resps))
            pylab.figure(1)
            for (i, name) in enumerate(sorted_names):
                y[i] = resps[name]
                # TODO fix this to be something reasonable
                #err[i] = (pylab.sum(stds[name][bins]) / float(len(bins))) / \
                #        pylab.sqrt(ns[name])
                err[i] = 0
            pylab.errorbar(x, y, err)
            xl = pylab.xlim()
            pylab.xticks(x, sorted_names)
            pylab.xlim(xl)
            pylab.ylabel('average binned response')
            pylab.title('Selectivity: %.2f' % sel_index)
            pylab.savefig(outdir + '/by_name.png')
            pylab.close(1)

            # separability
            # get stims without bluesquare
            stims = summary.get_stimuli({'name': \
                    {'value': 'BlueSquare', 'op': '!='}})
            attr_combinations = {}
            sep_info = {}
            for (ai, attr1) in enumerate(attrs[:-1]):
                uniques1 = numpy.unique(stims[attr1])
                for attr2 in attrs[ai + 1:]:
                    uniques2 = numpy.unique(stims[attr2])
                    if attr1 == attr2:
                        continue
                    M = summary.get_response_matrix(ch, cl, attr1, attr2, \
                            bins=bins, spike_times=spike_times, stims=stims, \
                            uniques1=uniques1, uniques2=uniques2, \
                            timeRange=trange, trials=dtrials)
                    if M.shape[0] == 1 or M.shape[1] == 1:
                        logging.warning("M.shape %s, skipping" % \
                                str(M.shape))
                        continue
                    sep, spi, ps = physio.spikes.separability.\
                            separability_permutation(M)
                    if not pylab.any(pylab.isnan(M)):
                        pylab.figure(1)
                        pylab.imshow(M, interpolation='nearest')
                        pylab.colorbar()
                        pylab.xlabel(attr2)
                        xl = pylab.xlim()
                        yl = pylab.ylim()
                        pylab.xticks(range(len(uniques2)), uniques2)
                        pylab.ylabel(attr1)
                        pylab.yticks(range(len(uniques1)), uniques1)
                        pylab.xlim(xl)
                        pylab.ylim(yl)
                        pylab.title('Sep: %s, %.4f, (%.3f, %.3f)' % \
                                (str(sep), spi, ps[0], ps[1]))
                        pylab.savefig(outdir + '/%s_%s.png' % \
                                (attr1, attr2))
                        pylab.close(1)
                    sep_info['_'.join((attr1, attr2))] = { \
                            'sep': sep, 'spi': spi, 'ps': ps}

            with open(outdir + '/sep_info.p', 'w') as f:
                pickle.dump(sep_info, f, 2)

            # compute separability at each name
            name_sep_info = {}
            for name in sorted_names:
                stims = summary.get_stimuli({'name': name})
                for (ai, attr1) in enumerate(attrs[:-1]):
                    uniques1 = numpy.unique(stims[attr1])
                    for attr2 in attrs[ai + 1:]:
                        uniques2 = numpy.unique(stims[attr2])
                        if attr1 == attr2 or \
                                attr1 == 'name' or attr2 == 'name':
                            continue
                        M = summary.get_response_matrix(ch, cl, attr1, \
                                attr2, bins=bins, spike_times=spike_times,\
                                stims=stims, uniques1=uniques1, \
                                uniques2=uniques2, timeRange=trange, \
                                trials=dtrials)
                        if M.shape[0] == 1 or M.shape[1] == 1:
                            logging.debug("M.shape incompatible" \
                                    " with separability: %s" % \
                                    str(M.shape))
                            continue
                        else:
                            sep, spi, ps = physio.spikes.separability.\
                                    separability_permutation(M)
                            if not pylab.any(pylab.isnan(M)):
                                pylab.figure(1)
                                pylab.imshow(M, interpolation='nearest')
                                pylab.colorbar()
                                pylab.xlabel(attr2)
                                xl = pylab.xlim()
                                yl = pylab.ylim()
                                pylab.xticks(range(len(uniques2)), uniques2)
                                pylab.ylabel(attr1)
                                pylab.yticks(range(len(uniques1)), uniques1)
                                pylab.xlim(xl)
                                pylab.ylim(yl)
                                pylab.title('Sep: %s, %.4f, (%.3f, %.3f)' \
                                        % (str(sep), spi, ps[0], ps[1]))
                                pylab.savefig(outdir + '/%s_%s_%s.png' % \
                                        (name, attr1, attr2))
                                pylab.close(1)
                            name_sep_info['_'.join((name, attr1, attr2))] \
                                    = {'sep': sep, 'spi': spi, 'ps': ps}

            with open(outdir + '/name_sep_info.p', 'w') as f:
                pickle.dump(name_sep_info, f, 2)
Example #60
0
def plot_station_map(plottitle,
                     plotregion,
                     topo,
                     coastal,
                     border,
                     fault,
                     sta,
                     map_prefix,
                     hypocenter_list=None):
    """
    Genereate the station map plot
    """

    # Read in topo data
    topo_points = read_topo(topo, plotregion)

    # Read in fault data
    fault_x, fault_y = read_fault(fault)

    # Read in station data
    sta_x, sta_y = read_stations(sta)

    # Read coastlines
    coast_x, coast_y = read_coastal(coastal, plotregion)

    # Read borders
    bord_x, bord_y = read_coastal(border, plotregion)

    # Set plot dims
    pylab.gcf().set_size_inches(6, 6)
    pylab.gcf().clf()

    # Adjust title y-position
    t = pylab.title(plottitle, size=12)
    t.set_y(1.06)

    # Setup color scale
    cmap = cm.gist_earth
    norm = mcolors.Normalize(vmin=-1000.0, vmax=3000.0)

    # Plot basemap
    pylab.imshow(topo_points,
                 cmap=cmap,
                 norm=norm,
                 extent=plotregion,
                 interpolation='nearest')

    # Freeze the axis extents
    pylab.gca().set_autoscale_on(False)

    # Plot coast lines
    for i in xrange(0, len(coast_x)):
        pylab.plot(coast_x[i], coast_y[i], linestyle='-', color='0.5')

    # Plot borders
    for i in xrange(0, len(bord_x)):
        pylab.plot(bord_x[i], bord_y[i], linestyle='-', color='0.75')

    # Plot fault trace
    pylab.plot(fault_x, fault_y, linestyle='-', color='k')

    # Plot stations
    pylab.plot(sta_x, sta_y, marker='o', color='r', linewidth=0)

    # Plot hypocenter if provided
    if hypocenter_list is not None:
        hypo_lat = []
        hypo_lon = []
        for hypocenter in hypocenter_list:
            hypo_lat.append(hypocenter['lat'])
            hypo_lon.append(hypocenter['lon'])
        pylab.plot(hypo_lon,
                   hypo_lat,
                   marker='*',
                   markersize=12,
                   color='y',
                   linewidth=0)

    # Set degree formatting of tick values
    majorFormatter = FormatStrFormatter(u'%.1f\u00b0')
    pylab.gca().xaxis.set_major_formatter(majorFormatter)
    pylab.gca().yaxis.set_major_formatter(majorFormatter)

    # Turn on ticks for both sides of axis
    for tick in pylab.gca().xaxis.get_major_ticks():
        tick.label1On = True
        tick.label2On = True
    for tick in pylab.gca().yaxis.get_major_ticks():
        tick.label1On = True
        tick.label2On = True

    # Set font size
    for tick in pylab.gca().get_xticklabels():
        tick.set_fontsize(8)
    for tick in pylab.gca().get_yticklabels():
        tick.set_fontsize(8)

    print("==> Creating Plot: %s.png" % (map_prefix))
    pylab.savefig('%s.png' % (map_prefix),
                  format="png",
                  transparent=False,
                  dpi=plot_config.dpi)
    pylab.close()