def nice_plot(data,xmin,xmax,xint,centerlat,centerlon,stations,color,cmin,
              cmax,levels_t):
    """Make plots in map projection, requires input array, x-min max and 
       interval (also used for y), center of data in lat, lon, station 
       locations, color scale, min and max limits and levels array for color
       scale.
    """
    domain = xmax-xint/2.
    maps = Basemap(projection='laea',lat_0=centerlat,lon_0=centerlon,
                   width=domain*2,height=domain*2)
    s = plt.pcolormesh(np.arange(xmin-xint/2.,xmax+3*xint/2.,xint)+domain,
                       np.arange(xmin-xint/2.,xmax+3*xint/2.,xint)+domain,
                       data, cmap = color)
    s.set_clim(vmin=cmin,vmax=cmax)
    CS = plt.contour(np.arange(xmin,xmax+xint,xint)+domain,
                     np.arange(xmin,xmax+xint,xint)+domain,
                     data, colors='k',levels=levels_t)
    plt.clabel(CS, inline=1, fmt='%1.2f',fontsize=8)
    plt.scatter(stations[:,0]+domain, stations[:,1]+domain, color='k',s=2)
    maps.drawstates()
    fig = plt.gcf()
    circle=plt.Circle((domain,domain),100000,color='0.5',fill=False)
    fig.gca().add_artist(circle)
    circle=plt.Circle((domain,domain),200000,color='0.5',fill=False)
    fig.gca().add_artist(circle)
Exemple #2
0
def plot_mle_graph(function,
                   mle_params,
                   x_start=eps, x_end=1 - eps,
                   y_start=eps, y_end=1 - eps, resolution=100,
                   x_label="x", y_label="y",
                   show_constraint=False,
                   show_optimum=False):
    x = np.linspace(x_start, x_end, resolution)
    y = np.linspace(y_start, y_end, resolution)
    xx, yy = np.meshgrid(x, y)
    np_func = np.vectorize(lambda x, y: function(x, y))
    z = np_func(xx, yy)

    optimal_loss = function(*mle_params)
    levels_before = np.arange(optimal_loss - 3.0, optimal_loss, 0.25)
    levels_after = np.arange(optimal_loss, min(optimal_loss + 2.0, -0.1), 0.25)

    fig = plt.figure()
    contour = plt.contour(x, y, z, levels=np.concatenate([levels_before, levels_after]))
    plt.xlabel(x_label)
    plt.ylabel(y_label)

    if show_constraint:
        plt.plot(x, 1 - x)
    if show_optimum:
        plt.plot(mle_params[0], mle_params[1], 'ro')
    plt.clabel(contour)
    return mpld3.display(fig)
Exemple #3
0
    def overlayCnvCntrs(self):
        """Overlay convection contours from mapex data
        
        **Belongs to**: :class:`MapConv`

        **Returns**:
            contours of convection are overlayed on the map object.
        **Example**:
            ::

                MapConv.overlayCnvCntrs()
        """
        from matplotlib.ticker import LinearLocator
        import matplotlib.pyplot as plt


        # get the lats, lons and potentials from calcCnvPots() function
        ( latCntr, lonCntr, potCntr ) = self.calcCnvPots()

        #plot the contours
        xCnt, yCnt = self.mObj( lonCntr, latCntr, coords=self.plotCoords )
        cntrPlt = self.mObj.contour( xCnt, yCnt, potCntr, 
            zorder = 2.,
            vmax=potCntr.max(), vmin=potCntr.min(), 
            colors = 'DarkSlateGray', linewidths=1., 
            locator=LinearLocator(12) )
        plt.clabel(cntrPlt, inline=1, fontsize=10)
def free_energy(centers, A, levels=None, norm=None,\
                fmt='%.1f', method='linear', fill_value=np.nan,
                ax = None):
    r"""Make contourplot of alanine-dipeptide free energy.

    The scattered data is interpolated onto a regular grid 
    before plotting.

    Parameters
    ----------
    centers : (N, 2) ndarray 
        (phi, psi) coordinates of MSM discretization.
    A : (N, ) ndarray,
        Free energy.

    ax : optional matplotlib axis to plot to
    """
    X, Y=np.meshgrid(xcenters, ycenters)
    Z=griddata(centers, A, (X, Y), method=method, fill_value=fill_value)
    Z=Z-Z.min()
    if levels is None:
        levels=np.linspace(0.0, 50.0, 10)
    V=np.asarray(levels)
    if ax is None:
        fig=plt.figure()
        ax=fig.add_subplot(111)
    ax.set_xlim(-180.0, 180.0)
    ax.set_ylim(-180.0, 180.0)
    ax.set_xticks(np.linspace(-180.0, 180.0, 11))
    ax.set_yticks(np.linspace(-180.0, 180.0, 11))
    ax.set_xlabel(r"$\phi$")
    ax.set_ylabel(r"$\psi$")
    cs=ax.contour(X, Y, Z, V, norm=norm)
    plt.clabel(cs, inline=1, fmt=fmt)
    plt.grid()
Exemple #5
0
def plot(variables,prev_vars,pltenv):

    cont_int = 10
    cont_smooth = 0.5
    thin = 10
    lvl = 2
    time = 0

    x = pltenv['x']
    y = pltenv['y']
    m = pltenv['map']


    bbox = dict(boxstyle="square",ec='None',fc=(1,1,1,0.75))

  
    T= variables['T_PL'][time][lvl]
    temp = T - 273.15 # convert to Celsius 
    levels = np.arange(-100,150,5)
    levels2 = np.arange(-50,50,1)

    P = m.contour(x,y,temp,levels=levels,colors='k')
    plt.clabel(P,inline=1,fontsize=10,fmt='%1.0f',inline_spacing=1)

    P = m.contour(x,y,temp,levels=[0],colors='r')
    plt.clabel(P,inline=1,fontsize=10,fmt='%1.0f',inline_spacing=1)


    m.contourf(x,y,temp, levels=levels2, extend='both')
def plot_curves(curve1, curve2, size_x, picture_name):
    """ function eats .dat files """
    size_y=size_x
    shape = [int(size_x),int(size_y)]
    data_1 = np.loadtxt(curve1)
    x_1 = data_1[:,0].reshape(shape,order='C')
    y_1 = data_1[:,1].reshape(shape,order='C')
    f_1 = data_1[:,2].reshape(shape,order='C')
    # plt.plot(x_end,rho_end, label='curve 1')
    a = plt.contour(x_1, y_1, f_1,30, label='curve 1')
    print np.max(f_1)
    data_2 = np.loadtxt(curve2)
    x_2 = data_2[:,0].reshape(shape,order='C')
    y_2 = data_2[:,1].reshape(shape,order='C')
    rho_2 = data_2[:,2].reshape(shape,order='C')
    b = plt.contourf(x_2,y_2,rho_2,30, label='curve 2')
    # b = plt.contour(xcoords, ycoords, step)
    print np.max(rho_2)
    plt.clabel(a, inline=1, fontsize=10)
    plt.clabel(b, inline=1, fontsize=10)
    plt.legend()
    
    cbar = plt.colorbar(b)
    # ymax = max(np.max(rho_end1),np.max(rho_end))
    # ymin = min(np.min(rho_end),np.min(rho_end1))

    # xmax = max(np.max(x_end1),np.max(x_end))
    # xmin = min(np.min(x_end),np.min(x_end1))
    
    #print xmax, xmin, ymax, ymin
    #plt.axis([0,1/6.,0,1])

    plt.axes().set_aspect('equal')
    plt.savefig(str(picture_name)+'.png', dpi=300) 
Exemple #7
0
def Pcolor(xs, ys, zs, pcolor=True, contour=False, **options):
    """Makes a pseudocolor plot.
    
    xs:
    ys:
    zs:
    pcolor: boolean, whether to make a pseudocolor plot
    contour: boolean, whether to make a contour plot
    options: keyword args passed to pyplot.pcolor and/or pyplot.contour
    """
    Underride(options, linewidth=3, cmap=matplotlib.cm.Blues)

    X, Y = np.meshgrid(xs, ys)
    Z = zs

    x_formatter = matplotlib.ticker.ScalarFormatter(useOffset=False)
    axes = pyplot.gca()
    axes.xaxis.set_major_formatter(x_formatter)

    if pcolor:
        pyplot.pcolormesh(X, Y, Z, **options)

    if contour:
        cs = pyplot.contour(X, Y, Z, **options)
        pyplot.clabel(cs, inline=1, fontsize=10)
Exemple #8
0
def MonotoneRegion():
    matplotlib.rcParams['xtick.direction'] = 'out'
    matplotlib.rcParams['ytick.direction'] = 'out'

    delta = 0.025
    w2 = np.arange(-5.0, 5.0, delta)
    a = np.arange(0.0, 5.0, delta)
    W2, A = np.meshgrid(w2, a)
    LAM_cc = -1. + 5.*(A**2.) - np.sqrt(1. + A**4. + 2.*(A**2.)*(-1. + 8.*(W2**2.)))  # They're actually the same boundary!!!!
    # solve for when square root above is less than b^2 and you get same as below, LAM_eg
    LAM_eg = -1. + 3.*(A**2.) - 2.*(W2**2.)
    # You can force all the contours to be the same color.
    plt.figure()
    CS = plt.contour(W2, A, LAM_cc, 10,
                     colors='k',  # negative contours will be dashed by default
                     )
    plt.clabel(CS, fontsize=9, inline=1)
    plt.title('Monotone Region: Crossing the Curl')
    plt.savefig('monregion_cc.png')
    plt.close()

    plt.figure()
    CS = plt.contour(W2, A, LAM_eg, 10,
                     colors='k',  # negative contours will be dashed by default
                     )
    plt.clabel(CS, fontsize=9, inline=1)
    plt.title('Monotone Region: Extragradient')
    plt.savefig('monregion_eg.png')
    plt.close()
def plot_fgmax_grid():

    fg = fgmax_tools.FGmaxGrid()
    fg.read_input_data('fgmax_grid1.txt')
    fg.read_output()

    #clines_zeta = [0.01] + list(numpy.linspace(0.05,0.3,6)) + [0.5,1.0,10.0]
    clines_zeta = [0.001] + list(numpy.linspace(0.05,0.25,10))
    colors = geoplot.discrete_cmap_1(clines_zeta)
    plt.figure(1)
    plt.clf()
    zeta = numpy.where(fg.B>0, fg.h, fg.h+fg.B)   # surface elevation in ocean
    plt.contourf(fg.X,fg.Y,zeta,clines_zeta,colors=colors)
    plt.colorbar()
    plt.contour(fg.X,fg.Y,fg.B,[0.],colors='k')  # coastline

    # plot arrival time contours and label:
    arrival_t = fg.arrival_time/3600.  # arrival time in hours
    #clines_t = numpy.linspace(0,8,17)  # hours
    clines_t = numpy.linspace(0,2,5)  # hours
    #clines_t_label = clines_t[::2]  # which ones to label 
    clines_t_label = clines_t[::1]  # which ones to label 
    clines_t_colors = ([.5,.5,.5],)
    con_t = plt.contour(fg.X,fg.Y,arrival_t, clines_t,colors=clines_t_colors) 
    plt.clabel(con_t, clines_t_label)

    # fix axes:
    plt.ticklabel_format(format='plain',useOffset=False)
    plt.xticks(rotation=20)
    plt.gca().set_aspect(1./numpy.cos(fg.Y.mean()*numpy.pi/180.))
    plt.title("Maximum amplitude / arrival times (hrs)")
Exemple #10
0
def PlotContour(data_list, ax, args):
  """ Plot two dimensional density contour.

  Args:
    data_list: a list of Data objects
    ax: a matplotlib axis object
    args: an argparse arguments object
  """
  if len(data_list) > 1:
    raise BadInput('You cannot create a contour plot with more '
                   'than one input file')
  data = data_list[0]
  x = data.x
  y = data.y
  H, xedges, yedges = numpy.histogram2d(
    x, y, range=[[min(x), max(x)], [min(y), max(y)]],
    bins=(args.contour_bin, args.contour_bin))
  extent = [yedges[0], yedges[-1], xedges[0], xedges[-1]]
  c_max = max(map(max, H))
  c_min = min(map(min, H))
  nc_levels = args.contour_num_levels
  if args.contour_logspace:
    c_levels = numpy.logspace(c_min, c_max, nc_levels)
  else:
    c_levels = numpy.linspace(c_min, c_max, nc_levels)
  im = plt.imshow(H, interpolation='bilinear', origin='lower',
                  cmap=matplotlib.cm.binary, extent=extent)
  c_set = plt.contour(H, extent=extent, origin='lower',
                      levels=c_levels, colors=ColorPicker(0, args))
  plt.clabel(c_set, colors='red', inline=True, fmt='%1.0i',
             rightside_up=True)
def drawContour(img):
    contour_image = plt.contour(img, 5)

    plt.clabel(contour_image, inline=1, fontsize=10)
    plt.show()
    
    return contour_image
Exemple #12
0
def kden_plot(X,Y, im, support, pvals=(.1,.333,.5,.666,.9),
              contours=True, imshow=True, cbar=False, psupport=True,oned=True,
              fignum=None,cfontsize=10):
    if fignum is None:
        fignum=plt.gcf().number
        plt.clf()
    
    dx=np.abs(X[0,0]-X[1,0])
    dy=np.abs(Y[0,0]-Y[0,1])
    dxdy=dx*dy
    if contours:
        
        levelsdict={x:'{:3.0f}%'.format(p*100)
                    for x,p in find_prob_contours(im,dxdy,pvals=pvals)}
        cplt=plt.contour(X,Y,im,colors='k', levels=levelsdict.keys())
        plt.clabel(cplt, inline=1, fontsize=10, use_clabeltext=True,
                   fmt=levelsdict)
    if imshow:
        plt.imshow(np.rot90(im),aspect='auto',
                   extent=[X.min(), X.max(), Y.min(), Y.max()],
                   cmap=plt.cm.gist_earth_r)
    if cbar:
        plt.colorbar()

    if psupport:
        plt.plot(support[0],support[1],'r,')

    if oned:
        plt.figure(fignum+1)
        plt.plot(X[:,0],((im*dy).sum(1)))
    def test(self):
        xlim=[-2.0,2.0]
        ylim=[-2.0,2.0]
        
        resol = 0.025
        sample_x = np.arange(-2.0,2.0,resol)
        sample_y = np.arange(-2.0,2.0,resol)
        sample_X, sample_Y = np.meshgrid(sample_x, sample_y)
        sample_XX = np.hstack([sample_X.reshape(sample_X.size,1),sample_Y.reshape(sample_Y.size,1)])

        sample_Z1 = np.exp(self.gmm_0.score(sample_XX))
        sample_Z2 = np.exp(self.gmm_1.score(sample_XX))

        plt.figure()
        ax1 = plt.subplot(121, aspect='equal')    
        CS = plt.contour(sample_X, sample_Y, sample_Z1.reshape(sample_X.shape))
        plt.clabel(CS, inline=1, fontsize=10)

        ax2 = plt.subplot(122, aspect='equal')    
        CS = plt.contour(sample_X, sample_Y, sample_Z2.reshape(sample_X.shape))
        plt.clabel(CS, inline=1, fontsize=10)

        ax1.set_xlim(xlim)
        ax1.set_ylim(ylim)

        ax2.set_xlim(xlim)
        ax2.set_ylim(ylim)

        plt.show()

        #print gmm_1.get_params(deep=True)
        print self.gmm_0.weights_
        print self.gmm_0.means_
        print self.gmm_0.covars_
Exemple #14
0
   def publish(self):
      alldata = []
      
      for i,val in enumerate(self.status['runs']):
         print val
         alldata.append(post_bout.read(path=val))
     
      alldata = np.array(alldata)
      print "alldata.shape: ", alldata.shape
      print  alldata[0]['Ni']['ave']['amp'].shape
      data = alldata[0]['Ni']['ave']['amp'] #Nt long array
      pp = PdfPages('output.pdf')
      plt.figure()
      cs = plt.plot(data)
      plt.title('amplitude ')
      plt.savefig(pp, format='pdf')

      gamma = alldata[2]['Ni']['modes'][0]['gamma'] #single value
      phase = alldata[2]['Ni']['modes'][0]['phase'] #Nt x Nx array 

      plt.figure()
      cs = plt.contour(phase)
      plt.clabel(cs, inline=1, fontsize=10)
      plt.title('phase')
      plt.savefig(pp, format='pdf')

      plt.close() 
      pp.close()
   
      explain = alldata[0]['meta']
      print explain
      
      allpickle = open('allpickled.pkl','wb')
      pickle.dump(alldata,allpickle)
      allpickle.close()
Exemple #15
0
def animation_plot(i, pressure, wind, direction, step=24):
    """
    Function to update the animation frame.

    """
    # Clear figure to refresh colorbar
    plt.gcf().clf()

    ax = plt.axes(projection=ccrs.Mercator())
    ax.set_extent([-10.5, 3.8, 48.3, 60.5], crs=ccrs.Geodetic())

    contour_wind = iplt.contourf(wind[i][::10, ::10], cmap='YlGnBu',
                                 levels=range(0, 31, 5))
    contour_press = iplt.contour(pressure[i][::10, ::10], colors='white',
                                 linewidth=1.25, levels=range(938, 1064, 4))
    plt.clabel(contour_press, inline=1, fontsize=14, fmt='%i', colors='white')
    quiver_plot(wind[i], direction[i], step)
    plt.gca().coastlines(resolution='50m')

    time_points = pressure[i].coord('time').points
    time = str(pressure[i].coord('time').units.num2date(time_points)[0])
    plt.gca().set_title(time)

    colorbar = plt.colorbar(contour_wind)
    colorbar.ax.set_ylabel('Wind speed ({})'.format(str(wind[i].units)))
def add_sub_plot(sub_num):

	plt.subplot(1,1,1)
	
	rbf = scipy.interpolate.Rbf(x, y, z, function='linear')
	zi = rbf(xi, yi)

	#io parameter interpolation
	rbf2 = scipy.interpolate.Rbf(xio, yio, zio, function='linear')
	zion = rbf2(xion, yion)

	#our contours. Teal for .2 dex and black for 1 dex
	contour = plt.contour(xi,yi,zi, levels, colors='r', linestyles = 'dashed')
	contour2 = plt.contour(xi,yi,zi, levels2, colors='k', linewidths=1.5)
	contour3 = plt.contour(xion,yion, zion, levelsio, colors='c', linewidths = 3) 

	plt.clabel(contour2, inline=1, fontsize=10, fmt='%1.1f')
	plt.clabel(contour3, inline=1, fontsize=10, fmt='%1.1f')

	#print the max values right on the plots
	#plt.scatter(max_values[0,2], max_values[0,3], c ='k',marker = '*', s = 1000)
	#plt.annotate(max_values[0,0], xy= (max_values[0,2], max_values[0,3]), xytext = (5, -30), textcoords = 'offset points', ha = 'left', va = 'bottom', fontsize=15)
	#axis limits
	yt_min = 8
	yt_max = 17
	xt_min = 0
	xt_max = 6
	plt.ylim(yt_min,yt_max)
	plt.xlim(xt_min,xt_max) 
	plt.yticks(arange(yt_min,yt_max+1,1),fontsize=16)
	plt.xticks(arange(xt_min,xt_max+1,1), fontsize = 16)
	plt.ylabel('Log ($ \phi  _{\mathrm{H}}  $)', fontsize=18)
	plt.xlabel('Log($n _{\mathrm{H}}  $)', fontsize=18)
Exemple #17
0
def __make_result_sps(session):
    sdf_extension = session['SPS']
    # if isinstance(sdf_extension, SDFExtension) == False:
    #    return sdf_extension
    scales = sdf_extension.actual_scales
    zs = sdf_extension.result_datasets
    x, y = numpy.meshgrid(scales[1].data, scales[0].data)
    response_string = ''
    for zds in zs:
        if zds.name != 'summary.batteryPower' and zds.name != 'summarySystemSPS.mechanicalPower':
            continue
        print zds.data
        z = numpy.fabs(zds.data)
        fig = plt.contourf(x, y, z, 10, alpha=.75, cmap=cm.coolwarm)
        C = plt.contour(x, y, z, 10, colors='black', linewidth=.5)
        plt.clabel(C, inline=1, fontsize=10)
        # TODO: Unit hackcode
        plt.xlabel(scales[1].name + ' (' + str(scales[1].unit) + ')')
        plt.ylabel(scales[0].name + ' (' + str(scales[0].unit) + ')')
        plt.title(zds.name)
        plt.colorbar(fig, shrink=0.5, aspect=5)
        plt.savefig('temp.svg')

        with open('temp.svg', 'rb') as f:
            data = f.read().encode('base64')
        os.remove('temp.svg')
        response_string += '<img src="data:image/svg+xml;base64,{0}"><br/>'.format(data)
        plt.close('all')
    return response_string
Exemple #18
0
    def visCostFun(self,thetaHis):
       fig = plt.figure()
       ax = fig.gca(projection='3d')

       theta0Rg=np.arange(-10, 10, 0.1)
       theta1Rg=np.arange(-1.,4., 0.01)
       valJ=np.zeros((len(theta0Rg),len(theta1Rg)))
       theta0Grid, theta1Grid=np.meshgrid(theta0Rg,theta1Rg)
       theta=np.zeros(2)
       for i in range(len(theta0Rg)):
           for j in range(len(theta1Rg)):
               theta[0]=theta0Rg[i]
               theta[1]=theta1Rg[j]
               valJ[i,j]=1./(2.*self.m)*np.sum(((theta.dot(self.newX.T))-self.y)**2) 
       i,j = np.unravel_index(valJ.argmin(), valJ.shape)
#       surf = ax.plot_surface(theta0Grid, theta1Grid, valJ.T, rstride=1, cstride=1, cmap=cm.coolwarm,
#                       linewidth=0, antialiased=False)
       surf = ax.plot_surface(theta0Grid, theta1Grid, valJ.T)
       plt.xlabel("theta0")
       plt.ylabel("theta1")
       plt.show()

       levels = np.arange(-30.,30.,5)
       CS=plt.contour(theta0Grid, theta1Grid, valJ.T, levels)
       plt.clabel(CS, inline=1, fontsize=10)
       plt.plot([theta0Rg[i]],[theta1Rg[j]],'-ro')
       for ele in thetaHis:
          plt.plot([ele[0]],[ele[1]],'b*')
       plt.xlabel("theta0")
       plt.ylabel("theta1")
       plt.show()
    def plot_contour(self):
        if self.fdim == 2:

            p = [self.x_range.min(), self.x_range.max(),
                               self.y_range.max(), self.y_range.min()]
            p2 = [self.x_range.min(), self.x_range.max(),
                               self.y_range.min(), self.y_range.max()]
            plt.imshow(self.z_val, vmin=self.z_val.min(), vmax=self.z_val.max(),
                       extent=p)

            CS = plt.contour(self.x_range, self.y_range, self.z_val, 15,  colors='k')
            plt.clabel(CS, inline=1, fontsize=10)
            x_ = []
            y_ = []
            for i in self.vec:
                x_.append(i[0])
                y_.append(i[1])

            plt.plot(x_, y_, color='k')
            plt.ylabel("x2")
            plt.xlabel("x1")

            if self.y_range.max() > 0:
                plt.ylim(self.y_range.min(), self.y_range.max())
            else:
                plt.ylim(self.y_range.max(), self.y_range.min())

            if self.x_range.max() > 0:
                plt.xlim(self.x_range.min(), self.x_range.max())
            else:
                plt.xlim(self.x_range.max(), self.x_range.min())

            plt.show()
        else:
            print('Dimension not equal 2')
Exemple #20
0
def plot_image(file_in, num=0, xlab='', ylab='', map_range=[0, 0, 0, 0],
               color_loc=False, cm='', fig_title='', cont=''):
    """
    plot a given 2d image
    """
    from matplotlib.pyplot import imshow, colorbar, figure
    from matplotlib.pyplot import xlabel, ylabel
    from matplotlib.pyplot import title, contour, clabel
    figure(num)

    if fig_title != '':
        title(fig_title)

    if xlab != '':
        xlabel(xlab)

    if ylab != '':
        ylabel(ylab)

    if all([v == 0 for v in map_range]):
        map_range = [0, len(file_in), 0, len(file_in)]

    if cm == '':
        imshow(file_in, extent=map_range, origin='lower', interpolation='None')
    else:
        imshow(file_in, extent=map_range, origin='lower',
               interpolation='None', cmap=cm)
    if color_loc:
        colorbar()
    if cont != '':
        CS = contour(file_in, cont, extent=map_range, origin='lower',
                     hold='on', colors=('k', ))
        clabel(CS, inline=1, fmt='%2.1f', fontsize=10)
Exemple #21
0
def epsPlot(subplot, filename, text):
    scale,S,count, members = pickle.load(open(filename,'rb'))
    #plt.subplot(2,3,i,adjustable='box', aspect=5)
    ax = plt.subplot(2,3,subplot)
    
    levels = []
    if subplot <=3:
        levels = np.linspace(0, 3, 13)
    else:
        levels = np.linspace(0, 8, 33)
    print levels
    
    CS = plt.contourf(S,levels = levels,extent = (EPSRANGE[0],EPSRANGE[-1],NMINRANGE[0], NMINRANGE[-1]),aspect='auto')
    plt.text(.08,3.5 ,text)
    
    plt.setp(ax.get_xticklabels(), rotation='vertical', fontsize=12)
    CS2 = plt.contour(count,[1,2,3,4,5,6],extent = (EPSRANGE[0],EPSRANGE[-1],NMINRANGE[0], NMINRANGE[-1]),colors = 'k')
    plt.clabel(CS2, inline=1, fontsize=12, colors = 'k')
    
    
    plt.ylabel(r'$N_{min}$')
    plt.xlabel(r'$\epsilon$')
    #if (subplot == 3 or subplot == 6):
    if ( subplot == 6):
        cax = fig2.add_axes([0.91, 0.1, 0.03, 0.365])
        cbar = plt.colorbar(CS , cax=cax)
        cbar.ax.set_ylabel('S')
    if ( subplot == 3):
        cax = fig2.add_axes([0.91, 0.535, 0.03, 0.365])
        cbar = plt.colorbar(CS , cax=cax)
        cbar.ax.set_ylabel('S')
    
    return
def plot_TS(temp, psal, depth, lon, lat, svec, tvec, density, title, m, figname):
    '''
    Create the T-S diagram
    '''
    logger = logging.getLogger(__name__)
    fig = plt.figure(figsize=(15, 15))
    rcParams.update({'font.size': 18})
    plt.scatter(psal, temp, s=5, c=depth, vmin=10., vmax=1000.,
               edgecolor='None', cmap=plt.cm.plasma)
    cbar = plt.colorbar(extend='max')
    plt.xlabel('Salinity', fontsize=18)
    plt.ylabel('Temperature\n($^{\circ}$C)', rotation=0, ha='right', fontsize=18)
    cont = plt.contour(svec, tvec, density, levels=np.arange(22., 32., 1.), 
                       colors='.65', linestyles='dashed', lineswidth=0.5)
    plt.clabel(cont,inline=True, fmt='%1.1f')
    plt.xlim(smin, smax)
    plt.ylim(tmin, tmax)
    cbar.set_label('Depth\n(m)', rotation=0, ha='left')
    plt.grid(color="0.6")

    # Add an inset showing the positions of the platform
    inset=plt.axes([0.135, 0.625, 0.3, 0.35])
    lon2plot, lat2plot = m(lon, lat)
    m.drawmapboundary(color='w')
    m.plot(lon2plot, lat2plot, 'ro', ms=2, markeredgecolor='r')
    #m.drawcoastlines(linewidth=0.25)
    m.drawlsmask(land_color='0.4', ocean_color='0.9', lakes=False)
    plt.title(title, fontsize=20)
    plt.savefig(figname, dpi=150)
    # plt.show()
    plt.close()
def contour(x,y,z, linewidth = 2, labels = None):
    """
    Plots contours for non-evenly spaced data.
    x,y,z must be 1d arrays.
    lines = # of contour lines (default 18 )
    linewidth = line width of lines (default 2 )
    """
    
    assert x.shape[0] == y.shape[0] == z.shape[0], "arrays x,y,z must be the same size"
    
    #make a grid that surrounds x,y support
    xi = np.linspace(x.min(),x.max(),100)
    yi = np.linspace(y.min(),y.max(),100)
    # grid the data.
    zi = griddata((x, y), z, (xi[None,:], yi[:,None]), method='cubic')
    # contour the gridded data, plotting dots at the randomly spaced data points.
    plt.figure()
    CS = plt.contour(xi,yi,zi,linewidth=2)
    plt.clabel(CS, inline=1, fontsize=10)
    
    if labels:
        plt.xlabel(labels[0])
        plt.ylabel(labels[1])
    # plot data points.
    plt.scatter(x,y,c=z,s=60, alpha = 0.7, edgecolors = "none")
    plt.xlim(x.min(),x.max())
    plt.ylim(y.min(),y.max())
    plt.show()
Exemple #24
0
def main():
    # Lets relax a 1D array of values. 
    N = 20
    a = 0.0
    b = 1.0
    u = np.zeros(20)
    u[0] = a
    u[-1] = b
    x = np.arange(0.0, float(len(u)), 1.0) / float(len(u) - 1)
    u = relax1D(u)
    print "It took %d iterations to reach the desired tolerance." % (len(u) - 1)
    animate1Dframes(x, u)
    plt.plot(x, u[-1], "-sk")
    plt.savefig("Relaxed1D.png")
    plt.close()

    # Now lets relax a 2D array of values. Such that the top and bottom edges are set to zero
    # and the left and right edges are set to one. 
    u2D = np.zeros((N, N))
    u2D[0,:]  = a
    u2D[-1,:] = a
    u2D[:,0]  = b
    u2D[:,-1] = b
    u2D = relax2D(u2D)
    print "It took %d iterations to reach the desired tolerance." % (len(u2D) - 1)
    animate2Dframes(u2D)
    u2D_cf = plt.contour(u2D[-1], levels=np.arange(0, 1, 0.1))
    plt.clabel(u2D_cf, colors='k')
    plt.savefig("Relaxed2D.png")
    plt.close()
def plot_pressuremap(data, 
                    title='pressure pattern', 
                    sub_title='ploted in birdhouse'):
  """
  plots pressure data
  :param data: 2D or 3D array of pressure data. if data == 3D a mean will be calculated
  :param title: string for title
  :param sub_title: string for sub_title
  """
  from numpy import squeeze, mean
  
  d = squeeze(data)

  if len(d.shape)==3:
    d = mean(d, axis=0)
  if len(d.shape)!=2:
    logger.error('data are not in shape for map display')

  co = plt.contour(d, lw=2, c='black')
  cf = plt.contourf(d)

  plt.colorbar(cf)
  plt.clabel(co, inline=1) # fontsize=10
  
  plt.title(title)
  plt.annotate(sub_title, (0,0), (0, -30), xycoords='axes fraction',
               textcoords='offset points', va='top')

  ip, image = mkstemp(dir='.',suffix='.png')
  plt.savefig(image)
  plt.close()

  return image
def main():
    dir='/Users/ph290/Public/mo_data/ostia/' # on ELD140
    filename = dir + '*.nc'

    cube = iris.load_cube(filename,'sea_surface_temperature',callback=my_callback)
    #reads in data using a special callback, because it is a nasty netcdf file
    cube.data=cube.data-273.15


    sst_mean = cube.collapsed('time', iris.analysis.MEAN)
    #average all 12 months together
    sst_stdev=cube.collapsed('time', iris.analysis.STD_DEV)

    caribbean = iris.Constraint(
                                    longitude=lambda v: 260 <= v <= 320,
                                    latitude=lambda v: 0 <= v <= 40,
                                    name='sea_surface_temperature'
                                    )

    caribbean_sst_mean = sst_mean.extract(caribbean)
    caribbean_sst_stdev = sst_stdev.extract(caribbean)
    #extract the Caribbean region

    fig = plt.figure()
    ax = plt.axes(projection=ccrs.PlateCarree())
    data=caribbean_sst_mean.data
    data2=caribbean_sst_stdev.data
    lons = caribbean_sst_mean.coord('longitude').points
    lats = caribbean_sst_mean.coord('latitude').points
    lo = np.floor(data.min())
    hi = np.ceil(data.max())
    levels = np.linspace(lo,hi,100)
    lo2 = np.floor(data2.min())
    hi2 = np.ceil(data2.max())
    levels2 = np.linspace(lo2,5,10)
    cube_label = 'latitude: %s' % caribbean_sst_mean.coord('latitude').points
    contour=plt.contourf(lons, lats, data,transform=ccrs.PlateCarree(),levels=levels,xlabel=cube_label)
    #filled contour the annually averaged temperature
    contour2=plt.contour(lons, lats, data2,transform=ccrs.PlateCarree(),levels=levels2,colors='k')
    #contour the standard deviations
    plt.clabel(contour2, inline=0.5, fontsize=12,fmt='%1.1f' )
    ax.add_feature(cartopy.feature.LAND)
    ax.coastlines()
    ax.add_feature(cartopy.feature.RIVERS)
    ax.add_feature(cartopy.feature.BORDERS, linestyle=':')
    #ax.add_feature(cartopy.feature.LAKES, alpha=0.5)
    cbar = plt.colorbar(contour, ticks=np.linspace(lo,hi,7), orientation='horizontal')
    cbar.set_label('Sea Surface Temperature ($^\circ$C)')
    # enable axis ticks
    ax.xaxis.set_visible(True)
    ax.yaxis.set_visible(True)
    # fix 10-degree increments and don't clip range
    plt.locator_params(steps=(1,10), tight=False)
    # add gridlines
    plt.grid(True)
    # add axis labels
    plt.xlabel('longitude')
    plt.ylabel('latitude')
    #plt.show()
    plt.savefig('/home/h04/hador/public_html/twiki_figures/carib_sst_and_stdev.png')
Exemple #27
0
def plot_area(dataset, request, area_prediction):
    bot_lat, top_lat, left_lon, right_lon = request['predict_area']

    plt.figure(figsize=(20, 15))

    # Plot stations
    sp = plt.scatter(
        dataset.longitude, dataset.latitude,
        s=10, c=dataset['TT2m_error'],
        edgecolor='face',
        vmin=-5, vmax=5,
    )

    # Contours
    contour_handle = plt.contour(
        area_prediction,
        np.arange(-5, 5, 1),
        antialiased=True,
        extent=(left_lon, right_lon, top_lat, bot_lat),
        zorder=999,
        alpha=0.5
    )
    plt.clabel(contour_handle, fontsize=11)

    # Color bar
    cb = plt.colorbar(sp)
    cb.set_label('Temperature error')
    plt.show()
    def draw(self):

        filename = self.filename
        file = open(os.getcwd() + "\\" + filename, 'r')
        lines = csv.reader(file)
        #
        data = []
        x = []
        y = []
        z = []
        for line in lines:
            try:
                data.append(line)
            except Exception as e:
                print e
                pass
        # print data
        for i in range(1, len(data)):
            try:
                x.append(float(data[i][0]))
                y.append(float(data[i][1]))
                z.append(float(data[i][3]))
            finally:
                pass

        xx = np.array(x)
        yy = np.array(y)
        zz = np.array(z)
        # print np.min(xx)

        tx = np.linspace(np.min(xx), np.max(xx), 100)
        ty = np.linspace(np.min(yy), np.max(yy), 100)

        XI, YI = np.meshgrid(tx, ty)

        rbf = interpolate.Rbf(xx, yy, zz, epsilon=2)
        ZI = rbf(XI, YI)

        #

        plt.gca().set_aspect(1.0)

        font = font_manager.FontProperties(family='times new roman', style='italic', size=16)

        cs = plt.contour(XI, YI, ZI, colors="black")
        plt.clabel(cs, cs.levels, inline=True, fontsize=10, prop=font)

        plt.subplot(1, 1, 1)
        plt.pcolor(XI, YI, ZI, cmap=cm.jet)
        plt.scatter(xx, yy, 100, zz, cmap=cm.jet)


        plt.title('interpolation example')
        plt.xlim(int(xx.min()), int(xx.max()))
        plt.ylim(int(yy.min()), int(yy.max()))
        plt.colorbar()
        plt.savefig("interpolation.jpg")
        #plt.show()

        return ZI, XI, YI
Exemple #29
0
def eigenvector(centers, ev, levels=None, norm=None,\
                    fmt='%.e', method='linear', fill_value=np.nan):
    r"""Make contourplot of alanine-dipeptide stationary distribution

    The scattered data is interpolated onto a regular grid before
    plotting.

    Parameters
    ----------
    centers : (N, 2) ndarray 
        (phi, psi) coordinates of MSM discretization.
    ev : (N, ) ndarray,
        Right eigenvector
    
    """  
    X, Y=np.meshgrid(xcenters, ycenters)
    Z=griddata(centers, ev, (X, Y), method=method, fill_value=fill_value)
    if levels is None:
        levels=np.linspace(-0.1, 0.1, 21)
    V=np.asarray(levels)    
    fig=plt.figure()
    ax=fig.add_subplot(111)
    ax.set_xlim(-180.0, 180.0)
    ax.set_ylim(-180.0, 180.0)
    ax.set_xticks(np.linspace(-180.0, 180.0, 11))
    ax.set_yticks(np.linspace(-180.0, 180.0, 11))
    ax.set_xlabel(r"$\phi$")
    ax.set_ylabel(r"$\psi$")
    cs=ax.contour(X, Y, Z, V, norm=norm)
    plt.clabel(cs, inline=1, fmt=fmt)
    plt.grid()
Exemple #30
0
def plotSNR(R, snr, T0, fname = '/Users/jmrv/Desktop/snr.pdf'):
	pp = PP(fname)
	plt.clf()

	T = T0*10**(np.arange(-2, 1.5, 0.1))
	scale = np.sqrt(T/T0)

	snrGrid = np.zeros((len(R), len(T)))
	for i in range(len(snr)):
		snrGrid[i,:] = scale*snr[i]

	levels = np.array([0.5, 1, 2, 3, 5, 10, 15, 20])/10
	c = plt.contour(T/1e3, R*1000, snrGrid, levels, colors='k')
	plt.clabel(c, fontsize=9, inline=1)
	plt.xscale('log')
	plt.yscale('log')
	plt.title('Signal-to-noise of Sc signal in the X-ray band')
	plt.ylabel('Instrument resolution (eV, FWHM)')
	plt.xlabel('Exposure (ks)')
	#plt.ticklabel_format(style='plain', axis='both')
	
	pp.savefig()
	pp.close()

	print '\nplotted '+fname
               f(points[i][0], points[i][1]),
               marker='o',
               color="red")  # Plot the point
    ax.set_xlabel('x')
    ax.set_ylabel('y')
    ax.set_zlabel('z')

    ax2 = fig.add_subplot(2, 2, 2)
    ax2.set_title('Contour Map')
    cp = plt.contour(X,
                     Y,
                     f(X, Y),
                     colors='black',
                     linestyles='dashed',
                     linewidths=1)  # Plot the line map
    plt.clabel(cp, inline=1, fontsize=10)
    cp = plt.contourf(X, Y, f(X, Y), 50,
                      cmap='viridis')  # Plot the contour map
    ax2.plot(points[i][0], points[i][1], marker='o',
             color="red")  # Plot the point
    ax2.set_xlabel('x')
    ax2.set_ylabel('y')

    ax3 = fig.add_subplot(2, 2, 3)
    ax3.set_title('Convergence')
    ax3.grid()
    ax3.plot(list(range(0, i + 1)), convergence)

    ax4 = fig.add_subplot(2, 2, 4, frameon=False)
    ax4.table(colLabels=['Iteration', 'Current Min', 'Convergence'],
              cellText=[[
Exemple #32
0
#Z2 = np.array([[p2n(p, q) for p in pp] for q in qq])
#Z4 = np.array([[p4n(p, q) for p in pp] for q in qq])
Z6 = np.array([[p6n2(p, q) for p in pp] for q in qq])

save_memoized(p6n2, 'fp6n2')

#Z8 = np.array([[p8(p, q) for p in pp] for q in qq])




bare_qubit = PP

#from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111)

fontsize=16

Z = Z6 - (1 - PP)**2
cont =  ax.contour(QQ, PP, Z, [0.06, 0.05, 0.04, 0.03, 0.02, 0.01], colors = ('black'))
plt.clabel(cont, inline=1, fontsize=fontsize)
cont2 = ax.contour(QQ, PP, Z, [0], colors = ('black'), linewidths=(3))
plt.clabel(cont2, inline=1, fontsize=fontsize)
plt.xlabel('$q$', fontsize=fontsize)
plt.ylabel('$p$', fontsize=fontsize)
plt.show()
plt.savefig('full_lying.pdf', format='pdf')
plt.savefig('../writeup/assets/full_lying.pdf', format='pdf')
Exemple #33
0
def f(x, y):
    return (1 - x / 2 + x**5 + y**3) * np.exp(-x**2 - y**2)


n = 256
x = np.linspace(-3, 3, n)
y = np.linspace(-3, 3, n)
# 将线和值进行绑定
X, Y = np.meshgrid(x, y)
# cmap是color map可以根据值在颜色图中找到对应的颜色
# 使用plt.contourf去填充contour(轮廓)
plt.contourf(X, Y, f(X, Y), 8, alpha=0.75, cmap=plt.cm.hot)
# 添加的是轮廓线
C = plt.contour(X, Y, f(X, Y), 8, colors='black')
# 在线上添加数字
plt.clabel(C, inline=True, fontsize=10.5)
plt.xticks(())
plt.yticks(())

# 传入图片
plt.figure(num=7)
# 用像素点模拟图片
a = np.array([
    0.31513153135, 0.1564651254, 0.51678534535, 0.15646765444, 0.1646524525,
    0.45534545345, 0.48641513213, 0.15646557613, 0.6649879843
]).reshape(3, 3)
# interpolation的参考地址是http://matplotlib.org/examples/images_contours_and_fields/interpolation_methods.html
plt.imshow(a, interpolation='nearest', cmap='bone', origin='lower')
plt.xticks([])
plt.yticks([])
Exemple #34
0
x_new.sort()
y_new.sort()
Prob = np.zeros([len(x_new), len(y_new)])

for i in xrange(len(x_new)):
    for j in xrange(len(y_new)):

        if (x_new[i], y_new[j]) in f:
            Prob[i, j] = f[(x_new[i], y_new[j])]

level = np.arange(0.00, 0.9, 0.05)

plt.figure(1)
G1 = plt.contour(x_new, y_new, Prob.transpose(), levels=level)
plt.clabel(G1, inline=1, fontsize=10)
plt.xlabel('Gluino mass (GeV)')
plt.ylabel('Neutralino mass (GeV)')
plt.title('037 (d) GttN1')
plt.axis([750, 1800, 150, 1600])
plt.grid(True)
plt.show()

q = open('037_d.txt', 'w')
Pt = Prob.transpose()
for i in xrange(len(x_new)):
    for j in xrange(len(y_new)):
        q.write(
            str(x_new[i]) + '   ' + str(y_new[j]) + '   ' + str(Pt[i, j]) +
            ' \n')
Exemple #35
0
def main(myfiles,
         fieldname,
         fieldlevel,
         idm=None,
         jdm=None,
         clim=None,
         filetype="archive",
         window=None,
         cmap="jet",
         datetime1=None,
         datetime2=None,
         vector="",
         tokml=False,
         exptid="",
         masklim=None,
         dpi=180):

    cmap = plt.get_cmap("jet")
    LinDic = mod_hyc2plot.cmap_dict('sawtooth_fc100.txt')
    my_cmap = matplotlib.colors.LinearSegmentedColormap('my_colormap', LinDic)
    cmap = my_cmap

    if vector:
        cmap = cmocean.cm.speed

    if tokml:
        ab = abf.ABFileGrid("regional.grid", "r")
        plon = ab.read_field("plon")
        plat = ab.read_field("plat")
        ab.close()

    ab = abf.ABFileGrid("regional.grid", "r")
    plon = ab.read_field("plon")
    plat = ab.read_field("plat")
    ab.close()

    proj = ccrs.Stereographic(central_latitude=90.0, central_longitude=-40.0)
    pxy = proj.transform_points(ccrs.PlateCarree(), plon, plat)
    px = pxy[:, :, 0]
    py = pxy[:, :, 1]
    x, y = np.meshgrid(np.arange(plon.shape[1]), np.arange(plon.shape[0]))

    if vector:
        logger.info("Vector component 1:%s" % fieldname)
        logger.info("Vector component 2:%s" % vector)

    figure = plt.figure(figsize=(8, 8))
    ax = figure.add_subplot(111)
    ax.set_facecolor('xkcd:gray')
    onemm = 9.806
    counter = 0
    sum_fld = np.zeros(plon.shape)
    sumf1 = np.zeros(plon.shape)
    sumf2 = np.zeros(plon.shape)
    file_count = 0
    for myfile0 in myfiles:

        # Open files, and return some useful stuff.
        # ab2 i used in case of vector
        # rdtimes is used for plotting forcing fields
        n_intloop, ab, ab2, rdtimes = open_file(myfile0,
                                                filetype,
                                                fieldname,
                                                fieldlevel,
                                                datetime1=datetime1,
                                                datetime2=datetime2,
                                                vector=vector,
                                                idm=idm,
                                                jdm=jdm)
        # Intloop used to read more fields in one file. Only for forcing for now
        for i_intloop in range(n_intloop):

            # Read ab file of different types
            if filetype == "archive":
                fld1 = ab.read_field(fieldname, fieldlevel)
                if vector: fld2 = ab.read_field(vector, fieldlevel)
            elif filetype == "regional.depth":
                fld1 = ab.read_field(fieldname)
            elif filetype == "forcing":
                fld1 = ab.read_field(fieldname, rdtimes[i_intloop])
                if vector: fld2 = ab2.read_field(vector, rdtimes[i_intloop])
                logger.info("Processing time %.2f" % rdtimes[i_intloop])
            else:
                raise NotImplementedError("Filetype %s not implemented" %
                                          filetype)

            if not window:
                J, I = np.meshgrid(np.arange(fld1.shape[0]),
                                   np.arange(fld1.shape[1]))
            else:
                J, I = np.meshgrid(np.arange(window[1], window[3]),
                                   np.arange(window[0], window[2]))

            print('mnfld1,mxfld1=', fld1.min(), fld1.max())
            # Create scalar field for vectors
            if vector:
                fld = np.sqrt(fld1**2 + fld2**2)
                print('mnfld2,mxfld2=', fld2.min(), fld2.max())
            else:
                fld = fld1

            # Apply mask if requested
            if masklim:
                fld = np.ma.masked_where(fld <= masklim[0], fld)
                fld = np.ma.masked_where(fld >= masklim[1], fld)

            sum_fld = sum_fld + fld
            counter = counter + 1
            if vector:
                sumf1 = sumf1 + fld1
                sumf2 = sumf2 + fld2
        file_count = file_count + 1
        # End i_intloop
    print('Computing the avearge of file_counter= ', file_count, 'counter=',
          counter)
    if file_count > 0:
        fld_Avg = sum_fld / file_count
        print('mn_Avg_fld,mx_Avg_fld=', fld_Avg.min(), fld_Avg.max())
    if vector:
        f1_avg = sumf1 / file_count
        f2_avg = sumf2 / file_count
        print('mn_avg_fld1,mx_avg_fld1=', f1_avg.min(), f1_avg.max())
        print('mn_avg_fld2,mx_avg_fld2=', f2_avg.min(), f2_avg.max())

    if fieldname == 'k.e.':
        P = plt.pcolormesh(x[J, I],
                           y[J, I],
                           np.log10(fld_Avg[J, I]),
                           cmap=cmap,
                           shading='auto')
    elif fieldname == 'srfhgt':
        P = plt.pcolormesh(x[J, I],
                           y[J, I], (fld_Avg[J, I] / onemm),
                           cmap=cmap,
                           shading='auto')
    else:
        P = plt.pcolormesh(x[J, I],
                           y[J, I],
                           fld_Avg[J, I],
                           cmap=cmap,
                           shading='auto')

    if 'temp' in fieldname:
        P1=plt.contour(x[J,I],y[J,I],fld_Avg[J,I],levels=[-1.,1,4.0,8], \
                   colors=('w',),linestyles=('-',),linewidths=(1.5,))
        plt.clabel(P1, fmt='%2.1d', colors='w',
                   fontsize=10)  #contour line labels

    if vector:
        skip = 10
        logger.info("ploting quiver .......>>> %s" % vector)
        I2 = I[::skip, ::skip]
        J2 = J[::skip, ::skip]
        plt.quiver(x[J2, I2], y[J2, I2], f1_avg[J2, I2], f2_avg[J2, I2])

    ##
    # Print figure and remove wite space.
    ax.set_facecolor('xkcd:gray')
    aspect = 40
    pad_fraction = 0.25
    divider = make_axes_locatable(ax)
    width = axes_size.AxesY(ax, aspect=1. / aspect)
    pad = axes_size.Fraction(pad_fraction, width)
    cax = divider.append_axes("right", size=width, pad=pad)
    if vector:
        cb = ax.figure.colorbar(P, cax=cax, extend='max')
    else:
        cb = ax.figure.colorbar(P, cax=cax, extend='both')
    if clim is not None: P.set_clim(clim)
    ax.set_title('Avg' + "%s:%s(%d)" % (myfile0, fieldname, fieldlevel))
    # Print figure.
    fnamepng_template = exptid + "Avg_%s_%d_%03d_Avg.png"
    fnamepng = fnamepng_template % (fieldname, fieldlevel, counter)
    logger.info("output in  %s" % fnamepng)
    figure.canvas.print_figure(fnamepng, bbox_inches='tight', dpi=dpi)
    ax.clear()
    cb.remove()
Exemple #36
0
    grad[0] = 400 * y[0] * (y[0]**2 - y[1]) + 2 * (y[0] - 1)
    grad[1] = 200 * (y[1] - y[0]**2)
    return grad


##Q1
xmin, xmax, ymin, ymax = -1.5, 1.5, -0.5, 1.5
xx = np.linspace(xmin, xmax, 500)
yy = np.linspace(ymin, ymax, 500)
[X, Y] = np.meshgrid(xx, yy)
fXY = rosenbrock([X, Y])

plt.figure(1)
plt.clf()
CS = plt.contour(X, Y, fXY, np.logspace(-0.5, 3.5, 20, base=10))
plt.clabel(CS, inline=1, fontsize=10)
plt.title('Lignes de niveau de Rosenbrock')
plt.show()
##Q2
epsilon = 10**-8


def GPF(h, x0, f_grad, epsilon=10**-8, n_max=1000):
    error = 1
    increment = 0
    XX = [x0]
    while error > epsilon and increment < n_max:
        x1 = x0 - h * f_grad(x0)
        error = np.linalg.norm(x0 - x1, 2)
        x0 = x1
        increment += 1
Exemple #37
0
def plot_fisher_information_contours_2d(
    fisher_information_matrices,
    fisher_information_covariances=None,
    reference_thetas=None,
    contour_distance=1.0,
    xlabel=r"$\theta_0$",
    ylabel=r"$\theta_1$",
    xrange=(-1.0, 1.0),
    yrange=(-1.0, 1.0),
    labels=None,
    inline_labels=None,
    resolution=500,
    colors=None,
    linestyles=None,
    linewidths=1.5,
    alphas=1.0,
    alphas_uncertainties=0.25,
):
    """
    Visualizes 2x2 Fisher information matrices as contours of constant Fisher distance from a reference point `theta0`.

    The local (tangent-space) approximation is used: distances `d(theta)` are given by
    `d(theta)^2 = (theta - theta0)_i I_ij (theta - theta0)_j`, summing over `i` and `j`.

    Parameters
    ----------
    fisher_information_matrices : list of ndarray
        Fisher information matrices, each with shape (2,2).

    fisher_information_covariances : None or list of (ndarray or None), optional
        Covariance matrices for the Fisher information matrices. Has to have the same length as
        fisher_information_matrices, and each entry has to be None (no uncertainty) or a tensor with shape
        (2,2,2,2). Default value: None.

    reference_thetas : None or list of (ndarray or None), optional
        Reference points from which the distances are calculated. If None, the origin (0,0) is used. Default value:
        None.

    contour_distance : float, optional.
        Distance threshold at which the contours are drawn. Default value: 1.

    xlabel : str, optional
        Label for the x axis. Default value: r'$\theta_0$'.

    ylabel : str, optional
        Label for the y axis. Default value: r'$\theta_1$'.

    xrange : tuple of float, optional
        Range `(min, max)` for the x axis. Default value: (-1., 1.).

    yrange : tuple of float, optional
        Range `(min, max)` for the y axis. Default value: (-1., 1.).

    labels : None or list of (str or None), optional
        Legend labels for the contours. Default value: None.

    inline_labels : None or list of (str or None), optional
        Inline labels for the contours. Default value: None.

    resolution : int
        Number of points per axis for the calculation of the distances. Default value: 500.

    colors : None or str or list of str, optional
        Matplotlib line (and error band) colors for the contours. If None, uses default colors. Default value: None.

    linestyles : None or str or list of str, optional
        Matploitlib line styles for the contours. If None, uses default linestyles. Default value: None.

    linewidths : float or list of float, optional
        Line widths for the contours. Default value: 1.5.

    alphas : float or list of float, optional
        Opacities for the contours. Default value: 1.

    alphas_uncertainties : float or list of float, optional
        Opacities for the error bands. Default value: 0.25.

    Returns
    -------
    figure : Figure
        Plot as Matplotlib Figure instance.

    """
    # Input data
    fisher_information_matrices = np.asarray(fisher_information_matrices)

    n_matrices = fisher_information_matrices.shape[0]

    if fisher_information_matrices.shape != (n_matrices, 2, 2):
        raise RuntimeError(
            "Fisher information matrices have shape {}, not (n, 2,2)!".format(
                fisher_information_matrices.shape))

    if fisher_information_covariances is None:
        fisher_information_covariances = [None for _ in range(n_matrices)]

    if reference_thetas is None:
        reference_thetas = [None for _ in range(n_matrices)]

    d2_threshold = contour_distance**2.0

    # Line formatting
    if colors is None:
        colors = ["C" + str(i) for i in range(10)] * (n_matrices // 10 + 1)
    elif not isinstance(colors, list):
        colors = [colors for _ in range(n_matrices)]

    if linestyles is None:
        linestyles = ["solid", "dashed", "dotted", "dashdot"
                      ] * (n_matrices // 4 + 1)
    elif not isinstance(linestyles, list):
        linestyles = [linestyles for _ in range(n_matrices)]

    if not isinstance(linewidths, list):
        linewidths = [linewidths for _ in range(n_matrices)]

    if not isinstance(alphas, list):
        alphas = [alphas for _ in range(n_matrices)]

    if not isinstance(alphas_uncertainties, list):
        alphas_uncertainties = [
            alphas_uncertainties for _ in range(n_matrices)
        ]

    # Grid
    xi = np.linspace(xrange[0], xrange[1], resolution)
    yi = np.linspace(yrange[0], yrange[1], resolution)
    xx, yy = np.meshgrid(xi, yi, indexing="xy")
    xx, yy = xx.flatten(), yy.flatten()
    thetas = np.vstack((xx, yy)).T

    # Theta from reference thetas
    d_thetas = []
    for reference_theta in reference_thetas:
        if reference_theta is None:
            d_thetas.append(thetas)
        else:
            d_thetas.append(thetas - reference_theta)
    d_thetas = np.array(d_thetas)  # Shape (n_matrices, n_thetas, n_parameters)

    # Calculate Fisher distances
    fisher_distances_squared = np.einsum("mni,mij,mnj->mn", d_thetas,
                                         fisher_information_matrices, d_thetas)
    fisher_distances_squared = fisher_distances_squared.reshape(
        (n_matrices, resolution, resolution))

    # Calculate uncertainties of Fisher distances
    fisher_distances_squared_uncertainties = []
    for d_theta, inf_cov in zip(d_thetas, fisher_information_covariances):
        if inf_cov is None:
            fisher_distances_squared_uncertainties.append(None)
            continue

        var = np.einsum("ni,nj,ijkl,nk,nl->n", d_theta, d_theta, inf_cov,
                        d_theta, d_theta)

        uncertainties = (var**0.5).reshape((resolution, resolution))
        fisher_distances_squared_uncertainties.append(uncertainties)

        logger.debug("Std: %s", uncertainties)

    # Plot results
    fig = plt.figure(figsize=(5.0, 5.0))

    # Error bands
    for i in range(n_matrices):
        if fisher_information_covariances[i] is not None:
            d2_up = fisher_distances_squared[
                i] + fisher_distances_squared_uncertainties[i]
            d2_down = fisher_distances_squared[
                i] - fisher_distances_squared_uncertainties[i]
            band = (d2_up > d2_threshold) * (d2_down < d2_threshold) + (
                d2_up < d2_threshold) * (d2_down > d2_threshold)

            plt.contourf(xi,
                         yi,
                         band, [0.5, 2.5],
                         colors=colors[i],
                         alpha=alphas_uncertainties[i])

    # Predictions
    for i in range(n_matrices):
        cs = plt.contour(
            xi,
            yi,
            fisher_distances_squared[i],
            np.array([d2_threshold]),
            colors=colors[i],
            linestyles=linestyles[i],
            linewidths=linewidths[i],
            alpha=alphas[i],
            label=None if labels is None else labels[i],
        )

        if inline_labels is not None and inline_labels[i] is not None and len(
                inline_labels[i]) > 0:
            plt.clabel(cs,
                       cs.levels,
                       inline=True,
                       fontsize=12,
                       fmt={d2_threshold: inline_labels[i]})

    # Legend and decorations
    if labels is not None:
        plt.legend()

    plt.axes().set_xlim(xrange)
    plt.axes().set_ylim(yrange)
    plt.xlabel(xlabel)
    plt.ylabel(ylabel)

    plt.tight_layout()

    return fig
Exemple #38
0
def present_plane(file_in, plane):
    """ open visualisation file and make desired plots of that plane """

    if os.path.isfile(file_in + '_visual_' + plane + '.fits.gz'):
        file_path = file_in + '_visual_' + plane + '.fits.gz'
        fits = pf.open(file_path)
        data_in = fits[0].data
        n_dust = fits[0].header['N_DUST']
        pix = fits[0].header['NAXIS1']
        r_ou = (pix - 1) / 2 * fits[0].header['CDELT1']
        xlab = 'distance [%s]' % (fits[0].header['CUNIT1'])
        ylab = xlab

        fits.close()

        pic = np.zeros((pix, pix, 8 + 2 * n_dust))
        for i in range(8 + 2 * n_dust):
            pic[:, :, i] = data_in[i, :, :]

        ext = file_path[-10:-8] + '-plane'
        m_range = [-r_ou, r_ou, -r_ou, r_ou]

    else:
        file_path = file_in + '_visual_' + plane + '.dat'
        map_in = open(file_path)
        row = map_in.readline().split()
        map_size = int(row[0])
        row = map_in.readline()  # empty row
        n_dust = 1  # fixed value here

        for j in range(map_size):
            for k in range(map_size):
                row = map_in.readline().split()
                if j == 0 and j == 0:
                    len_pic = len(row)
                    pic = np.zeros((map_size, map_size, len_pic - 2))

                if j == 0 and k == 0:
                    j_min = float(row[0])
                    k_min = float(row[1])
                elif j == map_size - 1 and k == map_size - 1:
                    j_max = float(row[0])
                    k_max = float(row[1])

                for l in range(2, len_pic):
                    if row[l] == 'NaN':
                        pic[k, j, l - 2] = 0
                    else:
                        pic[k, j, l - 2] = row[l]

        m_range = [k_min, k_max, j_min, j_max]
        ext = file_path[-6:-4] + '-plane'
        xlab = 'distance [AU]'
        ylab = xlab

    #~ pic += 1e-250
    #-------------------------------------------------
    #  Dust Temp
    for i in range(n_dust):
        plt.figure('Dust %2.0d Temperature, %s' % (i + 1, ext))
        plt.title('Dust %2.0d Temperature, %s' % (i + 1, ext))
        plt.xlabel(xlab)
        plt.ylabel(ylab)
        cont = [10, 20, 25, 30, 35, 40]
        data = pic[:, :, 4 + n_dust + i]
        CS = plt.contour(data, cont, linewidths=1, colors='k', extent=m_range)
        plt.clabel(CS, inline=1, fmt='%2.1f', fontsize=10)
        plt.imshow(data,
                   extent=m_range,
                   origin='lower',
                   interpolation='None',
                   cmap=plt.cm.jet)
        plt.clim(0, 350)
        plt.colorbar().set_label('Temperature [K]')
    #-------------------------------------------------
    #  Gas Temp

    plt.figure('Gas Temperature, ' + ext)
    plt.title('Gas Temperature, ' + ext)
    plt.xlabel(xlab)
    plt.ylabel(ylab)
    cont = [10, 20, 25, 30, 35, 40]
    data = pic[:, :, 4 + 2 * n_dust]
    CS = plt.contour(data, cont, linewidths=1, colors='k', extent=m_range)
    plt.clabel(CS, inline=1, fmt='%2.1f', fontsize=10)
    plt.imshow(data,
               extent=m_range,
               origin='lower',
               interpolation='None',
               cmap=plt.cm.jet)
    plt.clim(0, 350)
    plt.colorbar().set_label('Temperature [K]')

    #-------------------------------------------------
    #  Velocity
    plt.figure('abs(Velocity), ' + ext)
    plt.title('abs(Velocity), ' + ext)
    plt.xlabel(xlab)
    plt.ylabel(ylab)
    if pic.shape[2] > 9:
        data = np.sqrt(pic[:, :, 5 + 2 * n_dust]**2 +
                       pic[:, :, 6 + 2 * n_dust]**2 +
                       pic[:, :, 7 + 2 * n_dust]**2) / 1000
    else:
        data = pic[:, :, 5 + 2 * n_dust]
    CS = plt.contour(data, linewidths=1, colors='k', extent=m_range)
    plt.clabel(CS, inline=1, fmt='%2.1f', fontsize=10)
    plt.imshow(data,
               extent=m_range,
               origin='lower',
               interpolation='None',
               cmap=plt.cm.jet)
    plt.colorbar().set_label('Velocity [km/s]')

    #-------------------------------------------------
    #  molecule density

    data = pic[:, :, 0 + n_dust] * 1e-6
    plt.figure('Molecule distribution, ' + ext)
    plt.title('Molecule distribution, ' + ext)
    plt.xlabel(xlab)
    plt.ylabel(ylab)
    vmax = np.max(data)
    vmin = vmax * 1e-6
    cont = 10.0**np.linspace(np.log10(vmin), np.log10(vmax), 7)
    CS = plt.contour(data,
                     levels=cont,
                     linewidths=1,
                     colors='k',
                     extent=m_range)
    plt.clabel(CS, inline=1, fmt='%2.1e', fontsize=10)
    plt.imshow(data,
               extent=m_range,
               origin='lower',
               interpolation='None',
               cmap=plt.cm.jet,
               norm=LogNorm(vmin=vmin, vmax=vmax))

    plt.colorbar().set_label('molecule density [cm$^{-3}$]')

    #-------------------------------------------------
    #  dust density
    for i in range(n_dust):
        data = pic[:, :, i] * 1e-6
        plt.figure('Dust %2.0d distribution, %s' % (i + 1, ext))
        plt.title('Dust %2.0d distribution, %s' % (i + 1, ext))
        plt.xlabel(xlab)
        plt.ylabel(ylab)
        vmax = np.max(data)
        vmin = vmax * 1e-6
        cont = 10.0**np.linspace(np.log10(vmin), np.log10(vmax), 7)

        CS = plt.contour(data,
                         levels=cont,
                         linewidths=1,
                         colors='k',
                         extent=m_range)
        plt.clabel(CS, inline=1, fmt='%2.1e', fontsize=10)
        plt.imshow(data,
                   extent=m_range,
                   origin='lower',
                   interpolation='None',
                   cmap=plt.cm.jet,
                   norm=LogNorm(vmin=vmin, vmax=vmax))
        plt.colorbar().set_label('dust density [cm$^{-3}$]')

    #-------------------------------------------------
    #  H2 density

    data = pic[:, :, 1 + n_dust] * 1e-6
    plt.figure('H2 distribution, ' + ext)
    plt.title('H2 distribution, ' + ext)
    plt.xlabel(xlab)
    plt.ylabel(ylab)

    vmax = np.max(data)
    vmin = vmax * 1e-6
    cont = 10.0**np.linspace(np.log10(vmin), np.log10(vmax), 7)

    CS = plt.contour(data,
                     levels=cont,
                     linewidths=1,
                     colors='k',
                     extent=m_range)
    plt.clabel(CS, inline=1, fmt='%2.1e', fontsize=10)
    plt.imshow(data,
               extent=m_range,
               origin='lower',
               interpolation='None',
               cmap=plt.cm.jet,
               norm=LogNorm(vmin=vmin, vmax=vmax))

    plt.colorbar().set_label('H2 number density [cm$^{-3}$]')
    #-------------------------------------------------
    #  N(Mol)/N(H)
    fig = plt.figure('N(mol)/N(H), ' + ext)

    H2 = pic[:, :, 1 + n_dust]
    Mol = pic[:, :, 0 + n_dust]
    data = np.zeros_like(H2)
    idn = np.where(H2 > 0)

    data[idn] = Mol[idn] / H2[idn] * 0.5
    plt.xlabel(xlab)
    plt.ylabel(ylab)
    vmax = np.max(data)
    vmin = vmax * 1e-6
    #~ m_range = [-100,100,-40,40]
    cont = 10.0**np.linspace(np.log10(vmin), np.log10(vmax), 7)
    CS = plt.contour(data[:, :],
                     levels=cont,
                     linewidths=1,
                     colors='k',
                     extent=m_range)
    plt.clabel(CS, inline=1, fmt='%2.1e', fontsize=10)

    plt.imshow(data[:, :],
               extent=m_range,
               origin='lower',
               interpolation='None',
               cmap=plt.cm.jet,
               norm=LogNorm(vmin=vmin, vmax=vmax))
    plt.colorbar().set_label(r'N(HCO$^{+}$)/N(H)')
Exemple #39
0
# Define a nice function of distance from individual pts
def f(x, y, pts):
    z = np.zeros_like(x)
    for p in pts:
        z = z + 1 / (np.sqrt((x - p[0])**2 + (y - p[1])**2))
    return 1 / z


X, Y = np.meshgrid(np.linspace(-1, 1, 51), np.linspace(-1, 1, 51))
Z = f(X, Y, pts)

CS = plt.contour(X, Y, Z, 20)

tellme('Use mouse to select contour label locations, middle button to finish')
CL = plt.clabel(CS, manual=True)

##################################################
# Now do a zoom

tellme('Now do a nested zoom, click to begin')
plt.waitforbuttonpress()

while True:
    tellme('Select two corners of zoom, middle mouse button to finish')
    pts = plt.ginput(2, timeout=-1)
    if len(pts) < 2:
        break
    (x0, y0), (x1, y1) = pts
    xmin, xmax = sorted([x0, x1])
    ymin, ymax = sorted([y0, y1])
Exemple #40
0
LZ = np.linspace(lzmin, lzmax, 100)[np.newaxis, :]
phase = np.exp(-2 * factor * LZ)
multiple_reflections = -T * Ts * phase / (1 + Rs * phase)
S11 = R + multiple_reflections
Z = np.abs(S11)**2

[X, Y] = np.meshgrid(LZ.flatten(), f.flatten())
fig, ax = plt.subplots(figsize=(10, 10))
cax = ax.pcolor(X * 1e3, Y / 1e9, Z, cmap="RdGy", alpha=0.75, vmin=0, vmax=1)
cbar = plt.colorbar(cax, label="Reflection")
ax.tick_params('both', labelsize=14)
contours = plt.contour(X * 1e3, Y / 1e9, Z, [0.1, 0.5], colors="black")
plt.clabel(contours,
           inline=True,
           fontsize=12,
           manual=[(2, 5), (2, 7.5), (4, 7), (4, 11)],
           fmt="%.1f",
           inline_spacing=15)

plt.xlabel("lz [mm]", fontsize=14)
plt.ylabel("f [GHz]")
plt.title(
    "Cu patch edge length L=%s mm, $\epsilon=$ %s + i%s/2$\pi f \epsilon_0$" %
    (L, eps, kappa))

plt.savefig("XBandAbsorber_withoutR.pdf", format="pdf")
to_write = np.zeros((len(f), 5))
to_write[:, 0] = f
to_write[:, 1] = np.real(R[:, 0])
to_write[:, 2] = np.imag(R[:, 0])
to_write[:, 3] = np.real(multiple_reflections[:, 59])
def plot_traj_MDN_mult(model, sess, val_dict, batch, sl_plot=5, ind=-1):
    """Plots the trajectory. At given time-stamp, it plots the probability distributions
  of where the next point will be
  THIS IS FOR MULTIPLE MIXTURES
  input:
  - sess: the TF session
  - val_dict: a dictionary with which to evaluate the model
  - batch: the batch X_val[some_indices] that you feed into val_dict.
    we could also pick this from val-dict, but this workflow is cleaner
  - sl_plot: the time-stamp where you'd like to visualize
  - ind: some index into the batch. if -1, we'll pick a random one"""
    result = sess.run([
        model.mu1, model.mu2, model.mu3, model.s1, model.s2, model.s3,
        model.rho, model.theta
    ],
                      feed_dict=val_dict)
    batch_size, crd, seq_len = batch.shape
    assert ind < batch_size, 'Your index is outside batch'
    assert sl_plot < seq_len, 'Your sequence index is outside sequence'
    if ind == -1: ind = np.random.randint(0, batch_size)
    delta = 0.025  #Grid size to evaluate the PDF
    width = 1.0  # how far to evaluate the pdf?

    fig = plt.figure()
    ax = fig.add_subplot(2, 2, 1, projection='3d')
    ax.plot(batch[ind, 0, :], batch[ind, 1, :], batch[ind, 2, :], 'r')
    ax.scatter(batch[ind, 0, sl_plot], batch[ind, 1, sl_plot], batch[ind, 2,
                                                                     sl_plot])
    ax.set_xlabel('x coordinate')
    ax.set_ylabel('y coordinate')
    ax.set_zlabel('z coordinate')

    # lower-case x1,x2,x3 are indezing the grid
    # upper-case X1,X2,X3 are coordinates in the mesh
    x1 = np.arange(-width, width + 0.1, delta)
    x2 = np.arange(-width, width + 0.2, delta)
    x3 = np.arange(-width, width + 0.3, delta)
    X1, X2, X3 = np.meshgrid(x1, x2, x3, indexing='ij')
    XX = np.stack((X1, X2, X3), axis=3)

    PP = []

    mixtures = result[0].shape[1]
    for m in range(mixtures):
        mean = np.zeros((3))
        mean[0] = result[0][ind, m, sl_plot]
        mean[1] = result[1][ind, m, sl_plot]
        mean[2] = result[2][ind, m, sl_plot]
        cov = np.zeros((3, 3))
        sigma1 = result[3][ind, m, sl_plot]
        sigma2 = result[4][ind, m, sl_plot]
        sigma3 = result[5][ind, m, sl_plot]
        sigma12 = result[6][ind, m, sl_plot] * sigma1 * sigma2
        cov[0, 0] = np.square(sigma1)
        cov[1, 1] = np.square(sigma2)
        cov[2, 2] = np.square(sigma3)
        cov[1, 2] = sigma12
        cov[2, 1] = sigma12
        rv = multivariate_normal(mean, cov)
        P = rv.pdf(XX)  #P is now in [x1,x2,x3]
        PP.append(P)
    # PP is now a list
    PP = np.stack(PP, axis=3)
    # PP is now in [x1,x2,x3,mixtures]
    #Multiply with the mixture
    theta_local = result[7][ind, :, sl_plot]
    ZZ = np.dot(PP, theta_local)
    #ZZ is now in [x1,x2,x3]

    print('The theta variables %s' % theta_local)

    #Every Z is a marginalization of ZZ.
    # summing over axis 2, gives the pdf over x1,x2
    # summing over axis 1, gives the pdf over x1,x3
    # summing over axis 0, gives the pdf over x2,x3
    ax = fig.add_subplot(2, 2, 2)
    X1, X2 = np.meshgrid(x1, x2)
    Z = np.sum(ZZ, axis=2)
    CS = ax.contour(X1, X2, Z.T)
    plt.clabel(CS, inline=1, fontsize=10)
    ax.set_xlabel('x coordinate')
    ax.set_ylabel('y coordinate')

    ax = fig.add_subplot(2, 2, 3)
    X1, X3 = np.meshgrid(x1, x3)
    Z = np.sum(ZZ, axis=1)
    CS = ax.contour(X1, X3, Z.T)
    plt.clabel(CS, inline=1, fontsize=10)
    ax.set_xlabel('x coordinate')
    ax.set_ylabel('Z coordinate')

    ax = fig.add_subplot(2, 2, 4)
    X2, X3 = np.meshgrid(x2, x3)
    Z = np.sum(ZZ, axis=0)
    CS = ax.contour(X2, X3, Z.T)
    plt.clabel(CS, inline=1, fontsize=10)
    ax.set_xlabel('y coordinate')
    ax.set_ylabel('Z coordinate')
Exemple #42
0
        plt.plot(alpha, f, "ro")

        x1 = np.arange(n / Lx) * pi
        y1 = x1 * 0
        plt.plot(x1, y1, "g+")

        axes = plt.gca()
        axes.set_ylim([-1, 1])
        plt.show()

        print(alpha)
        print(np.arange(len(alpha)) * pi / 2)
        print(alpha * np.tan(Lx * alpha) - beta)
        print(np.arange(n) * pi / 2)

    if disp:
        Tanaly = analy(T1, Ta, h, lamb, Lx, Ly, Nx, Ny, n=n, err=err)
        X = np.arange(Tanaly.shape[0]) / Nx * Lx
        Y = np.arange(Tanaly.shape[1]) / Ny * Ly

        fig, ax3 = plt.subplots(figsize=(8, 6))

        im = ax3.pcolormesh(Y, X, Tanaly)
        im2 = ax3.contour(Y, X, Tanaly, colors="k")
        plt.clabel(im2, inline=1, fontsize=10)
        zou = fig.colorbar(im)
        zou.ax.set_ylabel('Température en Kelvin')
        plt.title("Analytic")
        ax3.set_xlabel('x(m)')
        ax3.set_ylabel('y(m)')
print(data['val'].max())
print(data['val'].min())

#brings the data in a matrix form hours above days
data_matrix = data['val'].reshape((24, 365))
a = np.transpose(data_matrix)

#print(data_matrix)

# Create a simple contour plot with labels using default colors.  The
# inline argument to clabel will control whether the labels are draw
# over the line segments of the contour, removing the lines beneath
# the label
plt.figure()
CS = plt.contour(data_matrix)
plt.clabel(CS, inline=1, fontsize=10)
plt.title('Simplest default with labels')

# You can force all the contours to be the same color.
plt.figure()
CS = plt.contour(
    data_matrix,
    6,
    colors='k',  # negative contours will be dashed by default
)
plt.clabel(CS, inline=1, fontsize=9)
plt.title('Single color - negative contours dashed')

# You can set negative contours to be solid instead of dashed:
matplotlib.rcParams['contour.negative_linestyle'] = 'solid'
plt.figure()
Exemple #44
0
def main():
    dimension_number, exp_number = 2, 20
    x_min_dist, x_max_dist, y_min_dist, y_max_dist, x0, dot_num, points_seq_style, way_style, exact_solution_style, \
        figsize, uniform_distr_low, uniform_distr_high, calc_epsilon, min_dist_between_points, level_max_diff = \
        -10.0, 10.0, -10.0, 10.0,  [0, 0], 500, 'ko', 'k-', 'ro', (15, 7.5), -5, 5, 1e-4, 1, 1000
    a, b, c = \
        rand(dimension_number, dimension_number) * (uniform_distr_high - uniform_distr_low) + uniform_distr_low, \
        rand(dimension_number) * (uniform_distr_high - uniform_distr_low) + uniform_distr_low, 0
    for j in range(exp_number):
        b = rand(dimension_number) * (uniform_distr_high -
                                      uniform_distr_low) + uniform_distr_low
        while True:
            a = rand(dimension_number, dimension_number) * (
                uniform_distr_high - uniform_distr_low) + uniform_distr_low
            hessian_of_f = (a + a.T) / 2
            flag = False
            for i in range(dimension_number):
                if linalg.det(hessian_of_f[:i + 1, :i + 1]) < 1e-15:
                    flag = True
                    break
            if not flag:
                break
        exact_solution = linalg.solve(hessian_of_f, b)
        x0 = rand(dimension_number)
        x0[0] = x0[0] * (x_max_dist -
                         x_min_dist) + exact_solution[0] + x_min_dist
        x0[1] = x0[1] * (y_max_dist -
                         y_min_dist) + exact_solution[1] + y_min_dist
        points_seq, _ = r_algorithm(f,
                                    x0,
                                    args=(a, b, c),
                                    form='B',
                                    calc_epsilon=calc_epsilon,
                                    iter_lim=100,
                                    step_method='adaptive',
                                    default_step=10,
                                    step_red_mult=0.75,
                                    step_incr_mult=1.25,
                                    lim_num=3,
                                    reduction_epsilon=1e-15)
        argmin = points_seq[points_seq.shape[0] - 1]
        count = 0
        while count < points_seq.shape[0] - 1:
            if linalg.norm(points_seq[count] -
                           points_seq[count + 1]) < min_dist_between_points:
                points_seq = np.delete(points_seq, count + 1, 0)
                count -= 1
            count += 1
        points_seq = np.append(points_seq,
                               argmin).reshape(points_seq.shape[0] + 1, 2)
        levels = np.sort(
            f(np.array([points_seq[:, 0], points_seq[:, 1]]), (a, b, c)))
        count = 0
        while count < levels.size - 1:
            if levels[count + 1] - levels[count] > level_max_diff:
                levels = np.insert(levels, count + 1,
                                   (levels[count + 1] + levels[count]) / 2.0)
                count -= 1
            count += 1
        levels = np.array(list(set(levels)))
        levels.sort()
        x, y = \
            np.linspace(exact_solution[0] + x_min_dist, exact_solution[0] + x_max_dist, dot_num), \
            np.linspace(exact_solution[1] + y_min_dist, exact_solution[1] + y_max_dist, dot_num)
        xx, yy = np.meshgrid(x, y)
        z = f(np.array([xx, yy]), (a, b, c))
        plt.figure(figsize=figsize)
        plt.grid(True)
        numerical_contour = plt.contour(x, y, z, levels=levels)
        plt.clabel(numerical_contour, inline=1, fontsize=10)
        plt.plot(points_seq[:, 0],
                 points_seq[:, 1],
                 points_seq_style,
                 label=u"Наближення")
        for i in range(points_seq.shape[0] - 1):
            plt.plot([points_seq[i][0], points_seq[i + 1][0]],
                     [points_seq[i][1], points_seq[i + 1][1]], way_style)
        plt.plot(exact_solution[0], exact_solution[1], exact_solution_style)
        plt.show()
        plt.close()
p.figure(1, figsize=(8, 8))
axScatter = p.axes(rect_scatter)
axScatter.set_yscale('log')
axScatter.set_xscale('log')
extent = [yedges[0], yedges[-1], xedges[0], xedges[-1]]
levels = (0.01, 0.1, 0.5, 1)
cset = p.contour(X,
                 Y,
                 proba,
                 levels,
                 origin='lower',
                 colors=['black', 'green', 'blue', 'red'],
                 linewidths=(1.9, 1.6, 1.5, 1.4),
                 extent=extent)
p.clabel(cset, inline=1, fontsize=10, fmt='%1.0i')
for c in cset.collections:
    c.set_linestyle('solid')

p.xlabel('DF N1')
p.ylabel('DF')

axHistx = p.axes(rect_histx)
axHisty = p.axes(rect_histy)
# no labels
axHistx.xaxis.set_major_formatter(nullfmt)
axHisty.yaxis.set_major_formatter(nullfmt)

# the scatter plot:

axHistx.plot(xb, HDF1, 'k')
Exemple #46
0
                               Y_idx,
                               RESULT_STRESS,
                               alpha=.8,
                               cmap='RdYlGn_r',
                               levels=levels)
        plt.colorbar(shrink=0.5,
                     aspect=len(levels),
                     label="nomalized cumulative stress over gait")
        plt.clim(0, 50)

        surf = plt.contour(X_idx,
                           Y_idx,
                           RESULT_STRESS,
                           levels=levels,
                           colors='black')
        plt.clabel(surf, levels, inline=True, fmt='%2.0f', fontsize=25)

        low_res = []
        gait_tex = ''
        for c1_idx in range(len(C1)):
            if c1_idx % take_every == 0 or c1_idx == len(C1) - 1:
                low_res += [1] * len(X2)
            else:
                low_res += [0] * len(X2)
        for g_idx, gait in enumerate(GAITS):
            if low_res[g_idx] == 1:
                gait.plot_orientation(length=.7 * sc, w=.5, size=6)
                #                gait.plot_gait()
                gait_tex = (gait_tex + '\n%%%%%%%\n' +
                            gait.get_tikz_repr(linewidth='.7mm', dashed=0))
Exemple #47
0
def plots_IMSHOW_cc(_snap, _x1, _x2, _pr, _limx1, _limx2, _limpr, _ngrid,
                    _ncont_levels, _text, _paths, _filename):

    limx1 = _limx1
    limx2 = _limx2
    limp = _limpr
    textbar = _text

    x1 = _x1
    x2 = _x2
    p = _pr

    ng = _ngrid
    ncl = _ncont_levels

    #plot
    fig = plt.figure(figsize=(10, 10))
    ax = fig.add_subplot(111)

    [X, Y] = np.meshgrid(np.linspace(np.min(x1), np.max(x1), ng),
                         np.linspace(np.min(x2), np.max(x2), ng))
    Z = griddata(x1, x2, p, X, Y, interp='linear')
    map_prop = ax.imshow(Z,
                         vmin=limp[0],
                         vmax=limp[1],
                         cmap='jet',
                         origin='lower')
    cont_prop = ax.contour(Z,
                           levels=np.linspace(limp[0], limp[1], ncl),
                           cmap='Greys_r',
                           linewidths=1.2)  #cmap='gist_rainbow_r',lw=0.2 )
    plt.clabel(cont_prop, inline=1, fontsize=20, colors='k')

    locsx, labelsx = plt.xticks()
    labelsx = [str(i * (2 * limx1[1] / float(ng)) - limx1[1]) for i in locsx]
    tick_locsx = locsx
    tick_lblsx = labelsx
    plt.xticks(tick_locsx[1:], tick_lblsx[1:])

    locsy, labelsy = plt.yticks()
    labelsy = [str(i * (2 * limx2[1] / float(ng)) - limx2[1]) for i in locsy]
    tick_locsy = locsy
    tick_lblsy = labelsy
    plt.yticks(tick_locsy[1:], tick_lblsy[1:])

    divider = make_axes_locatable(ax)
    cax = divider.append_axes("right", size="5%", pad=0.05)

    cbar = fig.colorbar(map_prop,
                        cax=cax,
                        label=textbar,
                        ticks=np.linspace(limp[0], limp[1], ncl))
    cbar.add_lines(cont_prop)
    time = _snap[9::]
    ax.minorticks_on()
    plt.text(0.87,
             0.92,
             "t=" + time,
             ha='center',
             va='center',
             transform=ax.transAxes,
             color="#ffa74e")
    path = _paths + 'cc_' + '_' + _filename + '_' + str(time) + '.jpg'
    plt.savefig(path, dpi=100, bbox_inches='tight')
Exemple #48
0
             bath_elevsub,
             levels=[0, 10000],
             colors='papayawhip',
             alpha=0.5)
plt.contourf(lonGOFS[oklonGOFS] - 360,
             latGOFS[oklatGOFS],
             NPEA_GOFS_100 * 1000,
             cmap=cmocean.cm.deep_r,
             **kw)
cb = plt.colorbar()
cs = plt.contour(lonGOFS[oklonGOFS] - 360,
                 latGOFS[oklatGOFS],
                 NPEA_GOFS_100 * 1000, [-0.35],
                 color='k')
fmt = '%r'
plt.clabel(cs, fmt=fmt)
plt.axis('scaled')
cb.set_label('Stratification Factor ($x1000$)',
             rotation=270,
             labelpad=20,
             fontsize=14)
plt.title('Non-Dimensional Potential Energy Anomaly 100 m\n GOFS on '+str(tGOFS[oktimeGOFS[4]])[0:13],\
          fontsize=16)

file = folder_fig + 'MAB_NPEA_100m_GOFS'
plt.savefig(file, bbox_inches='tight', pad_inches=0.1)

#%% NPEA COP

kw = dict(levels=np.arange(-0.56, 0, 0.05))
fig, ax = plt.subplots(figsize=(6, 6))
def plot_2d_contour(x_coords,
                    y_coords,
                    z_values,
                    magnitude,
                    base_name,
                    vmin=0.1,
                    vmax=10,
                    vlevel=0.5,
                    show=False,
                    plot_type='mesh',
                    file_type="png",
                    dir1_scale=1.,
                    dir2_scale=1.,
                    dir1_name="dim1",
                    dir2_name="dim2",
                    env_name=None,
                    key_name=None,
                    logscale="auto"):
    """Plot 2D contour map and 3D surface."""
    X = x_coords
    Y = y_coords
    Z = z_values

    title = env_name

    # Remove Atari name options
    env_name = env_name.replace("NoFrameskip", "")
    env_name = env_name.replace("-v0", "")
    env_name = env_name.replace("-v1", "")
    env_name = env_name.replace("-v2", "")
    env_name = env_name.replace("-v3", "")
    env_name = env_name.replace("-v4", "")
    env_name = env_name.replace("-v5", "")
    env_name = env_name.replace("Deterministic", "")

    # Construct Title
    if env_name in ENVCLASSES:
        title += " | " + ENVCLASSES[env_name]
    else:
        warnings.warn(
            "Environment is not listed in reward_surfaces/utils/plot_utils.py, plots titles may be missing information."
        )
    if env_name in REWARDCLASSES:
        title += " | " + REWARDCLASSES[env_name]

    # Label max value
    if key_name in KEYNAMES:
        title += " | " + f"{KEYNAMES[key_name]}"
        #title += " | " + f"Max {KEYNAMES[key_name]}: {np.max(Z):.02f}"
    else:
        title += " | " + "Value"
        #title += " | " + f"Max Value: {np.max(Z):.02f}"

    # Automatically choose logscale
    if logscale == "auto":
        if np.max(Z) - np.min(Z) > 10000:
            logscale = True
    elif logscale == "on":
        logscale = True
    else:
        logscale = False

    # --------------------------------------------------------------------
    # Plot 2D contours
    # --------------------------------------------------------------------
    if plot_type == 'all' or plot_type == 'contour':
        fig = plt.figure()
        CS = plt.contour(X,
                         Y,
                         Z,
                         cmap='summer',
                         levels=np.arange(vmin, vmax, vlevel))
        plt.clabel(CS, inline=1, fontsize=8)
        out_fname = base_name + '_2dcontour.' + file_type
        fig.savefig(out_fname, dpi=300, bbox_inches='tight', format=file_type)

    if plot_type == 'all' or plot_type == 'contourf':
        fig = plt.figure()
        print(base_name + '_2dcontourf' + '.png')
        CS = plt.contourf(X,
                          Y,
                          Z,
                          cmap='summer',
                          levels=np.arange(vmin, vmax, vlevel))
        out_fname = base_name + '_2dcontourf.' + file_type
        fig.savefig(out_fname, dpi=300, bbox_inches='tight', format=file_type)

    # --------------------------------------------------------------------
    # Plot 2D heatmaps
    # --------------------------------------------------------------------
    if plot_type == 'all' or plot_type == 'heat':
        if file_type != "pgf":
            sns.set_theme(font="Serif")
        dir1_name = "Grad Direction"
        dir2_name = "Random Direction"
        size = len(X[0])
        dir1_magnitude = math.floor(math.log10(abs(dir1_scale)))
        dir2_magnitude = math.floor(math.log10(abs(dir2_scale)))

        labels_d1 = [
            f"{x:0.1f}" for x in (np.arange(size) - size // 2) / (size / 2) *
            dir1_scale * (10**-dir1_magnitude)
        ]
        labels_d2 = [
            f"{x:0.1f}" for x in (np.arange(size) - size // 2) / (size / 2) *
            dir2_scale * (10**-dir2_magnitude)
        ]
        ax = plt.axes()
        sns_plot = sns.heatmap(Z,
                               cmap='viridis',
                               cbar=True,
                               vmin=vmin,
                               vmax=vmax,
                               xticklabels=labels_d1,
                               yticklabels=labels_d2)
        sns_plot.invert_yaxis()
        xlabel = dir1_name + r" ($10^{{{}}}$)".format(
            dir1_magnitude) if dir1_magnitude != 0 else dir1_name
        ylabel = dir2_name + r" ($10^{{{}}}$)".format(
            dir2_magnitude) if dir2_magnitude != 0 else dir2_name
        sns_plot.set(xlabel=xlabel, ylabel=ylabel)
        out_fname = base_name + '_2dheat.' + file_type
        ax.set_title(title)
        sns_plot.get_figure().savefig(out_fname,
                                      dpi=300,
                                      bbox_inches='tight',
                                      format=file_type)

    # --------------------------------------------------------------------
    # Plot 3D surface
    # --------------------------------------------------------------------
    if plot_type == 'all' or plot_type == 'mesh':
        fig = plt.figure()
        tnrfont = {'fontname': 'Sans'}
        ax = Axes3D(fig)

        fig.suptitle(title)
        if file_type != "pgf":
            fig.suptitle(title, **tnrfont)

        if np.min(Z) < -1e9 and not logscale:
            print(
                "Warning: Data includes extremely large negative rewards ({:3E}).\
                  Consider setting logscale=True".format(np.min(Z)))

        # Scale X and Y values by the step size magnitude
        X = magnitude * X
        Y = magnitude * Y

        real_Z = Z.copy()
        # Take numerically stable log of data
        if logscale:
            Z_neg = Z[Z < 0]
            Z_pos = Z[Z >= 0]
            Z_neg = -np.log10(1 - Z_neg)
            Z_pos = np.log10(1 + Z_pos)
            Z[Z < 0] = Z_neg
            Z[Z >= 0] = Z_pos

        # Plot surface
        surf = ax.plot_surface(X,
                               Y,
                               Z,
                               cmap=cm.coolwarm,
                               linewidth=0,
                               antialiased=False,
                               zorder=5)

        # Add max text
        # center = len(Z) // 2
        # ax.text(0.05, 0.05, np.max(Z), f"{real_Z[center][center]:.2f}", color='black')

        # Plot center line above surface
        Z_range = abs(np.max(Z) - np.min(Z))
        zline_above = np.linspace(Z[len(Z) // 2][len(Z[0]) // 2],
                                  np.max(Z) + (Z_range * 0.1), 4)
        xline_above = 0 * zline_above
        yline_above = 0 * zline_above
        ax.plot3D(xline_above, yline_above, zline_above, 'black', zorder=10)

        # Plot center line below surface
        zline_below = np.linspace(Z[len(Z) // 2][len(Z[0]) // 2],
                                  np.min(Z) - (Z_range * 0.1), 4)
        xline_below = 0 * zline_below
        yline_below = 0 * zline_below
        ax.plot3D(xline_below, yline_below, zline_below, 'black', zorder=0)

        # Fix colorbar labeling for log scale
        if logscale:
            # Find the highest order of magnitude
            max_Z = np.max(real_Z)
            if max_Z < 0:
                max_magnitude = -math.floor(math.log10(-max_Z))
            else:
                max_magnitude = math.floor(math.log10(max_Z))

            # Find the lowest order of magnitude
            min_Z = np.min(real_Z)
            if min_Z < 0:
                min_magnitude = -math.floor(math.log10(-min_Z))
            else:
                if min_Z == 0:
                    min_Z += 0.0000001
                min_magnitude = math.floor(math.log10(min_Z))

            # Create colorbar
            continuous_labels = np.round(
                np.linspace(min_magnitude, max_magnitude, 8, endpoint=True))
            cbar = fig.colorbar(surf,
                                shrink=0.5,
                                aspect=5,
                                ticks=continuous_labels,
                                pad=0.1)
            cbar.set_ticks(list())

            # Manually set colorbar and z axis tick text
            zticks = []
            ztick_labels = []
            bounds = cbar.ax.get_ybound()
            for index, label in enumerate(continuous_labels):
                x = 6.0
                y = bounds[0] + (bounds[1] - bounds[0]) * index / 8

                # Format label
                zticks.append(label)
                if label > 2 or label < -2:
                    label = "$-10^{" + str(
                        int(-label)) + "}$" if label < 0 else "$10^{" + str(
                            int(label)) + "}$"
                else:
                    label = "${}$".format(-10.0**(
                        -label)) if label < 0 else "${}$".format(10.0**label)
                cbar.ax.text(x, y, label)
                ztick_labels.append("    " + label)
            ax.set_zticks(zticks)
            ax.set_zticklabels(ztick_labels)
            if file_type != "pgf":
                ax.set_zticklabels(ztick_labels, **tnrfont)
        else:
            fig.colorbar(surf, shrink=0.5, aspect=5, pad=0.05)

        # Save plot
        out_fname = base_name + '_3dsurface.' + file_type
        fig.savefig(out_fname, dpi=300, bbox_inches='tight', format=file_type)

    if show:
        plt.show()

    return out_fname
Exemple #50
0
                 levels=np.arange(40, 92, 10),
                 extend='both',
                 zorder=3)
# 色标
cb = fig.colorbar(ac, extend='both', shrink=1, label='相对湿度(%)', pad=0.01)

#温度
temp0 = temps.isel(longitude=46, latitude=80, time=tarray)
temp_tT = temp0 - 273.15
temp_t = temp_tT.T
tt = np.arange(-20, 32, 4)
at = ax.contour(time, levs, temp_t, tt, linewidths=1, colors='red', zorder=4)
#零值线加粗,目前想到的本办法
a0 = ax.contour(time,
                levs,
                temp_t, [0],
                linewidths=1.3,
                colors='red',
                zorder=5)
#fmt参数使标注数字为整数,默认标注3位小数
plt.clabel(at, fontsize=11, fmt='%d', colors="k", inline=True)
#标注0值线
plt.clabel(a0, fontsize=11, fmt='%d', colors="k", inline=True)

#纬向风
v_windT = v_winds.isel(longitude=46, latitude=80, time=tarray)
v_wind = v_windT.T
abar = ax.barbs(time, levs, v_wind)

plt.show()
Exemple #51
0
def plot_grid(gwf, silent=True):
    verbose = not silent
    fs = USGSFigure(figure_type="map", verbose=verbose)

    bot = gwf.dis.botm.array

    fig, axes = create_figure()
    ax = axes[0]
    mm = flopy.plot.PlotMapView(gwf, ax=ax, extent=extents)
    bot_coll = mm.plot_array(bot, vmin=bmin, vmax=bmax)
    mm.plot_bc("CHD", color="cyan")
    cv = mm.contour_array(
        bot,
        levels=blevels,
        linewidths=0.5,
        linestyles=":",
        colors=bcolor,
    )
    plt.clabel(cv, fmt="%1.0f")
    ax.set_xlabel("x-coordinate, in meters")
    ax.set_ylabel("y-coordinate, in meters")
    fs.remove_edge_ticks(ax)

    # legend
    ax = axes[1]
    ax.plot(
        -10000,
        -10000,
        lw=0,
        marker="s",
        ms=10,
        mfc="cyan",
        mec="cyan",
        label="Constant Head",
    )
    ax.plot(
        -10000,
        -10000,
        lw=0.5,
        ls=":",
        color=bcolor,
        label="Bottom elevation contour, m",
    )
    fs.graph_legend(ax, loc="center", ncol=2)

    cax = plt.axes([0.275, 0.125, 0.45, 0.025])
    cbar = plt.colorbar(
        bot_coll,
        shrink=0.8,
        orientation="horizontal",
        cax=cax,
    )
    cbar.ax.tick_params(size=0)
    cbar.ax.set_xlabel(r"Bottom Elevation, $m$")

    # save figure
    if config.plotSave:
        fpth = os.path.join(
            "..",
            "figures",
            "{}-grid{}".format(sim_name, config.figure_ext),
        )
        fig.savefig(fpth)

    return
Exemple #52
0
cs = ax.imshow(numpy.flipud(ratio),
               extent=(80, 111, 40, 80),
               aspect='auto',
               cmap=cmap,
               interpolation='nearest',
               norm=norm)

fig.colorbar(cs)

cs = ax.contour(hindex.value("F") - t,
                levels=[-5, -4, -3, -2, -1, 0, 2, 4, 6, 8, 10, 14, 20],
                extent=(80, 110, 40, 80),
                aspect='auto',
                colors='white')
plt.clabel(cs, inline=1, fontsize=14, fmt='%.0f')

#print numpy.shape(otmpf)
#print numpy.shape(orelh)
#ax.scatter(otmpf.value("F"), orelh)

ax.set_xlim(80, 110)
#ax.set_yticks([10,25,50,75,100])
ax.set_ylabel("Dew Point Temperature $^\circ$F")
ax.set_xlabel(r"Air Temperature $^\circ$F")
ax.set_title(
    "1933-2012 Des Moines Heat Index\ncontour is heat index delta at temp/dwp\npixels are observed frequencies [%] at that temperature"
)
fig.tight_layout()
#fig.colorbar(cs)
Exemple #53
0
fig1.subplots_adjust(bottom=0.08)

#######################################################
#Plotting temperature
#######################################################
ax1 = fig1.add_subplot(311, axisbg='grey')
zmin = T.min()
zmax = 0
#plt.pcolor(Xgrid,depth,T,cmap='Blues_r',vmin=zmin,vmax=zmax)
plt.pcolor(Xgrid, depth, T, cmap=T_cmap, vmin=zmin, vmax=zmax)
c1 = plt.colorbar(pad=0.01)
c1.set_label(r'T')
plt.axis([Xgrid.min(), Xgrid.max(), ymin, ymax])
#ax1.fill_between(Xaxis[:],freeboard[:], snow[:,0]+freeboard[:,],facecolor='white',edgecolor='white')
CS1 = plt.contour(Xgrid, depth_contour, T, levelsT, colors='k')
plt.clabel(CS1, fontsize=9, inline=1, fmt='%1.0f')
plt.plot(Xaxis[:], freeboard[:], 'k--')
plt.ylabel(r'depth [m]')
ax1.set_title('Temperature, liquid volume fraction, and bulk salinity')
ax1.xaxis.set_ticklabels([])

#######################################################
#Plotting liquid fraction
#######################################################
ax2 = fig1.add_subplot(312, axisbg='grey')
fsize = 10.
zmin = 0.
zmax = 1.

#plt.pcolor(Xgrid,depth,psi_l,cmap='bone_r',vmin=zmin,vmax=zmax)
plt.pcolor(Xgrid, depth, psi_l, cmap=psi_cmap, vmin=zmin, vmax=zmax)
Exemple #54
0
def plot_results(idx, sim, silent=True):
    verbose = not silent
    if config.plotModel:
        fs = USGSFigure(figure_type="map", verbose=verbose)
        name = list(parameters.keys())[idx]
        sim_ws = os.path.join(ws, name)
        gwf = sim.get_model(sim_name)

        bot = gwf.dis.botm.array

        if idx == 0:
            plot_grid(gwf, silent=silent)

        # create MODFLOW 6 head object
        file_name = gwf.oc.head_filerecord.get_data()[0][0]
        fpth = os.path.join(sim_ws, file_name)
        hobj = flopy.utils.HeadFile(fpth)

        # create MODFLOW 6 cell-by-cell budget object
        file_name = gwf.oc.budget_filerecord.get_data()[0][0]
        fpth = os.path.join(sim_ws, file_name)
        cobj = flopy.utils.CellBudgetFile(fpth, precision="double")

        # extract heads and specific discharge
        head = hobj.get_data(totim=1.0)
        imask = (head > -1e30) & (head <= bot)
        head[imask] = -1e30  # botm[imask]
        spdis = cobj.get_data(text="DATA-SPDIS", totim=1.0)

        # Create figure for simulation
        fig, axes = create_figure()

        ax = axes[0]
        mm = flopy.plot.PlotMapView(gwf, ax=ax, extent=extents)
        if bot.max() < 20:
            cv = mm.contour_array(
                bot,
                levels=blevels,
                linewidths=0.5,
                linestyles=":",
                colors=bcolor,
                zorder=9,
            )
            plt.clabel(cv, fmt="%1.0f", zorder=9)
        h_coll = mm.plot_array(head,
                               vmin=vmin,
                               vmax=vmax,
                               masked_values=masked_values,
                               zorder=10)
        cv = mm.contour_array(
            head,
            masked_values=masked_values,
            levels=vlevels,
            linewidths=0.5,
            linestyles="-",
            colors=vcolor,
            zorder=10,
        )
        plt.clabel(cv, fmt="%1.0f", zorder=10)
        mm.plot_bc("CHD", color="cyan", zorder=11)
        mm.plot_specific_discharge(spdis,
                                   normalize=True,
                                   color="0.75",
                                   zorder=11)
        ax.set_xlabel("x-coordinate, in meters")
        ax.set_ylabel("y-coordinate, in meters")
        fs.remove_edge_ticks(ax)

        # create legend
        ax = axes[-1]
        ax.plot(
            -10000,
            -10000,
            lw=0,
            marker="s",
            ms=10,
            mfc="cyan",
            mec="cyan",
            label="Constant Head",
        )
        ax.plot(
            -10000,
            -10000,
            lw=0,
            marker=u"$\u2192$",
            ms=10,
            mfc="0.75",
            mec="0.75",
            label="Normalized specific discharge",
        )
        if bot.max() < 20:
            ax.plot(
                -10000,
                -10000,
                lw=0.5,
                ls=":",
                color=bcolor,
                label="Bottom elevation contour, m",
            )
        ax.plot(
            -10000,
            -10000,
            lw=0.5,
            ls="-",
            color=vcolor,
            label="Head contour, m",
        )
        fs.graph_legend(ax, loc="center", ncol=2)

        cax = plt.axes([0.275, 0.125, 0.45, 0.025])
        cbar = plt.colorbar(h_coll,
                            shrink=0.8,
                            orientation="horizontal",
                            cax=cax)
        cbar.ax.tick_params(size=0)
        cbar.ax.set_xlabel(r"Head, $m$", fontsize=9)

        # save figure
        if config.plotSave:
            fpth = os.path.join(
                "..",
                "figures",
                "{}-{:02d}{}".format(sim_name, idx + 1, config.figure_ext),
            )
            fig.savefig(fpth)
Exemple #55
0
def get_flux_vol(params):
	''' Get 2D area and volume of flux surface '''
	[I_l_opt,I_f_opt],[z_l_opt,z_f],[r_l_opt,r_f],[tz_l,tz_f],[tr_l,tr_f],[nz_l,nz_f],[nr_l,nr_f] = params
	X,Z,Bxm,Bzm,Bs,rAm=multicoil_fields([I_l_opt,I_f_opt],[z_l_opt,z_f],[r_l_opt,r_f],[tz_l,tz_f],[tr_l,tr_f],[nz_l,nz_f],[nr_l,nr_f])
	if plt.fignum_exists(123): plt.clf()
	fig1 = plt.figure(123)
	axx=fig1.add_subplot(1,1,1, axisbg='b')
	phi= 2*np.pi*rAm;
	cs = plt.contourf(Z,X,phi*1e3,100,cmap=plt.cm.jet, extend="both")
	cbar=plt.colorbar()
	cbar.set_label(r' $2 \pi r A_{\theta} \times 10^3$',fontsize=16)
	levels=np.linspace(max(phi.flatten()*1.0e3)/5, max(phi.flatten()*1.0e3),100)
	CS = plt.contour(Z,X,phi*1.0e3,levels=levels,colors='w')
	plt.clabel(CS, inline=1, fontsize=13, linewidth=3, colors='white')
	plt.xlabel('r [m]'); plt.ylabel('z [m]')

	x_min,x_max=axx.get_xlim()
	y_min,y_max=axx.get_ylim()

	user_req=1
	while user_req==1:
		contour_lv=float(raw_input('Within which contour level do you want to compute the area and volume? \n'))
		print "Click to get 4 corners within which to compute contour properties"
		             
		coords=plt.ginput(4,show_clicks=True)
		plt.show(block=False)
		cc=np.asarray(coords)

		y_max=cc[:,1].max()
		y_min=cc[:,1].min()
		x_max=cc[:,0].max()
		x_min=cc[:,0].min()

		if plt.fignum_exists(222): plt.clf()
		fig2=plt.figure(222);
		y_max_idx=np.argmin(np.abs(X[0,:]-y_max))
		y_min_idx=np.argmin(np.abs(X[0,:]-y_min))
		x_max_idx=np.argmin(np.abs(Z[:,0]-x_max))
		x_min_idx=np.argmin(np.abs(Z[:,0]-x_min))

		contour_idx=np.argmin(np.abs(levels-contour_lv))

		plt.contourf(Z[x_min_idx:x_max_idx,y_min_idx:y_max_idx],X[x_min_idx:x_max_idx,y_min_idx:y_max_idx],phi[x_min_idx:x_max_idx,y_min_idx:y_max_idx]*1.0e3, levels=levels)
		cs = plt.contour(Z[x_min_idx:x_max_idx,y_min_idx:y_max_idx],X[x_min_idx:x_max_idx,y_min_idx:y_max_idx],phi[x_min_idx:x_max_idx,y_min_idx:y_max_idx]*1.0e3,levels=levels,colors='w')
		plt.clabel(cs, inline=1, fontsize=13, linewidth=3, colors='white')
		plt.xlabel('r [m]'); plt.ylabel('z [m]')

		contour=cs.collections[contour_idx]
		vs=contour.get_paths()[0].vertices
		cs = plt.contour(Z[x_min_idx:x_max_idx,y_min_idx:y_max_idx],X[x_min_idx:x_max_idx,y_min_idx:y_max_idx],phi[x_min_idx:x_max_idx,y_min_idx:y_max_idx]*1.0e3,levels=[levels[contour_idx],],colors='w', linewidths=4.0)

		a=area(vs)
        
                R=(np.mean(vs[:,0])**2+np.mean(vs[:,1])**2)**(0.5)
                print "R = ", R
                sub_area=tr_f*tz_f
		print "Contour of value "+str(levels[contour_idx])+" has (roughly) A="+str(round(a,4))
		print "V = "+str(round(2*np.pi*R*a,4)) + "m-3, " +str(round(2*np.pi*R*a,4)*1000) + " l"
		print "(lower estimate using Green's theorem)"
                print "Confinement volume: ", round(2*np.pi*R*a-sub_area,4)

		print "*****************"
		user_in=raw_input('Enter 1 to look at a different contour, or anything else to stop \n')
		if user_in=='1':
		    user_req=1
		else:
		    user_req=0
		print " - "*20
Exemple #56
0
# objective
Z = 100 * (Y - X**2)**2 + (1 - X)**2
# and the constraint contours
A = X * Y
B = X + Y**2

# plot the contours and constraints
plt.figure()
levels = [250, 500, 1000, 2000, 3000, 6000]
CS = plt.contour(X, Y, Z, levels, colors="k")
levels = np.arange(1.0, 1.01)
CS1 = plt.contour(X, Y, A, levels, colors="g")
levels = np.arange(0.0, 0.01)
CS2 = plt.contour(X, Y, B, levels, colors="b")
plt.clabel(CS, inline=1)
plt.clabel(CS1, inline=1)
plt.clabel(CS2, inline=1)

# set the one sided variable
xupper = [0.5, 0.5]
yupper = [-7, 3.0]

# Now plot the optimizer output
styleList = ["ko-", "ro-", "bo-", "go-", "mo-", "co-", "ks--"]
counter = 0
for opt in db.keys():
    plt.plot(xuser[opt][:, 0], xuser[opt][:, 1], styleList[counter], label=opt)
    counter += 1

plt.plot(xupper, yupper, "k")
Exemple #57
0
ax.set_ylabel('$\\theta_{2}$')
ax.set_zlabel('$E_{in}(h)$')
fig.colorbar(surf, shrink=0.5, aspect=5)

plot.show()

# Figure 6.2

V, U = np.gradient(Z, .2, .2)
Q = plot.quiver(X, Y, -U, -V, pivot='mid', units='inches')
plot.xlabel('$\\theta_{1}$')
plot.ylabel('$\\theta_{2}$')
plot.show()

p = plot.contour(X, Y, Z, cmap='brg_r')
plot.clabel(p, fontsize=9, inline=1)
current_value = np.array([0, 0])
x_values = [0]
y_values = [0]
V, U = np.gradient(Z, .1, .1)
steps = 1000
for i in range(0, steps):
    current_value = current_value - [
        0.1 * V[int(current_value[0] / 0.1),
                int(current_value[1] / 0.1)],
        0.1 * U[int(current_value[0] / 0.1),
                int(current_value[1] / 0.1)]
    ]
    x_values.append(current_value[0])
    y_values.append(current_value[1])
plot.plot(x_values, y_values, 'k:')
Exemple #58
0
pl.ylabel(r'$-G(\ell,\theta)\,\,\mathrm{[k_{B}T]}$', size = 20)
#pl.axis([1.5e-9, 6.5e-8,100,145])
pl.title(r'$\mathrm{-G(\ell,\theta)\,vs.\,separation:\,parallel,\,retarded,\,water}$', size = 20)
#pl.legend(loc = 'best')
pl.savefig('plots/par_ret_water/G_vs_l.pdf')
show()

#G_l_t_dt[G_l_t_dt>300]= np.nan #NOTE: remove me later
#G_l_t_dt[G_l_t_dt<200e-25]= np.nan #NOTE: remove me later

# CONTOUR PLOT:
X,Y = np.meshgrid(thetas, ls)
pl.figure()
pl.contourf(X, Y, np.log(G_l_t_dt), 25)#, cmap = cm.hot())
CS = pl.contour(X,Y,np.log(G_l_t_dt))#, levels = np.linspace(1e-1,1e10,10))
pl.clabel(CS, inline =1,fmt = '%1.5f', fontsize = 18,color = 'k')#, manual = man_loc)
pl.xlabel(r'$Angle\,\,\mathrm{[radians]}$', size = 20)
pl.ylabel(r'$Separation\,\,\mathrm{[m]}$', size = 20)
pl.title(r'$\mathrm{-Log(G),\,retarded,\,parallel\,cyls\,in\,water}$', size = 20)#uas a function of separation and angle')
cbar = pl.colorbar(CS, shrink = 0.8, extend = 'both')
cbar.ax.set_ylabel(r'$-Log(G(\mathcal{\ell},\theta))\,\,[k_{B}T]$', size = 14)
cbar.add_lines(CS)
##pl.axis([0,1.0,0,1.0])
#pl.grid()
pl.savefig('plots/par_ret_water/logG_contour.pdf')
show()

fig = pl.figure()
ax = fig.gca(projection = '3d')
#ax.text(-7, 6, 0.7, r'$\zeta/\omega_{0}$', zdir = (-1,1,-3), size = 21)
surf = ax.plot_surface(X,Y, G_l_t_dt, rstride = 1, cstride = 1,alpha = 0.2, linewidth = 0.3)#edgecolor = 'none',antialiased = True, shade = False, norm = norm, linewidth = 0.3)
zul = z.max()

plt.figure(1, figsize=(10, 10.0))

xi = np.linspace(xll, xul, N)
yi = np.linspace(yll, yul, N)
zi = scipy.interpolate.griddata((x, y),
                                z, (xi[None, :], yi[:, None]),
                                method='cubic')

contours = plt.contour(xi,
                       yi,
                       zi,
                       levels=(2.3, 6.18, 11.83),
                       colors=('orange', 'red', 'violet'))
plt.clabel(contours, inline=True, fontsize=14)
image = plt.imshow(zi,
                   extent=[xll, xul, yll, yul],
                   origin='lower',
                   aspect=(xul - xll) / (yul - yll),
                   norm=mpl.colors.Normalize(vmin=0., vmax=12.),
                   cmap=plt.cm.Blues_r)
clb = plt.colorbar(image, fraction=0.045, pad=0.045, fontsize=14)
plt.tick_params(axis='both', which='major', labelsize=16)
plt.tick_params(axis='both', which='minor', labelsize=16)
clb.set_label(r'$\chi^{2}}$', labelpad=-40, y=1.05, rotation=0, fontsize=18)
plt.ylabel(r'$\delta_{CP}$ $\degree$', fontsize=20)
plt.xlabel(r'$\theta_{13}$ $\degree$', fontsize=20)
plt.title(r'$\delta_{CP}-\theta_{13}$', fontsize=22)
plt.tight_layout()
plt.savefig('theta13deltaCP.pdf')
Exemple #60
0
    np.linspace(0, 3.5, 200).reshape(-1, 1),
)
X_new = np.c_[x0.ravel(), x1.ravel()]

softmax_reg = LogisticRegression(multi_class="multinomial",
                                 solver="lbfgs",
                                 C=10,
                                 random_state=42)
softmax_reg.fit(X, y)
y_proba = softmax_reg.predict_proba(X_new)
y_predict = softmax_reg.predict(X_new)

zz1 = y_proba[:, 1].reshape(x0.shape)
zz = y_predict.reshape(x0.shape)

plt.figure(figsize=(10, 4))
plt.plot(X[y == 2, 0], X[y == 2, 1], "g^", label="Iris-Virginica")
plt.plot(X[y == 1, 0], X[y == 1, 1], "bs", label="Iris-Versicolor")
plt.plot(X[y == 0, 0], X[y == 0, 1], "yo", label="Iris-Setosa")

custom_cmap = ListedColormap(['#fafab0', '#9898ff', '#a0faa0'])

plt.contourf(x0, x1, zz, cmap=custom_cmap)
contour = plt.contour(x0, x1, zz1, cmap=plt.cm.brg)
plt.clabel(contour, inline=1, fontsize=12)
plt.xlabel("Petal length", fontsize=14)
plt.ylabel("Petal width", fontsize=14)
plt.legend(loc="center left", fontsize=14)
plt.axis([0, 7, 0, 3.5])
print("softmax_regression_contour_plot")
plt.show()