Esempio n. 1
0
def draw_force_field(x_list, y_list, width, height):
    from pprint import pprint
    '''docstring for draw_force_field''' 
    log.info("draw_force_field is working..." )
    X = []
    Y = []
    for row in range(0,height):
        one_row_x = []
        one_row_y = []
        for col in range(0, width):
            i = row * width + col
            one_row_x.append(x_list[i])
            one_row_y.append(y_list[i])
        X.append(one_row_x)
        Y.append(one_row_y)
        #X.insert(0, one_row_x)
        #Y.insert(0, one_row_y)

    Q = plt.quiver( X, Y)
    plt.quiverkey(Q, 0.5, 0.92, 2, r'')
    #l,r,b,t = plt.axis()
    #dx, dy = r-l, t-b
    ##axis([l-0.05*dx, r+0.05*dx, b-0.05*dy, t+0.05*dy])
    #plt.xticks(range(0,width +3))
    #plt.yticks(range(0,height + 3))
    plt.title('Attraction Force field')
    plt.savefig("pixel.jpg")
    plt.show()
    return 0
def plot_meancontquiv(turbine="turbine2", save=False):
    mean_u = load_vel_map(turbine=turbine, component="u")
    mean_v = load_vel_map(turbine=turbine, component="v")
    mean_w = load_vel_map(turbine=turbine, component="w")
    y_R = np.round(np.asarray(mean_u.columns.values, dtype=float), decimals=4)
    z_R = np.asarray(mean_u.index.values, dtype=float)
    plt.figure(figsize=(7.5, 4.1))
    # Add contours of mean velocity
    cs = plt.contourf(y_R, z_R, mean_u / U, 20, cmap=plt.cm.coolwarm)
    cb = plt.colorbar(cs, orientation="vertical")
    cb.set_label(r"$U/U_{\infty}$")
    # Make quiver plot of v and w velocities
    Q = plt.quiver(y_R, z_R, mean_v / U, mean_w / U, angles="xy", width=0.0022, edgecolor="none", scale=3.0)
    plt.xlabel(r"$y/R$")
    plt.ylabel(r"$z/R$")
    plt.quiverkey(
        Q, 0.65, 0.045, 0.1, r"$0.1 U_\infty$", labelpos="E", coordinates="figure", fontproperties={"size": "small"}
    )
    ax = plt.axes()
    ax.set_aspect(1)
    # Plot circle to represent turbine frontal area
    circ = plt.Circle((0, 0), radius=1, facecolor="none", edgecolor="gray", linewidth=3.0)
    ax.add_patch(circ)
    plt.tight_layout()
    if save:
        plt.savefig("figures/" + turbine + "-meancontquiv.pdf")
Esempio n. 3
0
def main():

    plot_utils.apply_plot_params(width_cm=20, height_cm=20, font_size=10)

    high_hles_years = [1993, 1995, 1998]
    low_hles_years = [1997, 2001, 2006]
    data_path = "/BIG1/skynet1_rech1/diro/sample_obsdata/eraint/eraint_uvslp_years_198111_201102_NDJmean_ts.nc"





    with xr.open_dataset(data_path) as ds:
        print(ds)


        u = get_composit_for_name(ds, "u10", high_years_list=high_hles_years, low_years_list=low_hles_years)
        v = get_composit_for_name(ds, "v10", high_years_list=high_hles_years, low_years_list=low_hles_years)
        msl = get_composit_for_name(ds, "msl", high_years_list=high_hles_years, low_years_list=low_hles_years)

        lons = ds["longitude"].values
        lats = ds["latitude"].values

        print(lats)
        print(msl.shape)
        print(lons.shape, lats.shape)


        lons2d, lats2d = np.meshgrid(lons, lats)


    fig = plt.figure()

    map = Basemap(llcrnrlon=-130, llcrnrlat=22, urcrnrlon=-28,
                  urcrnrlat=65, projection='lcc', lat_1=33, lat_2=45,
                  lon_0=-95, resolution='i', area_thresh=10000)


    clevs = np.arange(-11.5, 12, 1)
    cmap = cm.get_cmap("bwr", len(clevs) - 1)
    bn = BoundaryNorm(clevs, len(clevs) - 1)

    x, y = map(lons2d, lats2d)
    im = map.contourf(x, y, msl / 100, levels=clevs, norm=bn, cmap=cmap) # convert to mb (i.e hpa)
    map.colorbar(im)


    stride = 2
    ux, vy = map.rotate_vector(u, v, lons2d, lats2d)
    qk = map.quiver(x[::stride, ::stride], y[::stride, ::stride], ux[::stride, ::stride], vy[::stride, ::stride],
               scale=10, width=0.01, units="inches")
    plt.quiverkey(qk, 0.5, -0.1, 2, "2 m/s", coordinates="axes")


    map.drawcoastlines(linewidth=0.5)
    map.drawcountries()
    map.drawstates()
    #plt.show()

    fig.savefig("hles_wind_compoosits.png", bbox_inches="tight", dpi=300)
Esempio n. 4
0
def add_std_vector_to_12months_cycle_figure(plt, fig, CF, parameter):
	std_length	= parameter[0]
	scale		= parameter[1]
	qkeyx		= parameter[2]
	qkeyy		= parameter[3]
	plt.quiverkey(CF, qkeyx, qkeyy, std_length, str(std_length))
	return plt
Esempio n. 5
0
def PLOT_E(v1,v2,v3,v4,scale,title="",flag_out=0,name_out="output.png",flag_show=0):
	if not len(v1) == len (v2):
		print("v1 and v2 have different length")
		return
	if not len(v1) == len (v3):
		print("v1 and v3 have different length")
		return
	if not len(v1) == len (v4):
		print("v1 and v4 have different length")
		return
	E1 = []
	E2 = []
	for i in range(len(v1)):
		E=math.hypot(v3[i],v4[i])
		T=math.atan2(v4[i],v3[i])
		E1.append( E*math.cos(0.5*T))
		E2.append( E*math.sin(0.5*T))

	plt.title(title)
	A=plt.quiver(v1,v2,E1,E2,scale=(float)(scale),width=0.005,headwidth=0,pivot='middle')
	plt.quiverkey(A,0.95,0.95,0.1,"0.1")
	plt.axis('scaled')
	if flag_out == 1:
		plt.savefig(name_out)
	if flag_show == 1:
		plt.show()
	plt.close()
Esempio n. 6
0
def plot_meancontquiv():
    data = calcwake(t1=0.4)
    y_R = data["y/R"]
    z_R = data["z/R"]
    u = data["meanu"]
    v = data["meanv"]
    w = data["meanw"]
    plt.figure(figsize=(7, 9))
    # Add contours of mean velocity
    cs = plt.contourf(y_R, z_R, u/U, 20, cmap=plt.cm.coolwarm)
    cb = plt.colorbar(cs, shrink=1, extend="both",
                      orientation="horizontal", pad=0.1)
                      #ticks=np.round(np.linspace(0.44, 1.12, 10), decimals=2))
    cb.set_label(r"$U/U_{\infty}$")
    # Make quiver plot of v and w velocities
    Q = plt.quiver(y_R, z_R, v/U, w/U, angles="xy", width=0.0022,
                   edgecolor="none", scale=3.0)
    plt.xlabel(r"$y/R$")
    plt.ylabel(r"$z/R$")
    plt.quiverkey(Q, 0.8, 0.21, 0.1, r"$0.1 U_\infty$",
               labelpos="E",
               coordinates="figure",
               fontproperties={"size": "small"})
    ax = plt.axes()
    ax.set_aspect(1)
    # Plot circle to represent turbine frontal area
    circ = plt.Circle((0, 0), radius=1, facecolor="none", edgecolor="gray",
                      linewidth=3.0)
    ax.add_patch(circ)
    plt.tight_layout()
Esempio n. 7
0
    def whiskerplot(cat,col,fig):

        if col == 'psf':
            key = r'e_{PSF}'
        if col == 'e':
            key = r'e'
        if col == 'dpsf':
            key = r'\Delta e_{PSF}'

        scale=0.02

        y,x,mw,e1,e2,e=field.field.whisker_calc(cat,col=col)
        pos0=0.5*np.arctan2(e2/mw,e1/mw)
        e/=mw
        for i in range(len(x)):
            y[i,:,:],x[i,:,:]=field.field_methods.ccd_to_field(i,y[i,:,:]-2048,x[i,:,:]-1024)

        print 'y,x',y[i,:,:],x[i,:,:]

        plt.figure(fig)
        print np.shape(x),np.shape(y),np.shape(np.sin(pos0)*e),np.shape(np.cos(pos0)*e)
        Q = plt.quiver(np.ravel(y),np.ravel(x),np.ravel(np.sin(pos0)*e),np.ravel(np.cos(pos0)*e),units='width',pivot='middle',headwidth=0,width=.0005)
        plt.quiverkey(Q,0.2,0.2,scale,str(scale)+' '+key,labelpos='E',coordinates='figure',fontproperties={'weight': 'bold'})
        plt.savefig('plots/y1/whisker_'+col+'.pdf', dpi=500, bbox_inches='tight')
        plt.close(fig)

        return
def plot_grid(EIC_grid,sat_track,sat_krig,title):
    '''
    This function plots a scatter map of the EICS grid and its horizontal components, and the krigged value for the
    satellite.

    :param EIC_grid: The EICS grid
    :param satPos: The position of the satellite
    :param ptz_u: The krigged u component of the satellite
    :param ptz_v: The krigged v component of the satllite
    :param title: Timestamp of the satellite
    :return: The figure
    '''

    # Define the size of the figure in inches
    plt.figure(figsize=(18,18))

    # The horizontal components of the Ionospheric current from the EICS grid
    u = EIC_grid[:,2]
    v = EIC_grid[:,3]

    '''
    The m variable defines the basemap of area that is going to be displayed.
    1) width and height is the area in pixels of the area to be displayed.
    2) resolution is the resolution of the boundary dataset being used 'c' for crude and 'l' for low
    3) projection is type of projection of the basemape, in this case it is a Lambert Azimuthal Equal Area projection
    4) lat_ts is the latitude of true scale,
    5) lat_0 and lon_0 is the latitude and longitude of the central point of the basemap
    '''
    m = Basemap(width=8000000, height=8000000, resolution='l', projection='lcc',\
             lat_0=60,lon_0=-100.)

    m.drawcoastlines() #draw the coastlines on the basemap

    # draw parallels and meridians and label them
    m.drawparallels(np.arange(-80.,81.,20.),labels=[1,0,0,0],fontsize=10)
    m.drawmeridians(np.arange(-180.,181.,20.),labels=[0,0,0,1],fontsize=10)

    # Project the inputted grid into x,y values defined of the projected basemap parameters
    x,y =m(EIC_grid[:,1],EIC_grid[:,0])
    satx,saty = m(sat_track[::10,7],sat_track[::10,6])
    satkrigx,satkrigy = m(sat_krig[1],sat_krig[0])


    '''
    Plot the inputted grid as a quiver plot on the basemap,
    1) x,y are the projected latitude and longitude coordinates of the grid
    2) u and v are the horizontal components of the current
    3) the EICS grid values are plotted in blue color where as the satellite krigged values are in red
    '''
    eic = m.quiver(x,y,u,v,width = 0.004, scale=10000,color='#0000FF')
    satkrig = m.quiver(satkrigx,satkrigy,sat_krig[2],sat_krig[3],color='#FF0000',width=0.004, scale = 10000)
    satpos = m.scatter(satx,saty,s=100,marker='.',c='#009933',edgecolors='none',label='Satellite Track')
    sat_halo = m.scatter(satkrigx,satkrigy,s=400,facecolors='none',edgecolors='#66FF66',linewidth='5')

    plt.title(title)
    plt.legend([satpos],['Satellite Track'],loc='upper right',scatterpoints=1)
    plt.quiverkey(satkrig,0.891,0.948,520,u'\u00B1' +'520 mA/m',labelpos='E')

    plt.savefig('EICS_20110311_002400.png',bbox_inches='tight',pad_inches=0.2)
Esempio n. 9
0
def water_quiver1(current_data):
    u = water_u1(current_data)
    v = water_v1(current_data)

    plt.hold(True)
    Q = plt.quiver(current_data.x[::2, ::2], current_data.y[::2, ::2], u[::2, ::2], v[::2, ::2])
    max_speed = np.max(np.sqrt(u ** 2 + v ** 2))
    label = r"%s m/s" % str(np.ceil(0.5 * max_speed))
    plt.quiverkey(Q, 0.15, 0.95, 0.5 * max_speed, label, labelpos="W")
    plt.hold(False)
 def animate(n): # the function of the animation
     ax.cla()
     plt.title('Drifter: {0} {1}'.format(drifter_ID,point['time'][n].strftime("%F %H:%M")))
     draw_basemap(ax, points)
     ax.plot(drifter_points['lon'],drifter_points['lat'],'bo-',markersize=6,label='Drifter')
     ax.annotate(an2,xy=(dr_points['lon'][-1],dr_points['lat'][-1]),xytext=(dr_points['lon'][-1]+0.01*track_days,
                 dr_points['lat'][-1]+0.01*track_days),fontsize=6,arrowprops=dict(arrowstyle="fancy"))
     ax.plot(model_points['lon'][:n+1],model_points['lat'][:n+1],'ro-',markersize=6,label=MODEL)
     #M = np.hypot(U[n], V[n])
     Q = ax.quiver(X,Y,U[n],V[n],color='black',pivot='tail',units='xy')
     plt.quiverkey(Q, 0.5, 0.92, 1, r'$1 \frac{m}{s}$', labelpos='E',fontproperties={'weight': 'bold','size':18})
Esempio n. 11
0
def plotResPosArrow2D(ccdSet, iexp, matchVec, sourceVec, outputDir):
    import matplotlib.pyplot as plt
    _xm = []
    _ym = []
    _dxm = []
    _dym = []
    for m in matchVec:
        if (m.good == True and m.iexp == iexp):
            _xm.append(m.u)
            _ym.append(m.v)
            _dxm.append((m.xi_fit - m.xi)*3600)
            _dym.append((m.eta_fit - m.eta)*3600)
    _xs = []
    _ys = []
    _dxs = []
    _dys = []
    if (len(sourceVec) != 0):
        for s in sourceVec:
            if (s.good == True and s.iexp == iexp):
                _xs.append(s.u)
                _ys.append(s.v)
                _dxs.append((s.xi_fit - s.xi)*3600)
                _dys.append((s.eta_fit - s.eta)*3600)

    xm = numpy.array(_xm)
    ym = numpy.array(_ym)
    dxm = numpy.array(_dxm)
    dym = numpy.array(_dym)
    xs = numpy.array(_xs)
    ys = numpy.array(_ys)
    dxs = numpy.array(_dxs)
    dys = numpy.array(_dys)

    plt.clf()
    plt.rc("text", usetex=USETEX)
    plt.rc('xtick', labelsize=10)
    plt.rc('ytick', labelsize=10)

    plotCcd(ccdSet)
    q = plt.quiver(xm, ym, dxm, dym, units="inches", angles="xy", scale=1, color="green", label="external")
    if len(xm) != 0 and len(ym) != 0:
        xPos = round(xm.min() + (xm.max() - xm.min())*0.002, -2)
        yPos = round(ym.max() + (ym.max() - ym.min())*0.025, -2)
        plt.quiverkey(q, xPos, yPos, 0.1, "0.1 arcsec", coordinates="data", color="blue", labelcolor="blue",
                      labelpos='E', fontproperties={'size': 10})
    plt.quiver(xs, ys, dxs, dys, units="inches", angles="xy", scale=1, color="red", label="internal")

    plt.axes().set_aspect("equal")
    plt.legend(fontsize=8)
    plt.title("LSST: %d" % (iexp))
    plt.savefig(os.path.join(outputDir, "ResPosArrow2D_%d.png" % (iexp)), format="png")
Esempio n. 12
0
  def plot_whisker(x,y,e1,e2,name='',label='',scale=.01,key='',chip=False):

    plt.figure()
    Q = plt.quiver(x,y,e1,e2,units='width',pivot='middle',headwidth=0,width=.0005)
    if chip:
      plt.quiverkey(Q,0.2,0.125,scale,str(scale)+' '+key,labelpos='E',coordinates='figure',fontproperties={'weight': 'bold'})
      plt.xlim((-250,4250))
      plt.ylim((-200,2100))
    else:
      plt.quiverkey(Q,0.2,0.2,scale,str(scale)+' '+key,labelpos='E',coordinates='figure',fontproperties={'weight': 'bold'})
    plt.savefig('plots/footprint/whisker_'+name+'_'+label+'.png', dpi=500,bbox_inches='tight')
    plt.close()

    return
Esempio n. 13
0
def plot_flow(binpath, pngpath, title, value):
    data = np.fromfile(binpath, dtype=float)

    # reading additional info
    NX = int(data[0])
    NY = int(data[1])

    data = data[2:]

    # hack
    a = NX
    NX = NY
    NY = a

    U = data[0:len(data):2]
    V = data[1:len(data):2]

    # get max and min vector
    UV = np.vstack((U, V))
    UV_max = np.amax(UV, axis=1)
    UV_min = np.amin(UV, axis=1)
    # get sqrt(x^x + y^y)
    UV_max = np.square(UV_max)
    UV_max = np.sum(UV_max)
    UV_max = np.sqrt(UV_max)

    UV_min = np.square(UV_min)
    UV_min = np.sum(UV_min)
    UV_min = np.sqrt(UV_min)

    UV_average = (UV_max + UV_min) / 2

    U = U.reshape(NX, NY)
    V = V.reshape(NX, NY)

    # create figure
    plt.figure(figsize=(6 * NY / NX, 6))
    # title
    plt.title(title)

    Q = plt.quiver(U, V, color='r', pivot='mid', units='xy')
    plt.quiverkey(Q, 0.5, 0.95, UV_average, '{0:.3e} {1}'.format(UV_average, value), labelpos='W')
    l,r,b,t = plt.axis()
    l,r,b,t = 0.0, NY, 0.0, NX
    dx, dy = r-l, t-b
    plt.axis([l-0.05*dx, r+0.05*dx, b-0.05*dy, t+0.05*dy])

    plt.savefig(pngpath, dpi=150)
    plt.close()
    return 0
Esempio n. 14
0
def quick_static(gflist,datapath,run_name,run_num,c):
    '''
    Make quick quiver plot of static fields
    
    IN:
        gflist: Tod ecide which stations to plot
        datapath: Where are the data files
    '''
    import matplotlib.pyplot as plt
    from numpy import genfromtxt,where,zeros,meshgrid,linspace

    
    GF=genfromtxt(gflist,usecols=3)
    sta=genfromtxt(gflist,usecols=0,dtype='S')
    lon=genfromtxt(gflist,usecols=1,dtype='f')
    lat=genfromtxt(gflist,usecols=2,dtype='f')
    #Read coseismcis
    i=where(GF!=0)[0]
    lon=lon[i]
    lat=lat[i]
    n=zeros(len(i))
    e=zeros(len(i))
    u=zeros(len(i))
    #Get data
    if run_name!='' or run_num!='':
        run_name=run_name+'.'
        run_num=run_num+'.'
    for k in range(len(i)):
        neu=genfromtxt(datapath+run_name+run_num+sta[i[k]]+'.static.neu')
        n[k]=neu[0]#/((neu[0]**2+neu[1]**2)**0.5)
        e[k]=neu[1]#/((neu[0]**2+neu[1]**2)**0.5)
        u[k]=neu[2]#/(2*abs(neu[2]))

            
    #Plot
    plt.figure()
    xi = linspace(min(lon), max(lon), 500)
    yi = linspace(min(lat), max(lat), 500)
    X, Y = meshgrid(xi, yi)
    #c=Colormap('bwr')
    #plt.contourf(X,Y,Z,100)
    #plt.colorbar()
    Q=plt.quiver(lon,lat,e,n,width=0.001,color=c)
    plt.scatter(lon,lat,color='b')
    plt.grid()
    plt.title(datapath+run_name+run_num)
    plt.show()
    qscale_en=1
    plt.quiverkey(Q,X=0.1,Y=0.9,U=qscale_en,label=str(qscale_en)+'m')
Esempio n. 15
0
def overdraw_vec_with_axis(plt, datax, datay, xgrid, ygrid, std_length=0.1, scale=1, intvl=3, qkeyx=0.8, qkeyy=0.8, lw = 2):
	import matplotlib.pyplot as plt
	if datax.shape!=datay.shape:
		raise Exception('datax and datay don\'t have same shape!')

	if datax.shape[0] != ygrid.size:
		raise Exception('data size x does not match ygrid size!')

	if datay.shape[1] != xgrid.size:
		raise Exception('data size y does not match xgrid size!')

	X, Y=np.meshgrid(xgrid, ygrid)
	Q=plt.quiver(X[::intvl, ::intvl], Y[::intvl, ::intvl], datax[::intvl, ::intvl], datay[::intvl, ::intvl], angles='xy', scale=scale, lw = lw)
	plt.quiverkey(Q,  qkeyx,  qkeyy,  std_length,  str(std_length))
	return plt
Esempio n. 16
0
    def plotmap(self, domain = [0., 360., -90., 90.], res='c', stepp=2, scale=20):

        latitudes = self.windspeed.latitudes.data
        longitudes = self.windspeed.longitudes.data

        m = bm(projection='cyl',llcrnrlat=latitudes.min(),urcrnrlat=latitudes.max(),\
        llcrnrlon=longitudes.min(),urcrnrlon=longitudes.max(),\
        lat_ts=0, resolution=res)

        lons, lats = np.meshgrid(longitudes, latitudes)

        cmap = palettable.colorbrewer.sequential.Oranges_9.mpl_colormap

        f, ax = plt.subplots(figsize=(10,6))

        m.ax = ax

        x, y = m(lons, lats)

        im = m.pcolormesh(lons, lats, self.windspeed.data, cmap=cmap)

        cb = m.colorbar(im)
        cb.set_label('wind speed (m/s)', fontsize=14)

        Q = m.quiver(x[::stepp,::stepp], y[::stepp,::stepp], \
                     self.uanoms.data[::stepp,::stepp], self.vanoms.data[::stepp,::stepp], \
                     pivot='middle', scale=scale)

        l,b,w,h = ax.get_position().bounds

        qk = plt.quiverkey(Q, l+w-0.1, b-0.03, 5, "5 m/s", labelpos='E', fontproperties={'size':14}, coordinates='figure')

        m.drawcoastlines()

        return f
Esempio n. 17
0
def my_plot(u,v,t,daystr,levels):
    #boston light swim
    ax= [-71.10, -70.10, 41.70, 42.70] # region to plot
    vel_arrow = 0.2 # velocity arrow scale
    subsample = 8  # subsampling of velocity vectors

    # find velocity points in bounding box
    ind = np.argwhere((lonc >= ax[0]) & (lonc <= ax[1]) & (latc >= ax[2]) & (latc <= ax[3]))

    np.random.shuffle(ind)
    Nvec = int(len(ind) / subsample)
    idv = ind[:Nvec]
    # tricontourf plot of water depth with vectors on top
    plt.figure(figsize=(20,10))
    plt.subplot(111,aspect=(1.0/np.cos(lat[:].mean()*np.pi/180.0)))
    #tricontourf(tri, t,levels=levels,shading='faceted',cmap=plt.cm.gist_earth)
    plt.tricontourf(tri, t,levels=levels,shading='faceted')
    plt.axis(ax)
    plt.gca().patch.set_facecolor('0.5')
    cbar=plt.colorbar()
    cbar.set_label('Forecast Surface Temperature (C)', rotation=-90)
    plt.tricontour(tri, t,levels=[0])
    Q = plt.quiver(lonc[idv],latc[idv],u[idv],v[idv],scale=10)
    maxstr='%3.1f m/s' % vel_arrow
    qk = plt.quiverkey(Q,0.92,0.08,vel_arrow,maxstr,labelpos='W')
    plt.title('NECOFS Surface Velocity, Layer %d, %s UTC' % (ilayer, daystr))
    plt.plot(lon_track,lat_track,'m-o')
    plt.plot(lon_buoy,lat_buoy,'y-o')
Esempio n. 18
0
    def velocidadlimpio(self):
        #sino no llega al 2, asi funciona        
        v = np.arange(-3, 3,1)
        [x,y] = np.meshgrid(v,v)

        z=np.multiply(x,np.exp( -np.power(x,2) - np.power(y,2) ))

        #Matplotlib t invierte el orden de las matrices a diferenciade matlab
        [py,px] = np.gradient(z,1,1)

        print 'x '+str(x)
        print 'y '+str(y)
        print 'z '+str(z)
        print 'px '+str(px)
        print 'py '+str(py)
        
        #q = plt.quiver(X, Y, u, v, angles='xy', scale=40, color=['r'])
        #p = plt.quiverkey(q,1,16.5,50,"50 m/s",coordinates='data',color='r')        

        #primero los rangos, despues los valores q contiene
        q = plt.quiver(x,y, px, py)
        p = plt.quiverkey(q,1,16.5,50,"50 m/s",coordinates='data',color='r')
        plt.title('Velocidad')
        plt.show()
        print 'Fourth plot loaded...'  
Esempio n. 19
0
def plot_meancontquiv(t1_fraction=0.5, cb_orientation="vertical", save=False):
    """Plot contours of normalized mean streamwise velocity and vectors of
    cross-stream and vertical mean velocity.
    """
    data = load_probe_data(t1_fraction=t1_fraction)
    y_R = data["y_R"]
    z_H = data["z_H"]
    mean_u = data["mean_u"]
    mean_v = data["mean_v"]
    mean_w = data["mean_w"]
    scale = 7.5/10.0
    plt.figure(figsize=(10*scale, 3*scale))
    # Add contours of mean velocity
    cs = plt.contourf(y_R, z_H, mean_u, 20, cmap=plt.cm.coolwarm)
    if cb_orientation == "horizontal":
        cb = plt.colorbar(cs, shrink=1, extend="both",
                          orientation="horizontal", pad=0.14)
    elif cb_orientation == "vertical":
        cb = plt.colorbar(cs, shrink=0.88, extend="both",
                          orientation="vertical", pad=0.02)
    cb.set_label(r"$U/U_{\infty}$")
    # Make quiver plot of v and w velocities
    Q = plt.quiver(y_R, z_H, mean_v, mean_w, width=0.0022,
                   edgecolor="none", scale=3)
    plt.xlabel(r"$y/R$")
    plt.ylabel(r"$z/H$")
    plt.ylim(-0.15, 0.85)
    plt.xlim(-1.68/R, 1.68/R)
    if cb_orientation == "horizontal":
        plt.quiverkey(Q, 0.65, 0.26, 0.1, r"$0.1 U_\infty$",
                      labelpos="E",
                      coordinates="figure",
                      fontproperties={"size": "small"})
    elif cb_orientation == "vertical":
        plt.quiverkey(Q, 0.65, 0.09, 0.1, r"$0.1 U_\infty$",
                      labelpos="E",
                      coordinates="figure",
                      fontproperties={"size": "small"})
    plot_turb_lines()
    ax = plt.axes()
    ax.set_aspect(H/R)
    plt.yticks([0, 0.13, 0.25, 0.38, 0.5, 0.63, 0.75])
    plt.grid(True)
    plt.tight_layout()
    if save:
        plt.savefig("figures/meancontquiv.pdf")
        plt.savefig("figures/meancontquiv.png", dpi=300)
def plot_meancontquiv(save=False, show=False, savetype=".pdf",
                      cb_orientation="vertical"):
    """Plot mean contours/quivers of velocity."""
    mean_u = load_vel_map("u")
    mean_v = load_vel_map("v")
    mean_w = load_vel_map("w")
    y_R = np.round(np.asarray(mean_u.columns.values, dtype=float), decimals=4)
    z_H = np.asarray(mean_u.index.values, dtype=float)
    plt.figure(figsize=(7.5, 4.8))
    # Add contours of mean velocity
    cs = plt.contourf(y_R, z_H, mean_u,
                      np.arange(0.15, 1.25, 0.05), cmap=plt.cm.coolwarm)
    if cb_orientation == "horizontal":
        cb = plt.colorbar(cs, shrink=1, extend="both",
                          orientation="horizontal", pad=0.14)
    elif cb_orientation == "vertical":
        cb = plt.colorbar(cs, shrink=1, extend="both",
                          orientation="vertical", pad=0.02)
    cb.set_label(r"$U/U_{\infty}$")
    plt.hold(True)
    # Make quiver plot of v and w velocities
    Q = plt.quiver(y_R, z_H, mean_v, mean_w, width=0.0022,
                   edgecolor="none", scale=3.0)
    plt.xlabel(r"$y/R$")
    plt.ylabel(r"$z/H$")
    # plt.ylim(-0.2, 0.78)
    # plt.xlim(-3.2, 3.2)
    if cb_orientation == "horizontal":
        plt.quiverkey(Q, 0.65, 0.26, 0.1, r"$0.1 U_\infty$",
                      labelpos="E",
                      coordinates="figure",
                      fontproperties={"size": "small"})
    elif cb_orientation == "vertical":
        plt.quiverkey(Q, 0.65, 0.055, 0.1, r"$0.1 U_\infty$",
                      labelpos="E",
                      coordinates="figure",
                      fontproperties={"size": "small"})
    plot_turb_lines()
    plot_exp_lines()
    ax = plt.axes()
    ax.set_aspect(2.0)
    plt.yticks(np.around(np.arange(-1.125, 1.126, 0.125), decimals=2))
    plt.tight_layout()
    if show:
        plt.show()
    if save:
        plt.savefig("figures/meancontquiv"+savetype)
Esempio n. 21
0
def Vector(plt, X, Y, data, parameter, label_flg = 0):
	# std_length,scaleの目安として、
	# 流速の場合、1, 10.0
	# 風応力の場合、0.1, 1.0
	std_length	= parameter[0]
	scale		= parameter[1]
	intvl		= parameter[2]
	qkeyx		= parameter[3]
	qkeyy		= parameter[4]
	data[np.where(abs(data)==np.inf)]=np.nan
	datax = data[0, :, :]
	datay = data[1, :, :]
	Q=plt.quiver(X[::intvl,::intvl],Y[::intvl,::intvl],datax[::intvl,::intvl],datay[::intvl,::intvl],angles='xy',scale=scale)
	if label_flg == 0:
		plt.quiverkey(Q, qkeyx, qkeyy, std_length, str(std_length))

	return plt, Q
Esempio n. 22
0
    def DrawUV(self, m, micapsfile, clipborder, patch):

        if m is plt:
            if self.stream:
                plot = m.streamplot(self.X, self.Y, self.U, self.V,
                                    density=self.density,
                                    linewidth=self.linewidth,
                                    color=self.color,
                                    cmap=self.cmap
                                    )
            if self.barbs:
                barbs = m.barbs(self.X, self.Y, self.U, self.V,
                                length=self.length, barb_increments=dict(half=2, full=4, flag=20),
                                sizes=dict(emptybarb=0))
                pass

        else:
            # transform vectors to projection grid.
            uproj, vproj, xx, yy = \
                m.transform_vector(self.U, self.V, self.x, self.y, self.barbsgrid[0], self.barbsgrid[1],
                                   returnxy=True, masked=True)

            if isinstance(self.color, np.ndarray):
                self.color = self.colorlist

            if self.stream:
                # plot = m.streamplot(xx, yy, uproj, vproj  # , latlon=True
                #                     # density=self.density,
                #                     # linewidth=self.linewidth,
                #                     # color=self.color
                #                     # cmap=self.cmap
                #                     )
                # now plot.
                Q = m.quiver(xx, yy, uproj, vproj, color=self.color, scale=self.scale)
                # make quiver key.
                speed = micapsfile.uv.markscalelength
                qk = plt.quiverkey(Q, 0.1, 0.1, speed, '%.0f m/s' % speed, labelpos='W')
            if self.barbs:
                barbs = m.barbs(xx, yy, uproj, vproj, length=self.length,
                                barb_increments=dict(half=2, full=4, flag=20),
                                sizes=dict(emptybarb=0),
                                barbcolor='k', flagcolor='r',
                                linewidth=0.5)

        if clipborder.path is not None and clipborder.using:
            from matplotlib.patches import FancyArrowPatch
            from matplotlib.collections import PolyCollection
            from matplotlib.lines import Line2D
            for artist in plt.gca().get_children():
                if self.wholeclip:
                    # from matplotlib.patches import Polygon
                    if not isinstance(artist, Line2D):
                        artist.set_clip_path(patch)
                else:
                    from matplotlib.collections import LineCollection
                    if isinstance(artist, FancyArrowPatch) or isinstance(artist, PolyCollection) or \
                            isinstance(artist, LineCollection):
                        artist.set_clip_path(patch)
Esempio n. 23
0
def _show_currentloop_field():
    '''http://www.netdenizen.com/emagnettest/offaxis/?offaxisloop
    '''
    from numpy import sqrt

    r = numpy.linspace(0.0, 3.0, 51)
    z = numpy.linspace(-1.0, 1.0, 51)
    R, Z = numpy.meshgrid(r, z)

    a = 1.0
    V = 230 * sqrt(2.0)
    rho = 1.535356e-08
    II = V/rho
    mu0 = pi * 4e-7

    alpha = R / a
    beta = Z / a
    gamma = Z / R
    Q = (1+alpha)**2 + beta**2
    k = sqrt(4*alpha / Q)

    from scipy.special import ellipk
    from scipy.special import ellipe
    Kk = ellipk(k**2)
    Ek = ellipe(k**2)

    B0 = mu0*II / (2*a)

    V = B0 / (pi*sqrt(Q)) \
        * (Ek * (1.0 - alpha**2 - beta**2)/(Q - 4*alpha) + Kk)
    U = B0 * gamma / (pi*sqrt(Q)) \
        * (Ek * (1.0 + alpha**2 + beta**2)/(Q - 4*alpha) - Kk)

    Q = plt.quiver(R, Z, U, V)
    plt.quiverkey(
            Q, 0.7, 0.92, 1e4, '$1e4$',
            labelpos='W',
            fontproperties={'weight': 'bold'},
            color='r'
            )
    plt.show()
    return
Esempio n. 24
0
def quiver_3d(x,y,vx,vy,vz, ax=None, sep=1):
    import matplotlib.pyplot as plt
    if ax==None:
        ax = plt.figure().add_subplot(111)
    Q = ax.quiver(vy[::sep,::sep], vx[::sep,::sep], \
        vz[::sep,::sep], pivot='mid')
    qk = plt.quiverkey(Q, 0.9, 0.95, 5, r'$5 \frac{m}{s}$',
               labelpos='E',
               coordinates='figure',
               fontproperties={'weight': 'bold'})
    return ax
Esempio n. 25
0
def plotVectorField(X,Y):
    plt.figure()
    Q = plt.quiver(X,Y)
    qk = plt.quiverkey(Q, 0.5, 0.92, 2, r'$2 \frac{m}{s}$', labelpos='W',
                   fontproperties={'weight': 'bold'})
    l,r,b,t = plt.axis()
    dx, dy = r-l, t-b
    plt.axis([l-0.05*dx, r+0.05*dx, b-0.05*dy, t+0.05*dy])

    plt.title('Minimal arguments, no kwargs')
    plt.show()
Esempio n. 26
0
    def add_quiver(self, vname, t, k, cff, step, scale):
        """
        ベクトルの ax を返す関数
        2015-11-08 作成
        """
        X, Y = self.get_xy('quiver', step)
        if 'u_eastward' in self.nc.variables.keys():
            u = self.nc.variables['u_eastward'][t,k-1,::step,::step]
            v = self.nc.variables['v_northward'][t,k-1,::step,::step]
        else:
            u = self.nc.variables['u'][t,k-1,::step,::step]
            v = self.nc.variables['v'][t,k-1,::step,::step]

        ax = plt.gca()
        print X.shape, Y.shape, u.shape, v.shape
        if 'u_eastward' in self.nc.variables.keys():
            Q = ax.quiver(X, Y, u, v, units='width', angles='xy', scale=scale)
        else:
            Q = ax.quiver(X[:-1,:], Y[:-1,:], u[:-1,:], v, units='width', angles='xy', scale=scale)
        plt.quiverkey(Q, 0.9, 0.1, 1.0/scale, '1 m/s')
        return Q
Esempio n. 27
0
def plot_meancontquiv():
    data = calcwake(t1=3.0)
    y_R = data["y/R"]
    z_H = data["z/H"]
    u = data["meanu"]
    v = data["meanv"]
    w = data["meanw"]
    xvorticity = data["xvorticity"]
    plt.figure(figsize=(7, 6.8))
    # Add contours of mean velocity
    cs = plt.contourf(y_R, z_H, u, 20, cmap=plt.cm.coolwarm)
    cb = plt.colorbar(cs, shrink=1, extend='both', 
                      orientation='horizontal', pad=0.12)
                      #ticks=np.round(np.linspace(0.44, 1.12, 10), decimals=2))
    cb.set_label(r'$U/U_{\infty}$')
    plt.hold(True)
    # Make quiver plot of v and w velocities
    Q = plt.quiver(y_R, z_H, v, w, angles='xy', width=0.0022,
                   edgecolor="none", scale=3.0)
    plt.xlabel(r'$y/R$')
    plt.ylabel(r'$z/H$')
    #plt.ylim(-0.2, 0.78)
    #plt.xlim(-3.2, 3.2)
    plt.xlim(-3.66, 3.66)
    plt.ylim(-1.22, 1.22)
    plt.quiverkey(Q, 0.8, 0.22, 0.1, r'$0.1 U_\infty$',
               labelpos='E',
               coordinates='figure',
               fontproperties={'size': 'small'})
    plt.hlines(0.5, -1, 1, linestyles='solid', colors='gray',
               linewidth=3)
    plt.hlines(-0.5, -1, 1, linestyles='solid', colors='gray',
               linewidth=3)
    plt.vlines(-1, -0.5, 0.5, linestyles='solid', colors='gray',
               linewidth=3)
    plt.vlines(1, -0.5, 0.5, linestyles='solid', colors='gray',
               linewidth=3)
    ax = plt.axes()
    ax.set_aspect(2.0)
Esempio n. 28
0
def reload_and_postprocess(int_u = None):
    # Creates a pretty picture =)
    if int_u is None:
        f = open('data/disk_compression/int_u_disk.pkl', 'rb')
        int_u = cPickle.load(f)
    x_pts = 20
    y_pts = 22
    x = np.linspace(-0.95, 0.95, x_pts)
    y = np.linspace(-0.95, 0.95, y_pts)
    X, Y = np.meshgrid(x, y)
    fig = plt.figure()
    ax = fig.add_subplot(1, 1, 1)
    quiver_plot = plt.quiver(X, Y, int_u[0, :, :], int_u[1, :, :])
    plt.quiverkey(quiver_plot, 0.60, 0.95, 0.05, r'0.05', labelpos='W')
    plt.xlabel('X')
    plt.ylabel('Y')
    plt.ylim([-1.1, 1.2])
    plt.xlim([-1.1, 1.1])
    circ = plt.Circle((0, 0), radius = 1.0, color = 'g', fill = False)
    ax.add_patch(circ)
    plt.title(r'Displacement vectors for a disk compressed in plane strain')
    plt.show()
Esempio n. 29
0
        def single_ax(ax, title, df):
            states = df.index
            num_sts = len(states)
            y = np.linspace(0, num_sts-1, num_sts)
            if case == 'vec':
                assert len(df.columns) == 1
                x = [0]
                x_num_sts = 1
            else:
                assert len(df.columns) == num_sts
                x = y
                x_num_sts = num_sts
            xx, yy = np.meshgrid(x, y)
            # print(xx)
            # print(yy)

            ax.set_xlim(-1, x_num_sts)
            ax.set_xticks(np.arange(0, x_num_sts))
            ax.xaxis.tick_top()

            ax.set_ylim(-1, num_sts)
            ax.set_yticks(np.arange(0, num_sts))
            ax.invert_yaxis()

            ax.set_aspect('equal', adjustable='box')
            ax.set_title(title, y=1.2)

            for st, nom in enumerate(states):
                ax.annotate(nom, xy=(x_num_sts+.25, st),
                            annotation_clip=False)
            max_mag = np.max(np.absolute(df.values))
            q = ax.quiver(xx, yy, df.values.real,
                df.values.imag, scale=max_mag, units='x')

            plt.quiverkey(q, 0, -2, max_mag,
                '= {:.2e}'.format(max_mag), labelpos='E', coordinates='data')
 def PlotCurrentField(self,t,**kwargs):
     ''' PlotNewRiskmapFig - Produces a pretty picture from the RiskMapArray which is 
     useful for providing a context within which to plot simulation results. Requires
     'matplotlib<http://matplotlib.sourceforge.net>' pyplot functionality
     
     Args: t
         * t (int) : time index for the current data file that was loaded last.
     ''' 
     if kwargs.has_key('max_depth'):
         max_depth = kwargs['max_depth']
     else:
         max_depth = self.MaxDepth
     if kwargs.has_key('min_depth'):
         min_depth = kwargs['min_depth']
     else:
         min_depth = self.MinDepth
     if kwargs.has_key('arrow_color'):
         arrow_color = kwargs['arrow_color']
     else:
         arrow_color = 'k'
         
     d0,d1 = FindLowAndHighIndices(min_depth,self.depth)
     d1,d2 = FindLowAndHighIndices(max_depth,self.depth)
     print 'Averaging depths between indices %d and %d.'%(d0,d2)
     
     import matplotlib.pyplot as plt
     mapResX, mapResY = 20, 20
     width,height = self.Width, self.Height
     #import pdb; pdb.set_trace()
     u2,v2 = self.u[:,d0:d2,:,:],self.v[:,d0:d2,:,:]
     u2ma,v2ma = np.ma.masked_array(u2,np.isnan(u2)),np.ma.masked_array(v2,np.isnan(v2))
     u_mean, v_mean = u2ma.mean(axis=1).filled(np.nan),v2ma.mean(axis=1).filled(np.nan)
     
     #u_mean, v_mean = self.u.mean(axis=1),self.v.mean(axis=1)
     X,Y = np.linspace(0, width-0.5, mapResX), np.linspace(0, height-0.5, mapResY)
     aX,aY = np.meshgrid(X,Y)
     U,V = np.zeros((mapResX,mapResY)),np.zeros((mapResX,mapResY))
     for j in range(0,mapResY):
         for i in range(0,mapResX):
             myLat,myLon = self.GetLatLonfromXY(X[i],Y[j])
             if self.GetRisk(myLat, myLon, False )<0.9:
                 U[j,i], V[j,i] = BilinearInterpolate(myLat,myLon,self.lat,self.lon,u_mean[int(t)]), \
                                 BilinearInterpolate(myLat,myLon,self.lat,self.lon,v_mean[int(t)])
     q = plt.quiver(aX,aY,U,V,scale=self.gVel*10,color=arrow_color)
     p = plt.quiverkey(q,1,height-0.5,self.gVel,"%.3f m/s"%(self.gVel),coordinates='data',color='k')
Esempio n. 31
0
    def plot_image(self,
                   wavelength0,
                   overplot=False,
                   inclination=None,
                   cmap=None,
                   ax=None,
                   axes_units='AU',
                   polarization=False,
                   polfrac=False,
                   psf_fwhm=None,
                   vmin=None,
                   vmax=None,
                   dynamic_range=1e6,
                   colorbar=False):
        """ Show one image from an MCFOST model

        Parameters
        ----------
        wavelength : string
            note this is a string!! in microns. TBD make it take strings or floats
        inclination : float
            Which inclination to plot, in the case where there are multiple images?
            If not specified, defaults to the median inclination of whichever RT mode
            inclinations were computed.
        overplot : bool
            Should we overplot on current axes (True) or display a new figure? Default is False
        cmap : matplotlib Colormap instance
            Color map to use for display.
        ax : matplotlib Axes instance
            Axis to display into.
        vmin, vmax :    scalars
            Min and max values for image display. Always shows in log stretch
        dynamic_range : float
            default vmin is vmax/dynamic range. Default dynamic range is 1e6.
        axes_units : str
            Units to label the axes in. May be 'AU', 'arcsec', 'deg', or 'pixels'
        psf_fwhm : float or None
            convolve with PSF of this FWHM? Default is None for no convolution
        colorbar : bool
            Also draw a colorbar


        To Do:
        * Add convolution with PSFs
        * Add coronagraphic occulters

        """

        wavelength = self._standardize_wavelength(wavelength0)
        if inclination is None:
            inclination = self.parameters.inclinations[len(
                self.parameters.inclinations) / 2]

        if not overplot:
            if ax is None: plt.clf()
            else: plt.cla()

        if ax is None: ax = plt.gca()

        # Read in the data and select the image of

        imHDU = self.images[wavelength]

        inclin_index = utils.find_closest(self.parameters.inclinations,
                                          inclination)
        image = imHDU.data[0, 0, inclin_index, :, :]

        # Set up color mapping
        if cmap is None:
            from copy import deepcopy
            #cmap = plt.cm.gist_heat
            cmap = deepcopy(plt.cm.gist_gray)
            cmap.set_over('white')
            cmap.set_under('black')
            cmap.set_bad('black')
        if vmax is None: vmax = image.max()
        if vmin is None: vmin = vmax / dynamic_range
        norm = matplotlib.colors.LogNorm(vmin=vmin, vmax=vmax, clip=True)

        # calculate the display extent of the image

        # check if the image header has CDELT keywords, if so use those in preference to
        # the plate scale specified in the parameter file.
        # This will gracefully handle the case of the user overriding the default pixel
        # scale on the command line to MCFOST.
        cd1 = imHDU.header['CDELT1']
        cd2 = imHDU.header['CDELT2']
        pixelscale = np.asarray([cd1, cd2])  # in degrees

        if axes_units.lower() == 'deg':
            pass
        elif axes_units.lower() == 'arcsec':
            pixelscale *= 3600
        elif axes_units.lower() == 'au':
            pixelscale *= 3600 * self.parameters.distance
        elif axes_units.lower() == 'pixels' or axes_units.lower() == 'pixel':
            pixelscale = np.ones(2)
        else:
            raise ValueError("Unknown unit for axes_units: " + axes_units)

        halfsize = (np.asarray(image.shape)) / 2 * pixelscale
        extent = [-halfsize[0], halfsize[0], -halfsize[1], halfsize[1]]

        # Optional: convolve with PSF
        if psf_fwhm is not None:
            raise NotImplementedError("This code not yet implemented")
            import optics
            #psf = optics.airy_2d(aperture=10.0, wavelength=1.6e-6, pixelscale=0.020, shape=(99,99))
            psf = pyfits.getdata(
                '/Users/mperrin/Dropbox/AAS2013/models_pds144n/manual/keck_psf_tmp4.fits'
            )
            from astropy.nddata import convolve
            convolved = convolve(image, psf, normalize_kernel=True)

            image = convolved

        if polfrac:
            ax = plt.subplot(121)

        # Display the image!
        ax = utils.imshow_with_mouseover(ax,
                                         image,
                                         norm=norm,
                                         cmap=cmap,
                                         extent=extent,
                                         origin='lower')
        ax.set_xlabel("Offset [{unit}]".format(unit=axes_units))
        ax.set_ylabel("Offset [{unit}]".format(unit=axes_units))
        ax.set_title("Image for " + wavelength + " $\mu$m")

        if polarization == True:
            # overplot polarization vectors

            # don't show every pixel's vectors:
            showevery = 5

            imQ = imHDU.data[
                1, 0,
                inclin_index, :, :] * -1  #MCFOST sign convention requires flip for +Q = up
            imU = imHDU.data[
                2, 0, inclin_index, :, :] * -1  #MCFOST sign convention, ditto

            imQn = imQ / image
            imUn = imU / image
            polfrac_ar = np.sqrt(imQn**2 + imUn**2)
            theta = 0.5 * np.arctan2(imUn, imQn) + np.pi / 2
            vecX = polfrac_ar * np.cos(theta) * -1
            vecY = polfrac_ar * np.sin(theta)

            Y, X = np.indices(image.shape)
            Q = plt.quiver(X[::showevery, ::showevery],
                           Y[::showevery, ::showevery],
                           vecX[::showevery, ::showevery],
                           vecY[::showevery, ::showevery],
                           headwidth=0,
                           headlength=0,
                           headaxislength=0.0,
                           pivot='middle',
                           color='white')
            plt.quiverkey(Q,
                          0.85,
                          0.95,
                          0.5,
                          "50% pol.",
                          coordinates='axes',
                          labelcolor='white',
                          labelpos='E',
                          fontproperties={'size': 'small'})  #, width=0.003)
            #        ax = plt.subplot(152)
            #        ax.imshow(imQn, vmin=-1, vmax=1, cmap=matplotlib.cm.RdBu)
            #        ax.set_title('Q')
            #        ax = plt.subplot(153)
            #        ax.imshow(imUn, vmin=-1, vmax=1, cmap=matplotlib.cm.RdBu)
            #        ax.set_title('U')
            #        ax = plt.subplot(154)
            #        ax.imshow(vecX, vmin=-1, vmax=1, cmap=matplotlib.cm.RdBu)
            #        ax.set_title('vecX')
            #        ax = plt.subplot(155)
            #        ax.imshow(vecY, vmin=-1, vmax=1, cmap=matplotlib.cm.RdBu)
            #        ax.set_title('vecY')
            #        ax.colorbar()

            #plt.colorbar()

            if polfrac:
                # Display a 2nd panel showing the polarization fraction
                ax2 = plt.subplot(122)

                cmap2 = plt.cm.gist_heat
                cmap2 = plt.cm.jet
                cmap2.set_over('red')
                cmap2.set_under('black')
                cmap2.set_bad('black')

                ax2 = utils.imshow_with_mouseover(ax2,
                                                  polfrac_ar,
                                                  vmin=0,
                                                  vmax=1,
                                                  cmap=cmap2)
                ax2.set_title("Polarization fraction")

                cax = plt.axes([0.92, 0.25, 0.02, 0.5])
                plt.colorbar(ax2.images[0], cax=cax, orientation='vertical')

        if colorbar == True:
            cb = plt.colorbar(mappable=ax.images[0])
            cb.set_label("Intensity [$W/m^2/pixel$]")
    pivot='mid',
    color='blue',
    #cmap = plt.cm.seismic
)

# Main tweaks
# Radius limits
ax1.set_ylim(0, 4)
# Radius Ticks
ax1.set_yticks(np.linspace(0, 4, 5))
# Radius tick position in degrees
ax1.set_rlabel_position(135)
# Angle ticks
ax1.set_xticks(np.linspace(0, 2.0 * np.pi, 17)[:-1])

# Additional tweaks
plt.grid(True)
plt.quiverkey(Quiver,
              1.01,
              1.01,
              3,
              label='3 m/s',
              labelcolor='blue',
              labelpos='N',
              coordinates='axes')
# plt.colorbar(Quiver)
# plt.legend() - no label option, hence no legend
plt.title('Polar Quiver Plots')

plt.show()
Esempio n. 33
0
def plot2dxy_vector(ufilename, vfilename, ttest=True, lvl=850):
    f, ax = plt.subplots(1, figsize=(16, 10))
    #llon = 130; rlon = 230; blat = -25; tlat = 25
    llon = 130
    rlon = 230
    blat = -55
    tlat = 30
    #draw map
    m = Basemap(ax=ax,
                llcrnrlon=85 + (llon - 180),
                llcrnrlat=18.5 + blat,
                urcrnrlon=85 + (rlon - 180),
                urcrnrlat=18.5 + tlat,
                resolution='c',
                projection='merc',
                lat_0=18.5,
                lon_0=85)
    m.drawcoastlines()
    parallels = np.arange(-90, 90, 15.)
    m.drawparallels(parallels, labels=[1, 0, 0, 0])
    meridians = np.arange(0., 360., 15.)
    m.drawmeridians(meridians, labels=[0, 0, 0, 1])
    #quiver on top
    if ttest:
        u_da_raw = xr.open_dataarray(ufilename + '.nc')
        v_da_raw = xr.open_dataarray(vfilename + '.nc')
        u_da_sig = xr.open_dataarray(ufilename + '_ttest.nc')
        v_da_sig = xr.open_dataarray(vfilename + '_ttest.nc')
        Uraw = u_da_raw.values
        Vraw = v_da_raw.values
        Usig = u_da_sig.values
        Vsig = v_da_sig.values
        Usig[np.where(Vsig != 0.0)] = Uraw[np.where(Vsig != 0.0)]
        Vsig[np.where(Usig != 0.0)] = Vraw[np.where(Usig != 0.0)]
        u_da = u_da_raw
        v_da = v_da_raw
        u_da.values = Usig
        v_da.values = Vsig
    else:
        u_da = xr.open_dataarray(ufilename + '.nc')
        v_da = xr.open_dataarray(vfilename + '.nc')

    u_comp = u_da.sel({
        'lv_ISBL0': lvl
    }, method='nearest').sel({
        'g4_lat_1': slice(tlat, blat),
        'g4_lon_2': slice(llon, rlon)
    })
    v_comp = v_da.sel({
        'lv_ISBL0': lvl
    }, method='nearest').sel({
        'g4_lat_1': slice(tlat, blat),
        'g4_lon_2': slice(llon, rlon)
    })
    x = u_comp.coords['g4_lon_2'].values - 180 + 85
    y = u_comp.coords['g4_lat_1'].values + 18.5
    x, dummy = m(x, x)
    dummy, y = m(y, y)
    U = u_comp.values
    V = v_comp.values

    #Q = m.quiver(x, y, U, V)
    Q = m.quiver(x[::3],
                 y[::3],
                 U[::3, ::3],
                 V[::3, ::3],
                 pivot='mid',
                 units='inches',
                 scale=75,
                 scale_units='width',
                 headwidth=5,
                 headlength=2,
                 headaxislength=5)
    qk = plt.quiverkey(Q,
                       0.9,
                       0.9,
                       2,
                       '2 m/s',
                       labelpos='E',
                       coordinates='figure')
    #bounding box and center
    x, y = m([75, 95, 95, 75, 75], [10, 10, 27, 27, 10])
    m.plot(x, y, 'r-', lw=2.5)
    x, y = m([85], [18.5])
    m.plot(x, y, 'ro', ms=5)
    if ttest:
        ax.set_title('{}: {} mb, ttest'.format(ufilename, lvl))
    else:
        ax.set_title('{}: {} mb'.format(ufilename, lvl))
    plt.tight_layout(pad=4)
Esempio n. 34
0
    def plot(self,
             timedata=None,
             udata=None,
             vdata=None,
             ylabel=None,
             **kwargs):

        if kwargs['rotate'] != 0.0:
            print "rotating vectors"
            angle_offset_rad = np.deg2rad(kwargs['rotate'])
            udata = udata * np.cos(angle_offset_rad) + vdata * np.sin(
                angle_offset_rad)
            vdata = -1 * udata * np.sin(angle_offset_rad) + vdata * np.cos(
                angle_offset_rad)

        magnitude = np.sqrt(udata**2 + vdata**2)

        fig = plt.figure(1)
        ax2 = plt.subplot2grid((2, 1), (0, 0), colspan=1, rowspan=1)
        ax1 = plt.subplot2grid((2, 1), (1, 0), colspan=1, rowspan=1)

        # Plot u and v components
        # Plot quiver
        ax1.set_ylim(-1 * np.nanmax(magnitude), np.nanmax(magnitude))
        fill1 = ax1.fill_between(timedata, magnitude, 0, color='k', alpha=0.1)

        # Fake 'box' to be able to insert a legend for 'Magnitude'
        p = ax1.add_patch(plt.Rectangle((1, 1), 1, 1, fc='k', alpha=0.1))
        leg1 = ax1.legend([p], ["Current magnitude [cm/s]"], loc='lower right')
        leg1._drawFrame = False

        # 1D Quiver plot
        q = ax1.quiver(timedata,
                       0,
                       udata,
                       vdata,
                       color='r',
                       units='y',
                       scale_units='y',
                       scale=1,
                       headlength=1,
                       headaxislength=1,
                       width=0.04,
                       alpha=.95)
        qk = plt.quiverkey(q,
                           0.2,
                           0.05,
                           25,
                           r'$25 \frac{cm}{s}$',
                           labelpos='W',
                           fontproperties={'weight': 'bold'})

        # Plot u and v components
        ax1.set_xticklabels(ax1.get_xticklabels(), visible=True)
        ax2.set_xticklabels(ax2.get_xticklabels(), visible=True)
        ax1.axes.get_xaxis().set_visible(True)
        ax1.set_xlim(timedata.min() - 0.5, timedata.max() + 0.5)
        ax1.set_ylabel("Velocity (cm/s)")
        ax2.plot(kwargs['timedata2'],
                 kwargs['data2'][:, 0, 0, 0],
                 'k-',
                 linewidth=1)
        ax2.set_xlim(timedata.min() - 0.5, timedata.max() + 0.5)
        ax2.set_xlabel("Date (UTC)")
        ax2.set_ylabel("Salinity (PSU)")
        ax2.xaxis.set_major_locator(MonthLocator())
        ax2.xaxis.set_minor_locator(
            MonthLocator(bymonth=range(1, 13), bymonthday=15))
        ax2.xaxis.set_major_formatter(ticker.NullFormatter())
        ax2.xaxis.set_minor_formatter(ticker.NullFormatter())
        ax1.xaxis.set_major_locator(MonthLocator())
        ax1.xaxis.set_minor_locator(
            MonthLocator(bymonth=range(1, 13), bymonthday=15))
        ax1.xaxis.set_major_formatter(ticker.NullFormatter())
        ax1.xaxis.set_minor_formatter(DateFormatter('%b %y'))
        ax2.spines['bottom'].set_visible(False)
        ax1.spines['top'].set_visible(False)
        ax1.xaxis.set_ticks_position('top')
        ax2.xaxis.set_ticks_position('bottom')
        ax2.yaxis.set_ticks_position('both')
        ax1.tick_params(axis='both', which='minor', labelsize=self.labelsize)
        ax2.tick_params(axis='both', which='minor', labelsize=self.labelsize)

        return plt, fig
Esempio n. 35
0
var, lons_cyclic = addcyclic(var, lons)
var, lons_cyclic = shiftgrid(180., var, lons_cyclic, start=False)
u, lons_cyclic = addcyclic(u, lons)
u, lons_cyclic = shiftgrid(180., u, lons_cyclic, start=False)
v, lons_cyclic = addcyclic(v, lons)
v, lons_cyclic = shiftgrid(180., v, lons_cyclic, start=False)
lon2d, lat2d = np.meshgrid(lons_cyclic, lats)
x, y = m(lon2d, lat2d)

cs = m.contourf(x, y, var[:, :], values, extend='both')
#cs1 = m.contour(x,y,var[:,:],
#                values,linewidths=0.2,colors='k',
#                linestyles='-')

cs2 = m.quiver(x, y, u, v, scale=150, color='k')

qk = plt.quiverkey(cs2, 1, 0.03, 10, r'10 m/s', labelpos='W')

cmap = ncm.cmap('testcmap')
cs.set_cmap(cmap)

cbar = m.colorbar(cs, location='right', pad='10%', drawedges=True)
cbar.set_ticks(barlim)
cbar.set_ticklabels(map(str, barlim))
cbar.ax.tick_params(axis='x', size=.1)
cbar.set_label(r'\textbf{925mb wind anomalies [m/s]}')

fig.suptitle(r'\textbf{JAS 2007}')

plt.savefig(directoryfigure + 'testwind.png', dpi=300)
'Completed: Script done!'
Esempio n. 36
0
def main(dataDir,
         visit,
         title="",
         outputTxtFileName=None,
         showFwhm=False,
         minFwhm=None,
         maxFwhm=None,
         correctDistortion=False,
         showEllipticity=False,
         ellipticityDirection=False,
         showNdataFwhm=False,
         showNdataEll=False,
         minNdata=None,
         maxNdata=None,
         gridPoints=30,
         verbose=False):

    butler = dafPersist.ButlerFactory(mapper=hscSim.HscSimMapper(
        root=dataDir)).create()
    camera = butler.get("camera")

    if not (showFwhm or showEllipticity or showNdataFwhm or showNdataEll
            or outputTxtFileName):
        showFwhm = True
    #
    # Get a dict of cameraGeom::Ccd indexed by serial number
    #
    ccds = {}
    for raft in camera:
        for ccd in raft:
            ccd.setTrimmed(True)
            ccds[ccd.getId().getSerial()] = ccd
    #
    # Read all the tableSeeingMap files, converting their (x, y) to focal plane coordinates
    #
    xArr = []
    yArr = []
    ellArr = []
    fwhmArr = []
    paArr = []
    aArr = []
    bArr = []
    e1Arr = []
    e2Arr = []
    elle1e2Arr = []
    for tab in butler.subset("tableSeeingMap", visit=visit):
        # we could use tab.datasetExists() but it prints a rude message
        fileName = butler.get("tableSeeingMap_filename", **tab.dataId)[0]
        if not os.path.exists(fileName):
            continue

        with open(fileName) as fd:
            ccd = None
            for line in fd.readlines():
                if re.search(r"^\s*#", line):
                    continue
                fields = [float(_) for _ in line.split()]

                if ccd is None:
                    ccd = ccds[int(fields[0])]

                x, y, fwhm, ell, pa, a, b = fields[1:8]
                x, y = ccd.getPositionFromPixel(geom.PointD(x, y)).getMm()
                xArr.append(x)
                yArr.append(y)
                ellArr.append(ell)
                fwhmArr.append(fwhm)
                paArr.append(pa)
                aArr.append(a)
                bArr.append(b)
                if len(fields) == 11:
                    e1 = fields[8]
                    e2 = fields[9]
                    elle1e2 = fields[10]
                else:
                    e1 = -9999.
                    e2 = -9999.
                    elle1e2 = -9999.
                e1Arr.append(e1)
                e2Arr.append(e2)
                elle1e2Arr.append(elle1e2)

    xArr = np.array(xArr)
    yArr = np.array(yArr)
    ellArr = np.array(ellArr)
    fwhmArr = np.array(fwhmArr) * 0.168  # arcseconds
    paArr = np.radians(np.array(paArr))
    aArr = np.array(aArr)
    bArr = np.array(bArr)

    e1Arr = np.array(e1Arr)
    e2Arr = np.array(e2Arr)
    elle1e2Arr = np.array(elle1e2Arr)

    if correctDistortion:
        import lsst.afw.geom.ellipses as afwEllipses

        dist = camera.getDistortion()
        for i in range(len(aArr)):
            axes = afwEllipses.Axes(aArr[i], bArr[i], paArr[i])
            if False:  # testing only!
                axes = afwEllipses.Axes(1.0, 1.0, np.arctan2(yArr[i], xArr[i]))
            quad = afwGeom.Quadrupole(axes)
            quad = quad.transform(
                dist.computeQuadrupoleTransform(geom.PointD(xArr[i], yArr[i]),
                                                False))
            axes = afwEllipses.Axes(quad)
            aArr[i], bArr[i], paArr[i] = axes.getA(), axes.getB(
            ), axes.getTheta()

        ellArr = 1 - bArr / aArr

    if len(xArr) == 0:
        gridPoints = 0
        xs, ys = [], []
    else:
        N = gridPoints * 1j
        extent = [min(xArr), max(xArr), min(yArr), max(yArr)]
        xs, ys = np.mgrid[extent[0]:extent[1]:N, extent[2]:extent[3]:N]

    title = [
        title,
    ]

    title.append("\n#")

    if outputTxtFileName:
        f = open(outputTxtFileName, 'w')
        f.write("# %s visit %s\n" % (" ".join(title), visit))
        for x, y, ell, fwhm, pa, a, b, e1, e2, elle1e2 \
                in zip(xArr, yArr, ellArr, fwhmArr, paArr, aArr, bArr, e1Arr, e2Arr, elle1e2Arr):
            f.write('%f %f %f %f %f %f %f %f %f %f\n' %
                    (x, y, ell, fwhm, pa, a, b, e1, e2, elle1e2))

    if showFwhm:
        title.append("FWHM (arcsec)")
        if len(xs) > 0:
            fwhmResampled = griddata(xArr, yArr, fwhmArr, xs, ys)
            plt.imshow(fwhmResampled.T,
                       extent=extent,
                       vmin=minFwhm,
                       vmax=maxFwhm,
                       origin='lower')
            plt.colorbar()

        if outputTxtFileName:

            ndataGrids = getNumDataGrids(xArr, yArr, fwhmArr, xs, ys)

            f = open(outputTxtFileName + '-fwhm-grid.txt', 'w')
            f.write("# %s visit %s\n" % (" ".join(title), visit))
            for xline, yline, fwhmline, ndataline \
                    in zip(xs.tolist(), ys.tolist(), fwhmResampled.tolist(), ndataGrids):
                for xx, yy, fwhm, ndata in zip(xline, yline, fwhmline,
                                               ndataline):
                    if fwhm is None:
                        fwhm = -9999
                    f.write('%f %f %f %d\n' % (xx, yy, fwhm, ndata))

    elif showEllipticity:
        title.append("Ellipticity")
        scale = 4

        if ellipticityDirection:  # we don't care about the magnitude
            ellArr = 0.1

        u = -ellArr * np.cos(paArr)
        v = -ellArr * np.sin(paArr)
        if gridPoints > 0:
            u = griddata(xArr, yArr, u, xs, ys)
            v = griddata(xArr, yArr, v, xs, ys)
            x, y = xs, ys
        else:
            x, y = xArr, yArr

        Q = plt.quiver(
            x,
            y,
            u,
            v,
            scale=scale,
            pivot="middle",
            headwidth=0,
            headlength=0,
            headaxislength=0,
        )
        keyLen = 0.10
        if not ellipticityDirection:  # we care about the magnitude
            plt.quiverkey(Q, 0.20, 0.95, keyLen, "e=%g" % keyLen, labelpos='W')

        if outputTxtFileName:
            ndataGrids = getNumDataGrids(xArr, yArr, ellArr, xs, ys)

            f = open(outputTxtFileName + '-ell-grid.txt', 'w')
            f.write("# %s visit %s\n" % (" ".join(title), visit))
            # f.write('# %f %f %f %f %f %f %f\n' % (x, y, ell, fwhm, pa, a, b))
            for xline, yline, uline, vline, ndataline \
                    in zip(x.tolist(), y.tolist(), u.tolist(), v.tolist(), ndataGrids):
                for xx, yy, uu, vv, ndata in zip(xline, yline, uline, vline,
                                                 ndataline):
                    if uu is None:
                        uu = -9999
                    if vv is None:
                        vv = -9999
                    f.write('%f %f %f %f %d\n' % (xx, yy, uu, vv, ndata))

    elif showNdataFwhm:
        title.append("N per fwhm grid")
        if len(xs) > 0:
            ndataGrids = getNumDataGrids(xArr, yArr, fwhmArr, xs, ys)
            plt.imshow(ndataGrids,
                       interpolation='nearest',
                       extent=extent,
                       vmin=minNdata,
                       vmax=maxNdata,
                       origin='lower')
            plt.colorbar()
        else:
            pass

    elif showNdataEll:
        title.append("N per ell grid")
        if len(xs) > 0:
            ndataGrids = getNumDataGrids(xArr, yArr, ellArr, xs, ys)
            plt.imshow(ndataGrids,
                       interpolation='nearest',
                       extent=extent,
                       vmin=minNdata,
                       vmax=maxNdata,
                       origin='lower')
            plt.colorbar()
        else:
            pass

    # plt.plot(xArr, yArr, "r.")
    # plt.plot(xs, ys, "b.")
    plt.axes().set_aspect('equal')
    plt.axis([-20000, 20000, -20000, 20000])

    def frameInfoFrom(filepath):
        with fits.open(filepath) as hdul:
            h = hdul[0].header
            'object=ABELL2163 filter=HSC-I exptime=360.0 alt=62.11143274 azm=202.32265181 '
            'hst=(23:40:08.363-23:40:48.546)'
            return 'object=%s filter=%s exptime=%.1f azm=%.2f hst=%s' % \
                (h['OBJECT'], h['FILTER01'], h['EXPTIME'], h['AZIMUTH'], h['HST'])

    title.insert(
        0,
        frameInfoFrom(
            butler.get('raw_filename', {
                'visit': visit,
                'ccd': 0
            })[0]))
    title.append(r'$\langle$FWHM$\rangle %4.2f$"' % np.median(fwhmArr))
    plt.title("%s visit=%s" % (" ".join(title), visit), fontsize=9)

    return plt
Esempio n. 37
0
def geoplot(data=None, lon=None, lat=None, **kw):
    '''Show 2D data in a lon-lat plane.

    Parameters
    -----------
        data: array of shape (n_lat, n_lon), or [u_array, v_array]-like for (u,v)
            data or None(default) when only plotting the basemap.
        lon: n_lon length vector or None(default).
        lat: n_lat length vector or None(default).
        kw: dict parameters related to basemap or plot functions.

    Basemap related parameters:
    ----------------------------
        basemap_kw: dict parameter in the initialization of a Basemap.
        proj or projection: map projection name (default='moll')
            popular projections: 'ortho', 'np'(='nplaea'), 'sp'(='splaea')
                and other projections given from basemap.
        lon_0: map center longitude (None as default).
        lat_0: map center latitude (None as default).
        lonlatcorner: (llcrnrlon, urcrnrlon, llcrnrlat, urcrnrlat).
        boundinglat: latitude at the map out boundary (None as default).
        basemap_round or round: True(default) or False.

        fill_continents: bool value (False as default).
        continents_kw: dict parameter used in the Basemap.fillcontinents method.
        continents_color: color of continents ('0.33' as default).
        lake_color: color of lakes ('none' as default).
        ocean_color: color of ocean (None as default).

        coastlines_kw: dict parameter used in the Basemap.drawcoastlines method.
        coastlines_color: color of coast lines ('0.33' as default).

        gridOn: bool value (True as default).
        gridLabelOn: bool value (False as default).

        parallels_kw: dict parameters used in the Basemap.drawparallels method.
        parallels: parallels to be drawn (None as default).
        parallels_color: color of parallels ('0.5' as default).
        parallels_labels:[0,0,0,0] or [1,0,0,0].

        meridians_kw: dict parameters used in the Basemap.drawmeridians method.
        meridians: meridians to be drawn (None as default).
        meridians_color: color of meridians (parallels_color as default).
        meridians_labels: [0,0,0,0] or [0,0,0,1].

        lonlatbox: None or (lon_start, lon_end, lat_start, lat_end).
        lonlatbox_kw: dict parameters in the plot of lon-lat box.
        lonlatbox_color:

    General plot parameters:
    -------------------------
        ax: axis object, default is plt.gca()
        plot_type: a string of plot type from ('pcolor', 'pcolormesh', 'imshow', 'contourf', 'contour', 'quiver', 'scatter') or None(default).
        cmap: pyplot colormap.
        clim: a tuple of colormap limit.
        levels: sequence, int or None (default=None)
        plot_kw: dict parameters used in the plot functions.

    Pcolor/Pcolormesh related parameters:
    -------------------------------
        rasterized: bool (default is True).

    Imshow related parameters
    ---------------------------
        origin: 'lower' or 'upper'.
        extent: horizontal range.
        interpolation: 'nearest' (default) or 'bilinear' or 'cubic'.

    Contourf related parameters:
    -------------------------------
        extend: 'both'(default).

    Contour related parameters:
    ----------------------------
        label_contour: False(default) or True.
            Whether to label contours or not.
        colors: contour color (default is 'gray').

    Quiver plot related parameters:
    --------------------------------
        stride: stride along lon and lat.
        stride_lon: stride along lon.
        stride_lat: stride along lat.
        quiver_scale: quiver scale.
        quiver_color: quiver color.
        sparse_polar_grids: bool, default is True.
        quiver_kw: dict parameters used in the plt.quiver function.

        hide_qkey: bool value, whether to show the quiverkey plot.
        qkey_X: X parameter in the plt.quiverkey function (default is 0.85).
        qkey_Y: Y parameter in the plt.quiverkey function (default is 1.02).
        qkey_U: U parameter in the plt.quiverkey function (default is 2).
        qkey_label: label parameter in the plt.quiverkey function.
        qkey_labelpos: labelpos parameter in the plt.quiverkey function.
        qkey_kw: dict parameters used in the plt.quiverkey function.

    Scatter related parameters:
    ------------------------------
        scatter_data: None(default) or (lonvec, latvec).

    Hatch plot related parameters:
    ----------------------------------
        hatches: ['///'] is default.

    Colorbar related parameters:
    -------------------------------
        hide_cbar: bool value, whether to show the colorbar.
        cbar_type: 'vertical'(shorten as 'v') or 'horizontal' (shorten as 'h').
        cbar_extend: extend parameter in the plt.colorbar function.
            'neither' as default here.
        cbar_size: default '2.5%' for vertical colorbar,
            '5%' for horizontal colorbar.
        cbar_pad: default 0.1 for vertical colorbar,
            0.4 for horizontal colorbar.
        cbar_kw: dict parameters used in the plt.colorbar function.
        units: str
        long_name: str

    Returns
    --------
        basemap object if only basemap is plotted.
        plot object if data is shown.
        '''

    # target axis
    ax = kw.pop('ax', None)
    if ax is not None:
        plt.sca(ax)

    if isinstance(data, xr.DataArray):
        data_array = data.copy()
        data = data_array.values
        if np.any(np.isnan(data)):
            data = ma.masked_invalid(data)
        if lon is None:
            try:
                lonname = [
                    s for s in data_array.dims
                    if s in ('lon', 'longitude', 'X')
                ][0]
            except IndexError:
                lonname = [s for s in data_array.dims if 'lon' in s][0]
            lon = data_array[lonname]
        if lat is None:
            try:
                latname = [
                    s for s in data_array.dims if s in ('lat', 'latitude', 'Y')
                ][0]
            except IndexError:
                latname = [s for s in data_array.dims if 'lat' in s][0]
            lat = data_array[latname]
        # guess data name
        try:
            data_name = data_array.attrs['long_name']
        except KeyError:
            try:
                data_name = data_array.name
            except AttributeError:
                data_name = ''
        # guess data units
        try:
            data_units = data_array.attrs['units']
        except KeyError:
            data_units = ''
    #  copy the original data
    elif data is not None:
        try:
            data = data.copy()
        except:
            try:
                # data has two components(u,v)
                data = (data[0].copy(), data[1].copy())
            except:
                pass
    if lon is not None:
        lon = lon.copy()
    if lat is not None:
        lat = lat.copy()
    # #### basemap parameters
    # basemap kw parameter
    basemap_kw = kw.pop('basemap_kw', {})
    # projection
    # proj = kw.pop('proj', 'cyl')
    # proj = kw.pop('proj', 'moll')
    proj = kw.pop('proj', 'hammer')
    proj = kw.pop('projection',
                  proj)  # projection overrides the proj parameter
    # short names for nplaea and splaea projections
    if proj in ('npolar', 'polar', 'np'):
        proj = 'nplaea'
    elif proj in ('spolar', 'sp'):
        proj = 'splaea'

    # lon_0
    lon_0 = kw.pop('lon_0', None)
    if lon_0 is None:
        if lon is not None:
            if np.isclose(np.abs(lon[-1] - lon[0]), 360):
                lon_0 = (lon[0] + lon[-2]) / 2.0
            else:
                lon_0 = (lon[0] + lon[-1]) / 2.0
        else:
            # dummy = np.linspace(0, 360, data.shape[1]+1)[0:-1]
            # lon_0 = ( dummy[0] + dummy[-1] )/2.0
            lon_0 = 180
        # elif proj in ('moll', 'cyl', 'hammer', 'robin'):
        #     lon_0 = 180
        # elif proj in ('ortho','npstere', 'nplaea', 'npaeqd', 'spstere', 'splaea', 'spaeqd'):
        #     lon_0 = 0
    else:  # lon_0 is specified
        if lon is not None and proj in ('moll', 'cyl', 'hammer'):
            # correct the lon_0 so that it is at the edge of a grid box
            lon_0_data = (lon[0] + lon[-1]) / 2.0
            d_lon = lon[1] - lon[0]
            d_lon_0 = lon_0 - lon_0_data
            lon_0 = float(int(d_lon_0 / d_lon)) * d_lon + lon_0_data

    # lat_0
    lat_0 = kw.pop('lat_0', None)
    if lat_0 is None:
        if lat is not None:
            lat_0 = (lat[0] + lat[-1]) / 2.0
        elif proj in ('ortho', ):
            lat_0 = 45

    # lonlatcorner = (llcrnrlon, urcrnrlon, llcrnrlat, urcrnrlat)
    lonlatcorner = kw.pop('lonlatcorner', None)
    if lonlatcorner is not None:
        llcrnrlon = lonlatcorner[0]
        urcrnrlon = lonlatcorner[1]
        llcrnrlat = lonlatcorner[2]
        urcrnrlat = lonlatcorner[3]
    else:
        llcrnrlon = None
        urcrnrlon = None
        llcrnrlat = None
        urcrnrlat = None
    llcrnrlon = basemap_kw.pop('llcrnrlon', llcrnrlon)
    urcrnrlon = basemap_kw.pop('urcrnrlon', urcrnrlon)
    llcrnrlat = basemap_kw.pop('llcrnrlat', llcrnrlat)
    urcrnrlat = basemap_kw.pop('urcrnrlat', urcrnrlat)
    if llcrnrlon is None and urcrnrlon is None and llcrnrlat is None and urcrnrlat is None:
        lonlatcorner = None
    else:
        lonlatcorner = (llcrnrlon, urcrnrlon, llcrnrlat, urcrnrlat)

    # boundinglat
    boundinglat = kw.pop('boundinglat', None)
    if boundinglat is None:
        if proj in ('npstere', 'nplaea', 'npaeqd'):
            boundinglat = 30
        elif proj in ('spstere', 'splaea', 'spaeqd'):
            boundinglat = -30

    # basemap round: True or False
    if proj in ('npstere', 'nplaea', 'npaeqd', 'spstere', 'splaea', 'spaeqd'):
        basemap_round = kw.pop('basemap_round', True)
    else:
        basemap_round = kw.pop('basemap_round', False)
    basemap_round = kw.pop('round', basemap_round)

    # base map
    proj = basemap_kw.pop('projection', proj)
    lon_0 = basemap_kw.pop('lon_0', lon_0)
    lat_0 = basemap_kw.pop('lat_0', lat_0)
    boundinglat = basemap_kw.pop('boundinglat', boundinglat)
    basemap_round = basemap_kw.pop('round', basemap_round)
    m = Basemap(projection=proj,
                lon_0=lon_0,
                lat_0=lat_0,
                boundinglat=boundinglat,
                round=basemap_round,
                llcrnrlon=llcrnrlon,
                urcrnrlon=urcrnrlon,
                llcrnrlat=llcrnrlat,
                urcrnrlat=urcrnrlat,
                **basemap_kw)

    # fill continents or plot coast lines
    fill_continents = kw.pop('fill_continents', False)
    if fill_continents:
        # use Basemap.fillcontinents method
        continents_kw = kw.pop('continents_kw', {})
        continents_color = kw.pop('continents_color', '0.33')
        continents_color = continents_kw.pop('color', continents_color)
        lake_color = kw.pop('lake_color', 'none')
        lake_color = continents_kw.pop('lake_color', lake_color)
        m.fillcontinents(color=continents_color,
                         lake_color=lake_color,
                         **continents_kw)
    # else:
    draw_coastlines = kw.pop('draw_coastlines', not fill_continents)
    if draw_coastlines:
        # use Basemap.drawcoastlines method
        coastlines_kw = kw.pop('coastlines_kw', {})
        coastlines_color = kw.pop('coastlines_color', '0.33')
        coastlines_color = coastlines_kw.pop('color', coastlines_color)
        coastlines_lw = kw.pop('coastlines_lw', 0.5)
        coastlines_lw = coastlines_kw.pop('lw', coastlines_lw)
        m.drawcoastlines(color=coastlines_color,
                         linewidth=coastlines_lw,
                         **coastlines_kw)
    ocean_color = kw.pop('ocean_color', None)
    if ocean_color is not None:
        m.drawmapboundary(fill_color=ocean_color)

    # parallels
    gridOn = kw.pop('gridOn', True)
    gridLabelOn = kw.pop('gridLabelOn', False)
    parallels_kw = kw.pop('parallels_kw', {})
    # parallels = kw.pop('parallels', np.arange(-90,91,30))
    parallels = kw.pop('parallels', None)
    parallels = parallels_kw.pop('parallels', parallels)
    parallels_color = kw.pop('parallels_color', '0.5')
    parallels_color = parallels_kw.pop('color', parallels_color)
    parallels_lw = kw.pop('parallels_lw', 0.5)
    parallels_lw = parallels_kw.pop('lw', parallels_lw)
    parallels_labels = kw.pop('parallels_labels', None)
    parallels_labels = parallels_kw.pop('labels', parallels_labels)
    if parallels_labels is None:
        if gridLabelOn:
            parallels_labels = [1, 0, 0, 0]
        else:
            parallels_labels = [0, 0, 0, 0]
    if parallels is not None:
        m.drawparallels(parallels,
                        color=parallels_color,
                        labels=parallels_labels,
                        linewidth=parallels_lw,
                        **parallels_kw)
    elif gridOn:
        m.drawparallels(np.arange(-90, 91, 30),
                        color=parallels_color,
                        linewidth=parallels_lw,
                        labels=parallels_labels,
                        **parallels_kw)

    # meridians
    meridians_kw = kw.pop('meridians_kw', {})
    # meridians = kw.pop('meridians', np.arange(-180, 360, 30))
    meridians = kw.pop('meridians', None)
    meridians = meridians_kw.pop('meridians', meridians)
    meridians_color = kw.pop('meridians_color', parallels_color)
    meridians_color = meridians_kw.pop('color', meridians_color)
    meridians_lw = kw.pop('meridians_lw', parallels_lw)
    meridians_lw = meridians_kw.pop('lw', meridians_lw)
    meridians_labels = kw.pop('meridians_labels', None)
    meridians_labels = meridians_kw.pop('labels', meridians_labels)
    if meridians_labels is None:
        if gridLabelOn:
            if proj in ('npstere', 'nplaea', 'npaeqd', 'spstere', 'splaea',
                        'spaeqd'):
                meridians_labels = [1, 1, 0, 0]
            elif proj in ('cyl', ):
                meridians_labels = [0, 0, 0, 1]
            else:
                meridians_labels = [0, 0, 0, 0]
                print('Meridian are not labeled.')
        else:
            meridians_labels = [0, 0, 0, 0]
    if meridians is not None:
        m.drawmeridians(meridians,
                        color=meridians_color,
                        labels=meridians_labels,
                        linewidth=meridians_lw,
                        **meridians_kw)
    elif gridOn:
        m.drawmeridians(np.arange(0, 360, 30),
                        color=meridians_color,
                        labels=meridians_labels,
                        linewidth=meridians_lw,
                        **meridians_kw)

    # lonlatbox
    lonlatbox = kw.pop('lonlatbox', None)
    if lonlatbox is not None:
        lonlon = np.array([
            np.linspace(lonlatbox[0], lonlatbox[1],
                        100), lonlatbox[1] * np.ones(100),
            np.linspace(lonlatbox[1], lonlatbox[0], 100),
            lonlatbox[0] * np.ones(100)
        ]).ravel()
        latlat = np.array([
            lonlatbox[2] * np.ones(100),
            np.linspace(lonlatbox[2], lonlatbox[3], 100),
            lonlatbox[3] * np.ones(100),
            np.linspace(lonlatbox[3], lonlatbox[2], 100)
        ]).ravel()
        lonlatbox_kw = kw.pop('lonlatbox_kw', {})
        lonlatbox_color = kw.pop('lonlatbox_color', 'k')
        lonlatbox_color = lonlatbox_kw.pop('color', lonlatbox_color)
        m.plot(lonlon,
               latlat,
               latlon=True,
               color=lonlatbox_color,
               **lonlatbox_kw)

    # scatter
    scatter_data = kw.pop('scatter_data', None)
    if scatter_data is not None:
        # L = data.astype('bool')
        # marker_color = kw.pop('marker_color', 'k')
        # plot_obj = m.scatter(X[L], Y[L], color=marker_color, **kw)
        lonvec, latvec = scatter_data
        plot_obj = m.scatter(lonvec, latvec, **kw)

    # #### stop here and return the map object if data is None
    if data is None:
        return m

    # data prepare
    input_data_have_two_components = isinstance(data, tuple) \
        or isinstance(data, list)
    if input_data_have_two_components:
        # input data is (u,v) or [u, v] where u, v are ndarray and two components of a vector
        assert len(
            data) == 2, 'quiver data must contain only two componets u and v'
        u = data[0].squeeze()
        v = data[1].squeeze()
        assert u.ndim == 2, 'u component data must be two dimensional'
        assert v.ndim == 2, 'v component data must be two dimensional'
        data = np.sqrt(u**2 + v**2)  # calculate wind speed
    else:  # input data is a ndarray
        data = data.squeeze()
        assert data.ndim == 2, 'Input data must be two dimensional!'

    # lon
    if lon is None:
        # lon = np.linspace(0, 360, data.shape[1]+1)[0:-1]
        # lon_edge = np.hstack((
        #     lon[0]*2 - lon[1],
        #     lon,
        #     lon[-1]*2 - lon[-2]))
        # lon_edge = ( lon_edge[:-1] + lon_edge[1:] )/2.0
        lon_edge = np.linspace(lon_0 - 180, lon_0 + 180, data.shape[1] + 1)
        lon = (lon_edge[:-1] + lon_edge[1:]) / 2.0
    else:  # lon is specified
        if np.isclose(np.abs(lon[-1] - lon[0]), 360):
            # first and last longitude point to the same location: remove the last longitude
            lon = lon[:-1]
            data = data[:, :-1]
            if input_data_have_two_components:
                u = u[:, :-1]
                v = v[:, :-1]
        if (not np.isclose(lon_0, (lon[0] + lon[-1]) / 2.0)
                and proj in ('moll', 'cyl', 'hammer', 'robin')):
            # lon_0 not at the center of lon, need to shift grid
            lon_west_end = lon_0 - 180 + (
                lon[1] - lon[0]) / 2.0  # longitude of west end
            # make sure the longitude of west end within the lon
            if lon_west_end < lon[0]:
                lon_west_end += 360
            elif lon_west_end > lon[-1]:
                lon_west_end -= 360
            data, lon_shift = shiftgrid(lon_west_end, data, lon, start=True)
            if input_data_have_two_components:
                u, lon_shift = shiftgrid(lon_west_end, u, lon, start=True)
                v, lon_shift = shiftgrid(lon_west_end, v, lon, start=True)
            lon = lon_shift
            if lon[0] < -180:
                lon += 360
            elif lon[-1] >= 540:
                lon -= 360
        lon_hstack = np.hstack(
            (2 * lon[0] - lon[1], lon, 2 * lon[-1] - lon[-2]))
        lon_edge = (lon_hstack[:-1] + lon_hstack[1:]) / 2.0

    # lat
    if lat is None:
        lat_edge = np.linspace(-90, 90, data.shape[0] + 1)
        lat = (lat_edge[:-1] + lat_edge[1:]) / 2.0
    else:
        lat_hstack = np.hstack(
            (2 * lat[0] - lat[1], lat, 2 * lat[-1] - lat[-2]))
        lat_edge = (lat_hstack[:-1] + lat_hstack[1:]) / 2.0
        lat_edge[lat_edge > 90] = 90
        lat_edge[lat_edge < -90] = -90
    Lon, Lat = np.meshgrid(lon, lat)
    X, Y = m(Lon, Lat)
    Lon_edge, Lat_edge = np.meshgrid(lon_edge, lat_edge)
    X_edge, Y_edge = m(Lon_edge, Lat_edge)

    # ###### plot parameters
    # plot_type
    plot_type = kw.pop('plot_type', None)
    if plot_type is None:
        if input_data_have_two_components:
            plot_type = 'quiver'
        # elif ( proj in ('cyl',)
        #     and lonlatcorner is None
        #     ):
        #     plot_type = 'imshow'
        #     print('plot_type **** imshow **** is used.')
        elif proj in ('nplaea', 'splaea', 'ortho'):
            # pcolormesh has a problem for these projections
            plot_type = 'pcolor'
            print('plot_type **** pcolor **** is used.')
        else:
            plot_type = 'pcolormesh'
            print('plot_type **** pcolormesh **** is used.')

    # cmap
    cmap = kw.pop('cmap', None)
    if cmap is None:
        zz_max = data.max()
        zz_min = data.min()
        if zz_min >= 0:
            try:
                cmap = plt.get_cmap('viridis')
            except:
                cmap = plt.get_cmap('OrRd')
        elif zz_max <= 0:
            try:
                cmap = plt.get_cmap('viridis')
            except:
                cmap = plt.get_cmap('Blues_r')
        else:
            cmap = plt.get_cmap('RdBu_r')
    elif isinstance(cmap, str):
        cmap = plt.get_cmap(cmap)

    # clim parameters
    clim = kw.pop('clim', None)
    robust = kw.pop('robust', False)
    if clim is None:
        if isinstance(data, np.ma.core.MaskedArray):
            data1d = data.compressed()
        else:
            data1d = data.ravel()
        notNaNs = np.logical_not(np.isnan(data1d))
        data1d = data1d[notNaNs]
        if robust:
            a = np.percentile(data1d, 2)
            b = np.percentile(data1d, 98)
        else:
            a = data1d.min()
            b = data1d.max()
        if a * b < 0:
            b = max(abs(a), abs(b))
            a = -b
        clim = a, b

    # levels
    levels = kw.pop('levels', None)
    if levels is None:
        if plot_type in ('contour', 'contourf', 'contourf+'):
            a, b = clim
            levels = np.linspace(a, b, 11)
    elif isinstance(levels, int):
        if plot_type in ('contour', 'contourf', 'contourf+'):
            a, b = clim
            levels = np.linspace(a, b, levels)
        elif plot_type in ('pcolor', 'pcolormesh', 'imshow'):
            cmap = plt.get_cmap(cmap.name, levels - 1)
    else:  # levels is a sequence
        if plot_type in ('pcolor', 'pcolormesh', 'imshow'):
            cmap = plt.get_cmap(cmap.name, len(levels) - 1)
            clim = min(levels), max(levels)

    # colorbar parameters
    if plot_type in ('pcolor', 'pcolormesh', 'contourf', 'contourf+',
                     'imshow'):
        cbar_type = kw.pop('cbar_type', 'vertical')
        cbar_kw = kw.pop('cbar_kw', {})
        cbar_extend = kw.pop('cbar_extend', 'neither')
        cbar_extend = cbar_kw.pop('extend', cbar_extend)
        hide_cbar = kw.pop('hide_cbar', False)
        if cbar_type in ('v', 'vertical'):
            cbar_size = kw.pop('cbar_size', '2.5%')
            cbar_size = cbar_kw.pop('size', cbar_size)
            cbar_pad = kw.pop('cbar_pad', 0.1)
            cbar_pad = cbar_kw.pop('pad', cbar_pad)
            cbar_position = 'right'
            cbar_orientation = 'vertical'
        elif cbar_type in ('h', 'horizontal'):
            # cbar = hcolorbar(units=units)
            cbar_size = kw.pop('cbar_size', '5%')
            cbar_size = cbar_kw.pop('size', cbar_size)
            cbar_pad = kw.pop('cbar_pad', 0.4)
            cbar_pad = cbar_kw.pop('pad', cbar_pad)
            cbar_position = 'bottom'
            cbar_orientation = 'horizontal'
    # units in colorbar
    units = kw.pop('units', None)
    if units is None:
        try:
            units = data_units  # input data is a DataArray
        except:
            units = ''
    # long_name in colorbar
    long_name = kw.pop('long_name', None)
    if long_name is None:
        try:
            long_name = data_name  # if input data is a DataArray
            if long_name is None:
                long_name = ''
        except:
            long_name = ''

    # ###### plot
    # pcolor
    if plot_type in ('pcolor', ):
        rasterized = kw.pop('rasterized', True)
        plot_obj = m.pcolor(X_edge,
                            Y_edge,
                            data,
                            cmap=cmap,
                            rasterized=rasterized,
                            **kw)

    # pcolormesh
    elif plot_type in ('pcolormesh', ):
        rasterized = kw.pop('rasterized', True)
        plot_obj = m.pcolormesh(X_edge,
                                Y_edge,
                                data,
                                cmap=cmap,
                                rasterized=rasterized,
                                **kw)

    # imshow
    elif plot_type in ('imshow', ):
        if Y_edge[-1, 0] > Y_edge[0, 0]:
            origin = kw.pop('origin', 'lower')
        else:
            origin = kw.pop('origin', 'upper')
        extent = kw.pop(
            'extent',
            [X_edge[0, 0], X_edge[0, -1], Y_edge[0, 0], Y_edge[-1, 0]])
        interpolation = kw.pop('interpolation', 'nearest')
        plot_obj = m.imshow(data,
                            origin=origin,
                            cmap=cmap,
                            extent=extent,
                            interpolation=interpolation,
                            **kw)

    # contourf
    elif plot_type in ('contourf', ):
        if proj in ('ortho','npstere', 'nplaea', 'npaeqd', 'spstere',
            'splaea', 'spaeqd')\
            and np.isclose(np.abs(lon_edge[-1]-lon_edge[0]), 360):
            data, lon = addcyclic(data, lon)
            Lon, Lat = np.meshgrid(lon, lat)
            X, Y = m(Lon, Lat)
        extend = kw.pop('extend', 'both')
        plot_obj = m.contourf(X,
                              Y,
                              data,
                              extend=extend,
                              cmap=cmap,
                              levels=levels,
                              **kw)

    # contour
    elif plot_type in ('contour', ):
        if proj in ('ortho','npstere', 'nplaea', 'npaeqd', 'spstere',
            'splaea', 'spaeqd')\
            and np.isclose(np.abs(lon_edge[-1]-lon_edge[0]), 360):
            data, lon = addcyclic(data, lon)
            Lon, Lat = np.meshgrid(lon, lat)
            X, Y = m(Lon, Lat)
        colors = kw.pop('colors', 'k')
        if colors is not None:
            cmap = None
        alpha = kw.pop('alpha', 0.5)
        plot_obj = m.contour(X,
                             Y,
                             data,
                             cmap=cmap,
                             colors=colors,
                             levels=levels,
                             alpha=alpha,
                             **kw)
        label_contour = kw.pop('label_contour', False)
        if label_contour:
            plt.clabel(plot_obj, plot_obj.levels[::2], fmt='%.2G')

    # contourf + contour
    elif plot_type in ('contourf+', ):
        if proj in ('ortho','npstere', 'nplaea', 'npaeqd', 'spstere',
            'splaea', 'spaeqd')\
            and np.isclose(np.abs(lon_edge[-1]-lon_edge[0]), 360):
            data, lon = addcyclic(data, lon)
            Lon, Lat = np.meshgrid(lon, lat)
            X, Y = m(Lon, Lat)
        extend = kw.pop('extend', 'both')
        linewidths = kw.pop('linewidths', 1)
        plot_obj = m.contourf(X,
                              Y,
                              data,
                              extend=extend,
                              cmap=cmap,
                              levels=levels,
                              **kw)
        colors = kw.pop('colors', 'k')
        if colors is not None:
            cmap = None
        alpha = kw.pop('alpha', 0.5)
        m.contour(X,
                  Y,
                  data,
                  cmap=cmap,
                  colors=colors,
                  alpha=alpha,
                  levels=levels,
                  linewidths=linewidths,
                  **kw)

    # quiverplot
    elif plot_type in ('quiver', ):
        nGrids = kw.pop('nGrids', 50)
        nx = kw.pop('nx', nGrids)
        ny = kw.pop('ny', nGrids)
        stride = kw.pop('stride', 1)
        stride_lon = kw.pop('stride_lon', stride)
        stride_lat = kw.pop('stride_lat', stride)
        print(stride, stride_lon, stride_lat)
        if (stride != 1) or (stride_lon != 1) or (
                stride_lat != 1
        ):  # compatible with old api, with stride, stride_lon, stride_lat controling quiver grids. To be obsolete. Use nGrids, nx, ny instead
            print('stride used')
            lon_ = lon[::stride_lon]  # subset of lon
            lat_ = lat[::stride_lat]
            u_ = u[::stride_lat, ::stride_lon]
            v_ = v[::stride_lat, ::stride_lon]
            # sparse polar area
            sparse_polar_grids = kw.pop('sparse_polar_grids', True)
            if sparse_polar_grids:
                msk = np.empty(u_.shape) * np.nan
                for i in range(lat_.size):
                    step = int(1. / np.cos(lat_[i] * np.pi / 180))
                    msk[i, 0::step] = 0
                u_ += msk
                v_ += msk
            Lon_, Lat_ = np.meshgrid(lon_, lat_)
            u_rot, v_rot, X_, Y_ = m.rotate_vector(u_,
                                                   v_,
                                                   Lon_,
                                                   Lat_,
                                                   returnxy=True)
        else:  # use nGrids, nx, ny to control the quiver grids
            if lon.max() > 180:
                u_, lon_ = shiftgrid(180., u, lon, start=False)
                v_, lon_ = shiftgrid(180., v, lon, start=False)
            else:
                u_ = u
                v_ = v
                lon_ = lon
            u_rot, v_rot, X_, Y_ = m.transform_vector(u_,
                                                      v_,
                                                      lon_,
                                                      lat,
                                                      nx,
                                                      ny,
                                                      returnxy=True)
        quiver_color = kw.pop('quiver_color', 'g')
        quiver_scale = kw.pop('quiver_scale', None)
        hide_qkey = kw.pop('hide_qkey', False)
        qkey_kw = kw.pop('qkey_kw', {})
        qkey_X = kw.pop('qkey_X', 0.85)
        qkey_X = qkey_kw.pop('X', qkey_X)
        qkey_Y = kw.pop('qkey_Y', 1.02)
        qkey_Y = qkey_kw.pop('Y', qkey_Y)
        qkey_U = kw.pop('qkey_U', 2)
        qkey_U = qkey_kw.pop('U', qkey_U)
        qkey_label = kw.pop('qkey_label', '{:g} '.format(qkey_U) + units)
        qkey_label = qkey_kw.pop('label', qkey_label)
        qkey_labelpos = kw.pop('qkey_labelpos', 'W')
        qkey_labelpos = qkey_kw.pop('labelpos', qkey_labelpos)
        plot_obj = m.quiver(X_,
                            Y_,
                            u_rot,
                            v_rot,
                            color=quiver_color,
                            scale=quiver_scale,
                            **kw)
        if not hide_qkey:
            # quiverkey plot
            plt.quiverkey(plot_obj,
                          qkey_X,
                          qkey_Y,
                          qkey_U,
                          label=qkey_label,
                          labelpos=qkey_labelpos,
                          **qkey_kw)

    # hatch plot
    elif plot_type in ('hatch', 'hatches'):
        hatches = kw.pop('hatches', ['///'])
        plot_obj = m.contourf(X,
                              Y,
                              data,
                              colors='none',
                              hatches=hatches,
                              extend='both',
                              **kw)
    else:
        print(
            'Please choose a right plot_type from ("pcolor", "contourf", "contour")!'
        )

    # set clim
    if plot_type in ('pcolor', 'pcolormesh', 'imshow'):
        plt.clim(clim)

    # plot colorbar
    if plot_type in ('pcolor', 'pcolormesh', 'contourf', 'contourf+',
                     'imshow'):
        ax_current = plt.gca()
        divider = make_axes_locatable(ax_current)
        cax = divider.append_axes(cbar_position, size=cbar_size, pad=cbar_pad)
        cbar = plt.colorbar(plot_obj,
                            cax=cax,
                            extend=cbar_extend,
                            orientation=cbar_orientation,
                            **cbar_kw)
        if cbar_type in ('v', 'vertical'):
            # put the units on the top of the vertical colorbar
            cbar.ax.xaxis.set_label_position('top')
            cbar.ax.set_xlabel(units)
            cbar.ax.set_ylabel(long_name)
        elif cbar_type in ('h', 'horizontal'):
            # cbar.ax.yaxis.set_label_position('right')
            # cbar.ax.set_ylabel(units, rotation=0, ha='left', va='center')
            if long_name == '' or units == '':
                cbar.ax.set_xlabel('{}{}'.format(long_name, units))
            else:
                cbar.ax.set_xlabel('{} [{}]'.format(long_name, units))
        # remove the colorbar to avoid repeated colorbars
        if hide_cbar:
            cbar.remove()
        # set back the main axes as the current axes
        plt.sca(ax_current)

    return plot_obj
Esempio n. 38
0
def draw_wind(m, lons, lats,
              model, dsize, background,
              location, lat, lon,
              RUNDATE, VALIDDATE, fxx,
              alpha, half_box, barb_thin,
              level='10 m',
              Fill=False,
              Shade=False,
              Barbs=False,
              Quiver=False,
              p95=False,
              Convergence=False,
              Vorticity=False):
    """
    wind speed, wind barbs, wind quiver, Convergence, Divergence,
    shade high wind area, wind speed 95th percentile exceedance
    """
    LEVEL = level.replace(' ', '')

    H_UV = get_hrrr_variable(RUNDATE, 'UVGRD:%s' % level,
                             model=model, fxx=fxx,
                             outDIR='/uufs/chpc.utah.edu/common/home/u0553130/temp/',
                             verbose=False, value_only=False)
    
    if Fill:
        m.pcolormesh(lons, lats, H_UV['SPEED'],
                     latlon=True,
                     cmap=cm_wind(),
                     vmin=0, vmax=60,
                     zorder=2,
                     alpha=alpha)
        cb = plt.colorbar(orientation='horizontal', pad=pad, shrink=shrink, extend='max')
        cb.set_label(r'%s Wind Speed (m s$\mathregular{^{-1}}$)' % level)

    if Shade:
            m.contourf(lons, lats, H_UV['SPEED'],
                       levels=[10, 15, 20, 25],
                       colors=('yellow', 'orange', 'red'),
                       alpha=alpha,
                       extend='max',
                       zorder=3,
                       latlon=True)
            cb = plt.colorbar(orientation='horizontal', shrink=shrink, pad=pad)
            cb.set_label(r'%s Wind Speed (ms$\mathregular{^{-1}}$)' % level)

    if Barbs or Quiver:
        if level == '10 m':
            color = 'k'
        elif level == '80 m':
            color = 'darkred'
        elif level == '500 mb':
            color = 'navy'
        else:
            color='k'

        # For small domain plots, trimming the edges significantly reduces barb plotting time
        if barb_thin < 20:
            subset = hrrr_subset(H_UV, half_box=half_box, lat=lat, lon=lon, verbose=False)
        else:
            subset = H_UV

        # Need to rotate vectors for map projection
        subset['UGRD'], subset['VGRD'] = m.rotate_vector(subset['UGRD'], subset['VGRD'], subset['lon'], subset['lat'])

        thin = barb_thin
        # Add to plot
        if Barbs:
            m.barbs(subset['lon'][::thin,::thin], subset['lat'][::thin,::thin],
                    subset['UGRD'][::thin,::thin], subset['VGRD'][::thin,::thin],
                    zorder=10, length=5.5, color=color,
                    barb_increments={'half':2.5, 'full':5,'flag':25},
                    latlon=True)

        if Quiver:
            Q = m.quiver(subset['lon'][::thin,::thin], subset['lat'][::thin,::thin],
                         subset['UGRD'][::thin,::thin], subset['VGRD'][::thin,::thin],
                         zorder=10,
                         units='inches',
                         scale=40, color=color,
                         latlon=True)    
            qk = plt.quiverkey(Q, .92, 0.07, 10, r'10 s$^{-1}$',
                            labelpos='S',
                            coordinates='axes',
                            color='magenta')
            qk.text.set_backgroundcolor('w')

    if p95:
        DIR = '/uufs/chpc.utah.edu/common/home/horel-group8/blaylock/HRRR_OSG/hourly30/UVGRD_%s/' % level.replace(' ', '_')
        FILE = 'OSG_HRRR_%s_m%02d_d%02d_h%02d_f00.h5' % (('UVGRD_%s' % level.replace(' ', '_'), VALIDDATE.month, VALIDDATE.day, VALIDDATE.hour))
        with h5py.File(DIR+FILE, 'r') as f:
            spd_p95 = f["p95"][:]
        masked = H_UV['SPEED']-spd_p95
        masked = np.ma.array(masked)
        masked[masked < 0] = np.ma.masked
        
        m.pcolormesh(lons, lats, masked,
                     vmax=10, vmin=0,
                     latlon=True,
                     zorder=9,
                     cmap='viridis',
                     alpha=alpha)
        cb = plt.colorbar(orientation='horizontal', pad=pad, shrink=shrink)
        cb.set_label(r'%s Wind Speed exceeding 95th Percentile (m s$\mathregular{^{-1}}$)' % level)

    if Convergence or Vorticity:
        
        dudx, dudy = np.gradient(H_UV['UGRD'], 3, 3)
        dvdx, dvdy = np.gradient(H_UV['VGRD'], 3, 3)
        
        if Vorticity:
            vorticity = dvdx - dudy
            # Mask values
            vort = vorticity
            vort = np.ma.array(vort)
            vort[np.logical_and(vort < .05, vort > -.05) ] = np.ma.masked

            m.pcolormesh(lons, lats, vort,
                        latlon=True, cmap='bwr',
                        zorder=8,
                        vmax=np.max(vort),
                        vmin=-np.max(vort))
            cb = plt.colorbar(orientation='horizontal', pad=pad, shrink=shrink)
            cb.set_label(r'%s Vorticity (s$\mathregular{^{-1}}$)' % level)
        if Convergence:
            convergence = dudx + dvdy
            # Mask values
            conv = convergence
            conv = np.ma.array(conv)
            conv[np.logical_and(conv < .05, conv > -.05) ] = np.ma.masked

            m.pcolormesh(lons, lats, conv,
                        latlon=True, cmap='bwr',
                        zorder=8,
                        vmax=np.max(conv),
                        vmin=-np.max(conv))
            cb = plt.colorbar(orientation='horizontal', pad=pad, shrink=shrink)
            cb.set_label(r'%s Convergence (s$\mathregular{^{-1}}$)' % level)
Esempio n. 39
0
v = np.ma.masked_where(np.abs(v) >= 999, v)
x = f.variables['lon'][:]
y = f.variables['lat'][:]
vel = np.sqrt(u * u + v * v, where=(np.ma.getmaskarray(u) == False))

f.close()
# -

# ## Using colormap

plt.figure()
q = plt.quiver(x, y, u, v, vel, cmap=plt.cm.get_cmap('hsv'), scale=1000)
q.set_clim(0, 50)
cb = plt.colorbar(q)
cb.set_label('Wind speed (m/s)')
plt.show()

# ## Using reference arrow
#
# Adding a reference arrow is done by using the [quiverkey](https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.quiverkey.html) function

plt.figure()
q = plt.quiver(x, y, u, v, scale=1000)
keys = plt.quiverkey(q,
                     -131,
                     21,
                     70,
                     'Wind speed\n(50 m/s)',
                     coordinates='data')
plt.show()
Esempio n. 40
0
def main():

    source_all = [
        'f4\\W3Main', 'f5\\W3OH', 'f6\\L1448I', 'f7\\L1448N', 'f8\\L1448C',
        'f9\\L1445', 'f10\\IRAS2A', 'f11\\SVS13', 'f12\\IRAS4A', 'f13\\IRAS4B',
        'f14\\HH211', 'f15\\DGTau', 'f16\\L1551', 'f17\\L1527', 'f18\\CB26',
        'f19\\OrionKL', 'f20\\MMS5', 'f20\\MMS6', 'f21\\FIR4', 'f23\\VLA1623',
        'f24\\SerEmb17', 'f26\\SerEmb8', 'f27\\SerEmb6', 'f31\\B335',
        'f32\\DR21OH', 'f33\\L1157', 'f34\\CB230'
    ]

    for ii in range(len(source_all)):
        try:
            tapol, scuba, hertz, sharp, Idust, xx, yy = take_data(
                source_all[ii])
            Imax = max((Idust[0].data[0, 0, :, :]).flatten())
            center = numpy.where(Idust[0].data[0, 0, :, :] == Imax)
            f, (ax1, ax2) = plt.subplots(1, 2, figsize=(60, 20))

            tap = range(len(tapol[0]))
            for i in range(len(tapol[0])):
                tap[i] = numpy.sqrt((tapol[0][i] - xx[center[0]])**2.0 +
                                    (tapol[1][i] - yy[center[1]])**2.0)
            ax1.scatter(tap, tapol[4], color='b', label='tapol')
            if scuba != []:
                scu = range(len(scuba[0]))
                for i in range(len(scuba[0])):
                    scu[i] = numpy.sqrt((scuba[0][i] - xx[center[0]])**2.0 +
                                        (scuba[1][i] - yy[center[1]])**2.0)
                ax1.scatter(scu, scuba[3], color='r', label='scuba')
            if hertz != []:
                her = range(len(hertz[0]))
                for j in range(len(hertz[0])):
                    her[j] = numpy.sqrt((hertz[0][j] - xx[center[0]])**2.0 +
                                        (hertz[1][j] - yy[center[1]])**2.0)
                ax1.scatter(her, hertz[3], color='y', label='hertz')

            if sharp != []:
                sha = range(len(sharp[0]))
                for k in range(len(sharp[0])):
                    sha[k] = numpy.sqrt((sharp[0][k] - xx[center[0]])**2.0 +
                                        (sharp[1][k] - yy[center[1]])**2.0)
                ax1.scatter(sha, sharp[3], color='g', label='sharp')
            ax1.legend()

            xx_dust, yy_dust = a.sky_coor(Idust)
            ax2.contourf(Idust[0].data[0, 0, :, ::-1],
                         extent=[
                             max(xx_dust),
                             min(xx_dust),
                             min(yy_dust),
                             max(yy_dust)
                         ],
                         origin='lower',
                         aspect='auto')
            #            qv1 = ax2.quiver(-tapol[0],tapol[1],-tapol[4]*numpy.sin(tapol[6]*numpy.pi/180.0),tapol[4]*numpy.cos(tapol[6]*numpy.pi/180.0),headwidth=0,width=0.001,scale=100,color='w',pivot='middle')
            qv1 = ax2.quiver(-tapol[0],
                             tapol[1],
                             -tapol[2] *
                             numpy.sin(tapol[6] * numpy.pi / 180.0),
                             tapol[2] * numpy.cos(tapol[6] * numpy.pi / 180.0),
                             headwidth=0,
                             width=0.001,
                             scale=100,
                             color='w',
                             pivot='middle')

            plt.quiverkey(qv1, 0.2, 0.2, 4, '4% Tapol')

            if scuba != []:
                qv2 = ax2.quiver(
                    -scuba[0],
                    scuba[1],
                    -scuba[3] * numpy.sin(scuba[5] * numpy.pi / 180.0),
                    scuba[3] * numpy.cos(scuba[5] * numpy.pi / 180.0),
                    headwidth=0,
                    width=0.001,
                    color='r',
                    scale=100,
                    pivot='middle')
                plt.quiverkey(qv2, 0.2, 0.15, 4, '4% Scuba')
            if hertz != []:
                qv3 = ax2.quiver(
                    -hertz[0],
                    hertz[1],
                    -hertz[3] * numpy.sin(hertz[5] * numpy.pi / 180.0),
                    hertz[3] * numpy.cos(hertz[5] * numpy.pi / 180.0),
                    headwidth=0,
                    width=0.001,
                    color='y',
                    scale=100,
                    pivot='middle')
                plt.quiverkey(qv3, 0.2, 0.1, 4, '4% Hertz')
            if sharp != []:
                qv4 = ax2.quiver(
                    -sharp[0],
                    sharp[1],
                    -sharp[3] * numpy.sin(sharp[5] * numpy.pi / 180.0),
                    sharp[3] * numpy.cos(sharp[5] * numpy.pi / 180.0),
                    headwidth=0,
                    width=0.001,
                    color='g',
                    scale=100,
                    pivot='middle')
                plt.quiverkey(qv4, 0.2, 0.05, 4, '4% Sharp')

            if ii > 4:
                plt.savefig(source_all[ii][4:] + '_vector.png')
                plt.clf()
            else:
                plt.savefig(source_all[ii][3:] + '_vector.png')
                plt.clf()
        except:
            print 'except', source_all[ii]
Esempio n. 41
0
def trend_all():

    srfc = cnst.ERA_MONTHLY_SRFC_SYNOP
    pl = cnst.ERA_MONTHLY_PL_SYNOP
    storm_mean = 'aggs/gridsat_WA_-65_monthly_count_-40base_15-21UTC_1000km2.nc'
    storm_extreme = 'aggs/gridsat_WA_-70_monthly_count_5000km2.nc'
    mcs = cnst.GRIDSAT + storm_extreme

    fpath = cnst.network_data + 'figs/CLOVER/months/'

    box = [5, 55, -36, 0]  #  [-18,40,0,25] #

    da = xr.open_dataset(pl)
    da = u_darrays.flip_lat(da)
    da = da.sel(longitude=slice(box[0], box[1]),
                latitude=slice(box[2], box[3]))
    da2 = xr.open_dataset(srfc)
    da2 = u_darrays.flip_lat(da2)
    da2 = da2.sel(longitude=slice(box[0], box[1]),
                  latitude=slice(box[2], box[3]))
    da3 = xr.open_dataset(mcs)
    da3 = da3.sel(lon=slice(box[0], box[1]), lat=slice(box[2], box[3]))

    lons = da.longitude
    lats = da.latitude

    press = da2['sp']
    press = press[press['time.hour'] == 12]
    press.values = press.values * 1000
    low_press = 850
    up_press = 550

    q = da['q'].sel(level=slice(low_press - 100, low_press)).mean('level')
    q = q[q['time.hour'] == 12]
    t2d = da2['t2m']  #['t2m']
    #t2d = da['t'].sel(level=slice(800, 850)).mean('level')
    t2d = t2d[t2d['time.hour'] == 12]

    u600 = da['u'].sel(level=slice(up_press - 100, up_press)).mean('level')
    u600 = u600[u600['time.hour'] == 12]
    v600 = da['v'].sel(level=slice(up_press - 100, up_press)).mean('level')
    v600 = v600[v600['time.hour'] == 12]

    ws600 = u_met.u_v_to_ws_wd(u600, v600)

    u800 = da['u'].sel(level=slice(low_press - 100, low_press)).mean('level')
    u800 = u800[u800['time.hour'] == 12]

    v800 = da['v'].sel(level=slice(low_press - 100, low_press)).mean('level')
    v800 = v800[v800['time.hour'] == 12]

    shear_u = u600 - u800  #u600-
    shear_v = v600 - v800  # v600-

    ws_shear = u_met.u_v_to_ws_wd(shear_u.values, shear_v.values)

    ws_600 = t2d.copy(deep=True)
    ws_600.name = 'ws'
    ws_600.values = ws600[0]

    shear = t2d.copy(deep=True)
    shear.name = 'shear'
    shear.values = ws_shear[0]

    u6 = u800
    v6 = v800  # wind vectors

    q.values = q.values * 1000

    grid = t2d.salem.grid.regrid(factor=0.25)
    t2 = t2d  # grid.lookup_transform(t2d)
    tir = grid.lookup_transform(da3['tir'])

    grid = grid.to_dataset()
    tir = xr.DataArray(tir,
                       coords=[da3['time'], grid['y'], grid['x']],
                       dims=['time', 'latitude', 'longitude'])

    months = [
        (11, 1), 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12
    ]  #, 2,3,10]#[(12,2)]#[1,2,3,4,5,6,7,8,9,10,11,12]# #,2,3,11,12]#[(12,2)]#[1,2,3,4,5,6,7,8,9,10,11,12]# #,2,3,11,12]

    dicm = {}
    dicmean = {}

    for m in months:
        method = 'mk'

        if type(m) == int:
            m = [m]

        sig = True

        t2trend, t2mean = calc_trend(t2,
                                     m,
                                     method=method,
                                     sig=sig,
                                     hour=12,
                                     wilks=False)  #hour=12,
        t2_mean = t2mean.mean(axis=0)

        tirtrend, tirmean = calc_trend(tir,
                                       m,
                                       method=method,
                                       sig=sig,
                                       wilks=False)

        tirm_mean = tirmean.mean(axis=0)

        qtrend, qmean = calc_trend(q,
                                   m,
                                   method=method,
                                   sig=sig,
                                   hour=12,
                                   wilks=False)  #hour=12,
        q_mean = qmean.mean(axis=0)

        sheartrend, shearmean = calc_trend(shear,
                                           m,
                                           method=method,
                                           sig=sig,
                                           hour=12,
                                           wilks=False)  #hour=12,
        shear_mean = shearmean.mean(axis=0)

        u6trend, u6mean = calc_trend(u6,
                                     m,
                                     method=method,
                                     sig=sig,
                                     hour=12,
                                     wilks=False)  #hour=12,
        u6_mean = u6mean.mean(axis=0)
        v6trend, v6mean = calc_trend(v6,
                                     m,
                                     method=method,
                                     sig=sig,
                                     hour=12,
                                     wilks=False)  #hour=12,
        v6_mean = v6mean.mean(axis=0)

        t2trend_unstacked = t2trend * 10.  # warming over decade
        qtrend_unstacked = qtrend * 10.  # warming over decade
        sheartrend_unstacked = sheartrend * 10.  # warming over decade
        u6trend_unstacked = u6trend * 10
        v6trend_unstacked = v6trend * 10

        tirtrend_unstacked = (
            (tirtrend.values) * 10. / tirm_mean.values) * 100.

        tirtrend_out = xr.DataArray(tirtrend_unstacked,
                                    coords=[grid['y'], grid['x']],
                                    dims=['latitude', 'longitude'])
        tirmean_out = xr.DataArray(tirm_mean,
                                   coords=[grid['y'], grid['x']],
                                   dims=['latitude', 'longitude'])

        dicm[m[0]] = tirtrend_out
        dicmean[m[0]] = tirmean_out

        t_da = t2trend_unstacked
        q_da = qtrend_unstacked
        s_da = sheartrend_unstacked
        ti_da = tirtrend_unstacked

        if len(m) == 1:
            fp = fpath + 'trend_synop_-70C5000_trend_' + str(
                m[0]).zfill(2) + '.png'
        else:
            fp = fpath + 'trend_synop_-70C5000_trend_' + str(
                m[0]).zfill(2) + '-' + str(m[1]).zfill(2) + '.png'
        map = t2d.salem.get_map()

        f = plt.figure(figsize=(15, 8), dpi=300)

        # transform their coordinates to the map reference system and plot the arrows
        xx, yy = map.grid.transform(shear.longitude.values,
                                    shear.latitude.values,
                                    crs=shear.salem.grid.proj)

        xx, yy = np.meshgrid(xx, yy)
        #Quiver only every 7th grid point
        u = u6trend_unstacked.values[1::2, 1::2]
        v = v6trend_unstacked.values[1::2, 1::2]

        #Quiver only every 7th grid pointtr
        uu = u6_mean.values[1::2, 1::2]
        vv = v6_mean.values[1::2, 1::2]

        xx = xx[1::2, 1::2]
        yy = yy[1::2, 1::2]

        ax1 = f.add_subplot(221)
        map.set_data(t_da.values, interp='linear')  # interp='linear'

        map.set_contour((t2_mean.values - 273.15).astype(np.float64),
                        interp='linear',
                        colors='k',
                        linewidths=0.5,
                        levels=[20, 23, 26, 29, 32, 35])
        map.set_plot_params(levels=[
            -0.5, -0.4, -0.3, -0.2, -0.1, -0.05, -0.02, 0.02, 0.05, 0.1, 0.2,
            0.3, 0.4, 0.5
        ],
                            cmap='RdBu_r',
                            extend='both')  # levels=np.arange(-0.5,0.51,0.1),

        #map.set_contour((t2_mean.values).astype(np.float64), interp='linear', colors='k', linewidths=0.5, levels=np.linspace(800,925,8))
        #map.set_plot_params(levels=[-0.5,-0.4,-0.3,-0.2,-0.1,-0.05,-0.02, 0.02,0.05,0.1,0.2,0.3,0.4,0.5], cmap='RdBu_r', extend='both')  # levels=np.arange(-0.5,0.51,0.1),

        dic = map.visualize(ax=ax1,
                            title='2m temperature trend | contours: mean T',
                            cbar_title='K decade-1')
        qu = ax1.quiver(xx, yy, uu, vv, scale=40, width=0.002)  # 80

        qk = plt.quiverkey(qu,
                           0.4,
                           0.03,
                           4,
                           '4 m s$^{-1}$',
                           labelpos='E',
                           coordinates='figure')

        contours = dic['contour'][0]
        plt.clabel(contours, inline=True, fontsize=7, fmt='%1.1f')

        ax2 = f.add_subplot(222)
        map.set_data(q_da.values, interp='linear')  # interp='linear'
        map.set_contour((q_mean.values).astype(np.float64),
                        interp='linear',
                        colors='k',
                        levels=[6, 8, 10, 12, 14, 16],
                        linewidths=0.5)
        map.set_plot_params(levels=[
            -0.4, -0.3, -0.2, -0.1, -0.05, -0.02, 0.02, 0.05, 0.1, 0.2, 0.3,
            0.4
        ],
                            cmap='RdBu',
                            extend='both')  # levels=np.arange(-0.5,0.51,0.1),

        dic = map.visualize(
            ax=ax2,
            title='800hPa Spec. humidity trend | contours: mean q',
            cbar_title='g kg-1 decade-1')
        contours = dic['contour'][0]
        plt.clabel(contours, inline=True, fontsize=7, fmt='%1.1f')

        ax3 = f.add_subplot(223)
        map.set_data(s_da.values, interp='linear')  # interp='linear'
        map.set_contour(s_da.values,
                        interp='linear',
                        levels=np.arange(-7, 7, 8),
                        cmap='Blues')

        map.set_plot_params(levels=[
            -0.5, -0.4, -0.3, -0.2, -0.1, -0.05, -0.02, 0.02, 0.05, 0.1, 0.2,
            0.3, 0.4, 0.5
        ],
                            cmap='RdBu_r',
                            extend='both')  # levels=np.arange(-0.5,0.51,0.1)
        map.visualize(
            ax=ax3,
            title='800-500hPa wind shear trend, mean 850hPa wind vector trends',
            cbar_title='m s-1 decade-1')
        qu = ax3.quiver(xx, yy, u, v, scale=40, width=0.002)  # 80

        qk = plt.quiverkey(qu,
                           0.4,
                           0.03,
                           4,
                           '4 m s$^{-1}$',
                           labelpos='E',
                           coordinates='figure')

        ax4 = f.add_subplot(224)
        map.set_contour((tirm_mean.values).astype(np.float64),
                        interp='linear',
                        levels=[0.1, 0.5, 1, 2.5],
                        colors='k',
                        linewidths=0.5)

        ti_da[ti_da == 0] = np.nan
        map.set_data(ti_da)  #
        coord = [18, 25, -28, -20]
        geom = shpg.box(coord[0], coord[2], coord[1], coord[3])
        #map.set_geometry(geom, zorder=99, color='darkorange', linewidth=3, linestyle='--', alpha=0.3)

        map.set_plot_params(
            cmap='viridis', extend='both', levels=np.arange(
                10, 41,
                10))  # levels=np.arange(20,101,20)  #np.arange(20,101,20)
        dic = map.visualize(ax=ax4,
                            title='-65C cloud cover change | >1000km2 -40C',
                            cbar_title='$\%$ decade-1')
        contours = dic['contour'][0]
        plt.clabel(contours, inline=True, fontsize=7, fmt='%1.1f')

        plt.tight_layout()
        plt.savefig(fp)
        plt.close('all')

    pkl.dump(
        dicm,
        open(
            cnst.network_data + 'data/CLOVER/saves/storm_frac_synop12UTC_SA.p',
            'wb'))

    pkl.dump(
        dicmean,
        open(
            cnst.network_data +
            'data/CLOVER/saves/storm_frac_mean_synop12UTC_SA.p', 'wb'))
Esempio n. 42
0
pijd0 = 1

X, Y = np.meshgrid(np.arange(0, 5.2, step), np.arange(0, 4, step))
# others = [[1, 1], [1, 2], [2.732, 1], [2.732, 2]]
# others = [[1, 1], [1+1.732/2, 1.5], [2.732, 1]]
others = [[2, 2], [3, 2]]
U = 0
V = 0
for robot in others:
    pijx = X - robot[0]
    pijy = Y - robot[1]
    pij0 = (pijx**2 + pijy**2)**0.5  # the norm of pij
    pij0 = np.where(pij0 < 1e-4, 1, pij0)

    tauij0 = 2 * (pij0**4 - pijd0**4) / pij0**3

    U += tauij0 * pijx / pij0
    V += tauij0 * pijy / pij0

U, V = saturate(U * K3, V * K3, 0.7)
plt.figure()
plt.title('Vector field')
Q = plt.quiver(X, Y, U, V, units='width')
qk = plt.quiverkey(Q,
                   0.9,
                   0.9,
                   2,
                   r'$2 \frac{m}{s}$',
                   labelpos='E',
                   coordinates='figure')
plt.axes().set_aspect('equal', 'datalim')
Esempio n. 43
0
def show_image(wavelength,
               parfilename=None,
               par=None,
               dir="./",
               overplot=False,
               inclination=80,
               cmap=None,
               ax=None,
               polarization=False,
               polfrac=False,
               psf_fwhm=None,
               vmin=None,
               vmax=None):
    """ Show one image from an MCFOST model

    Parameters
    ----------
    wavelength : string
        note this is a string!! in microns. TBD make it take strings or floats
    inclination : float
        Which inclination to plot, in the case where there are multiple images? For RT computations
        with just one, then this parameter is essentially ignored
    overplot : bool
        Should we overplot on current axes (True) or display a new figure? Default is False
    cmap : matplotlib Colormap instance
        Color map to use for display.
    ax : matplotlib Axes instance
        Axis to display into.
    vmin, vmax :    scalars
        Min and max values for image display. Always shows in log stretch
    psf_fwhm : float or None 
        convolve with PSF of this FWHM? Default is None for no convolution
    parfilename : string, optional
    par : dict, optional
    dir :  string

    """
    if not overplot:
        if ax is None: plt.clf()
        else: plt.cla()

    if ax is None: ax = plt.gca()
    if par is None:
        par = paramfiles.Paramfile(parfilename, dir)
    if cmap is None:
        cmap = plt.cm.gist_heat
        cmap = plt.cm.gist_gray
        cmap.set_over('white')
        cmap.set_under('black')
        cmap.set_bad('black')

    rt_im = fits.getdata(dir + os.sep + "data_" + wavelength + os.sep +
                         "RT.fits.gz")
    inclin_index = _find_closest(par.im_inclinations, inclination)
    #print "using image %s, inc=%f" % (  str(inclin_index), par['im:inclinations'][inclin_index]  )

    #ax = plt.subplot(151)
    image = rt_im[0, 0, inclin_index, :, :]
    if vmax is None:
        #image.shape = image.shape[2:] # drop leading zero-length dimensions...
        vmax = image.max()
    if vmin is None:
        vmin = vmax / 1e8
    norm = matplotlib.colors.LogNorm(vmin=vmin, vmax=vmax, clip=True)

    if psf_fwhm is not None:
        raise NotImplementedError("This code not yet implemented")
        import optics
        #psf = optics.airy_2d(aperture=10.0, wavelength=1.6e-6, pixelscale=0.020, shape=(99,99))
        psf = pyfits.getdata(
            '/Users/mperrin/Dropbox/AAS2013/models_pds144n/manual/keck_psf_tmp4.fits'
        )
        from astropy.nddata import convolve
        convolved = convolve(image, psf, normalize_kernel=True)

        image = convolved

    if polfrac:
        ax = plt.subplot(121)

    ax = utils.imshow_with_mouseover(ax, image, norm=norm, cmap=cmap)
    ax.set_xlabel("Offset [pix]")
    ax.set_ylabel("Offset [pix]")
    ax.set_title(wavelength + " $\mu$m")

    if polarization == True:

        # dont' show every pixel's vectors:
        showevery = 5

        imQ = rt_im[
            1, 0,
            inclin_index, :, :] * -1  #MCFOST sign convention requires flip for +Q = up
        imU = rt_im[2, 0, inclin_index, :, :] * -1  #MCFOST sign convention

        imQn = imQ / image
        imUn = imU / image
        polfrac_ar = np.sqrt(imQn**2 + imUn**2)
        theta = 0.5 * np.arctan2(imUn, imQn) + np.pi / 2
        vecX = polfrac_ar * np.cos(theta) * -1
        vecY = polfrac_ar * np.sin(theta)

        Y, X = np.indices(image.shape)
        Q = plt.quiver(X[::showevery, ::showevery],
                       Y[::showevery, ::showevery],
                       vecX[::showevery, ::showevery],
                       vecY[::showevery, ::showevery],
                       headwidth=0,
                       headlength=0,
                       headaxislength=0.0,
                       pivot='middle',
                       color='white')
        plt.quiverkey(Q,
                      0.85,
                      0.95,
                      0.5,
                      "50% pol.",
                      coordinates='axes',
                      labelcolor='white',
                      labelpos='E',
                      fontproperties={'size': 'small'})  #, width=0.003)
        #        ax = plt.subplot(152)
        #        ax.imshow(imQn, vmin=-1, vmax=1, cmap=matplotlib.cm.RdBu)
        #        ax.set_title('Q')
        #        ax = plt.subplot(153)
        #        ax.imshow(imUn, vmin=-1, vmax=1, cmap=matplotlib.cm.RdBu)
        #        ax.set_title('U')
        #        ax = plt.subplot(154)
        #        ax.imshow(vecX, vmin=-1, vmax=1, cmap=matplotlib.cm.RdBu)
        #        ax.set_title('vecX')
        #        ax = plt.subplot(155)
        #        ax.imshow(vecY, vmin=-1, vmax=1, cmap=matplotlib.cm.RdBu)
        #        ax.set_title('vecY')
        #        ax.colorbar()

        #plt.colorbar()

        if polfrac:
            ax2 = plt.subplot(122)

            cmap2 = plt.cm.gist_heat
            cmap2 = plt.cm.jet
            cmap2.set_over('red')
            cmap2.set_under('black')
            cmap2.set_bad('black')

            ax2 = imshow_with_mouseover(ax2,
                                        polfrac_ar,
                                        vmin=0,
                                        vmax=1,
                                        cmap=cmap2)
            ax2.set_title("Polarization fraction")

            cax = plt.axes([0.92, 0.25, 0.02, 0.5])
            plt.colorbar(ax2.images[0], cax=cax, orientation='vertical')
Esempio n. 44
0
bounds = np.linspace(np.min(anom_NDEFM_speed), np.max(anom_NDEFM_speed), 20)
bounds = np.around(bounds, decimals=2)
CF = map.contourf(x,
                  y,
                  anom_NDEFM_speed[:, :],
                  20,
                  norm=MidpointNormalize(midpoint=0),
                  cmap=plt.cm.RdYlBu_r)  #plt.cm.rainbow
cb = plt.colorbar(CF,
                  orientation='horizontal',
                  pad=0.05,
                  shrink=0.8,
                  boundaries=bounds)
cb.set_label('m/s')
Q = map.quiver(x[::2, ::2],
               y[::2, ::2],
               anom_NDEFM_u[::2, ::2],
               anom_NDEFM_v[::2, ::2],
               scale=150)
plt.quiverkey(Q, 0.93, 0.05, 10, '10 m/s')
ax.set_title('$Wind$ $Field$ $-$ $Winter$ $Anomalies$', size='15')

#map.plot(P_TT_lon, P_TT_lat, marker='D', color='w')
#map.plot(P_PP_lon, P_PP_lat, marker='D', color='w')
#map.plot(P_PN_lon, P_PN_lat, marker='D', color='w')
map.plot(TT_lon, TT_lat, marker=None, color='k')
map.plot(PP_lon, PP_lat, marker=None, color='k')
map.plot(PN_lon, PN_lat, marker=None, color='k')
map.fillcontinents(color='white')
plt.show()
def main():

# Plot diagnostics, model and pressure levels etc. to plot on for looping through

 plot_type='mean'
 plot_diags=['temp', 'sp_hum']
 plot_levels = [925, 850, 700, 500] 
 #plot_levels = [925]
 #experiment_ids = ['djznq', 'djzns', 'dklyu', 'dkmbq', 'dklwu', 'dklzq' ]
 experiment_ids = ['dkjxq']
#experiment_id = 'djzny'

 p_levels = [1000, 950, 925, 850, 700, 500, 400, 300, 250, 200, 150, 100, 70, 50, 30, 20, 10]


###### Unrotate global model data ##############################

######### Regrid to global, and difference  #######
############################################################################

## Load global wind and orography
 
 fw_global = '/nfs/a90/eepdw/Mean_State_Plot_Data/pp_files/djzn/djzny/30201_mean.pp'
 fo_global = '/nfs/a90/eepdw/Mean_State_Plot_Data/pp_files/djzn/djzny/33.pp'
    
 u_global,v_global = iris.load(fw_global)
 oro_global = iris.load_cube(fo_global)
    
# Unrotate global coordinates

 cs_glob = u_global.coord_system('CoordSystem')
 cs_glob_v = v_global.coord_system('CoordSystem')

 cs_glob_oro = oro_global.coord_system('CoordSystem')

 lat_g = u_global.coord('grid_latitude').points
 lon_g = u_global.coord('grid_longitude').points

 lat_g_oro = oro_global.coord('grid_latitude').points
 lon_g_oro = oro_global.coord('grid_longitude').points
    
 if cs_glob!=cs_glob_v:
    print 'Global model u and v winds have different poles of rotation'

# Unrotate global winds

 if isinstance(cs_glob, iris.coord_systems.RotatedGeogCS):
        print ' Global Model - Winds - djzny - Unrotate pole %s' % cs_glob
        lons_g, lats_g = np.meshgrid(lon_g, lat_g)
        lons_g,lats_g = iris.analysis.cartography.unrotate_pole(lons_g,lats_g, cs_glob.grid_north_pole_longitude, cs_glob.grid_north_pole_latitude)
        
        lon_g=lons_g[0]
        lat_g=lats_g[:,0]

 for i, coord in enumerate (u_global.coords()):
            if coord.standard_name=='grid_latitude':
                lat_dim_coord_uglobal = i
            if coord.standard_name=='grid_longitude':
                lon_dim_coord_uglobal = i

 csur_glob=cs_glob.ellipsoid
 u_global.remove_coord('grid_latitude')
 u_global.remove_coord('grid_longitude')
 u_global.add_dim_coord(iris.coords.DimCoord(points=lat_g, standard_name='grid_latitude', units='degrees', coord_system=csur_glob), lat_dim_coord_uglobal)
 u_global.add_dim_coord(iris.coords.DimCoord(points=lon_g, standard_name='grid_longitude', units='degrees', coord_system=csur_glob), lon_dim_coord_uglobal)

#print u_global
    
 v_global.remove_coord('grid_latitude')
 v_global.remove_coord('grid_longitude')
 v_global.add_dim_coord(iris.coords.DimCoord(points=lat_g, standard_name='grid_latitude', units='degrees', coord_system=csur_glob),  lat_dim_coord_uglobal)
 v_global.add_dim_coord(iris.coords.DimCoord(points=lon_g, standard_name='grid_longitude', units='degrees', coord_system=csur_glob),  lon_dim_coord_uglobal)
    
 #print v_global

# Unrotate global model

 if isinstance(cs_glob_oro, iris.coord_systems.RotatedGeogCS):
        print ' Global Model - Orography - djzny - Unrotate pole %s - Winds and other diagnostics may have different number of grid points' % cs_glob_oro
        lons_go, lats_go = np.meshgrid(lon_g_oro, lat_g_oro)
        lons_go,lats_go = iris.analysis.cartography.unrotate_pole(lons_go,lats_go, cs_glob_oro.grid_north_pole_longitude, cs_glob_oro.grid_north_pole_latitude)
        
        lon_g_oro=lons_go[0]
        lat_g_oro=lats_go[:,0]

 for i, coord in enumerate (oro_global.coords()):
            if coord.standard_name=='grid_latitude':
                lat_dim_coord_og = i
            if coord.standard_name=='grid_longitude':
                lon_dim_coord_og = i 

 csur_glob_oro=cs_glob_oro.ellipsoid
 oro_global.remove_coord('grid_latitude')
 oro_global.remove_coord('grid_longitude')
 oro_global.add_dim_coord(iris.coords.DimCoord(points=lat_g_oro, standard_name='grid_latitude', units='degrees', coord_system=csur_glob_oro), lat_dim_coord_og)
 oro_global.add_dim_coord(iris.coords.DimCoord(points=lon_g_oro, standard_name='grid_longitude', units='degrees', coord_system=csur_glob_oro), lon_dim_coord_og)

   ###############################################################################
####################  Load global heights and temp/sp_hum #####################

 
 f_glob_h = '/nfs/a90/eepdw/Mean_State_Plot_Data/Mean_Heights_Temps_etc/408_pressure_levels_interp_pressure_djzny_%s' % (plot_type)
 
######################################################################################
 with h5py.File(f_glob_h, 'r') as i:
     mh = i['%s' % plot_type]
     mean_heights_global = mh[. . .]

######################################################################################
## Loop through experiment id's ######################################################
 
    
 for  pl in plot_diags:
  plot_diag=pl

  f_glob_d = '/nfs/a90/eepdw/Mean_State_Plot_Data/Mean_Heights_Temps_etc/%s_pressure_levels_interp_djzny_%s' % (plot_diag, plot_type)
  
  with h5py.File(f_glob_d, 'r') as i:
   mg = i['%s' % plot_type]
   mean_var_global = mg[. . .]

  for experiment_id in experiment_ids:
    expmin1 = experiment_id[:-1]

 

    ###############################################################################
####################  Load global heights and temp/sp_hum #####################

    fname_h = '/nfs/a90/eepdw/Mean_State_Plot_Data/Mean_Heights_Temps_etc/408_pressure_levels_interp_pressure_%s_%s' % (experiment_id, plot_type)
    fname_d = '/nfs/a90/eepdw/Mean_State_Plot_Data/Mean_Heights_Temps_etc/%s_pressure_levels_interp_%s_%s' % (plot_diag, experiment_id, plot_type)
    # print fname_h
    # print fname_d
#  Height data file
    with h5py.File(fname_h, 'r') as i:
        mh = i['%s' % plot_type]
        mean_heights = mh[. . .]
    # print mean_heights.shape
    with h5py.File(fname_d, 'r') as i:
        mh = i['%s' % plot_type]
        mean_var = mh[. . .]
    # print mean_var.shape

    f_oro =  '/nfs/a90/eepdw/Mean_State_Plot_Data/pp_files/%s/%s/409.pp' % (expmin1, experiment_id)
    oro = iris.load_cube(f_oro)

    #print oro
    
    for i, coord in enumerate (oro.coords()):
        if coord.standard_name=='grid_latitude':
            lat_dim_coord_oro = i
        if coord.standard_name=='grid_longitude':
            lon_dim_coord_oro = i

    fu = '/nfs/a90/eepdw/Mean_State_Plot_Data/pp_files/%s/%s/30201_mean.pp' % (expmin1, experiment_id)
       
    u_wind,v_wind = iris.load(fu)
    
# Wind may have different number of grid points so need to do unrotate again for wind grid points

    lat_w = u_wind.coord('grid_latitude').points
    lon_w = u_wind.coord('grid_longitude').points
    p_levs = u_wind.coord('pressure').points

    lat = oro.coord('grid_latitude').points
    lon = oro.coord('grid_longitude').points
    

    cs_w = u_wind.coord_system('CoordSystem')
    cs = oro.coord_system('CoordSystem')

    if isinstance(cs_w, iris.coord_systems.RotatedGeogCS):
        print ' Wind - %s - Unrotate pole %s' % (experiment_id, cs_w)
        lons_w, lats_w = np.meshgrid(lon_w, lat_w)
        lons_w,lats_w = iris.analysis.cartography.unrotate_pole(lons_w,lats_w, cs_w.grid_north_pole_longitude, cs_w.grid_north_pole_latitude)
        
        lon_w=lons_w[0]
        lat_w=lats_w[:,0]

        csur_w=cs_w.ellipsoid

        for i, coord in enumerate (u_wind.coords()):
            if coord.standard_name=='grid_latitude':
                lat_dim_coord_uwind = i
            if coord.standard_name=='grid_longitude':
                lon_dim_coord_uwind = i
       
        u_wind.remove_coord('grid_latitude')
        u_wind.remove_coord('grid_longitude')
        u_wind.add_dim_coord(iris.coords.DimCoord(points=lat_w, standard_name='grid_latitude', units='degrees', coord_system=csur_w),lat_dim_coord_uwind )
        u_wind.add_dim_coord(iris.coords.DimCoord(points=lon_w, standard_name='grid_longitude', units='degrees', coord_system=csur_w), lon_dim_coord_uwind)

        v_wind.remove_coord('grid_latitude')
        v_wind.remove_coord('grid_longitude')
        v_wind.add_dim_coord(iris.coords.DimCoord(points=lat_w, standard_name='grid_latitude', units='degrees', coord_system=csur_w), lat_dim_coord_uwind)
        v_wind.add_dim_coord(iris.coords.DimCoord(points=lon_w, standard_name='grid_longitude', units='degrees', coord_system=csur_w),lon_dim_coord_uwind )
        
    if isinstance(cs, iris.coord_systems.RotatedGeogCS):
        print ' 409.pp  - %s - Unrotate pole %s' % (experiment_id, cs)
        lons, lats = np.meshgrid(lon, lat) 

        lon_low= np.min(lons)
        lon_high = np.max(lons)
        lat_low = np.min(lats)
        lat_high = np.max(lats)

        lon_corners, lat_corners = np.meshgrid((lon_low, lon_high), (lat_low, lat_high))

        lons,lats = iris.analysis.cartography.unrotate_pole(lons,lats, cs.grid_north_pole_longitude, cs.grid_north_pole_latitude)
        lon_corner_u,lat_corner_u = iris.analysis.cartography.unrotate_pole(lon_corners, lat_corners, cs.grid_north_pole_longitude, cs.grid_north_pole_latitude)
        #lon_highu,lat_highu = iris.analysis.cartography.unrotate_pole(lon_high, lat_high, cs.grid_north_pole_longitude, cs.grid_north_pole_latitude)

        lon=lons[0]
        lat=lats[:,0]

        lon_low = lon_corner_u[0,0]
        lon_high = lon_corner_u[0,1]
        lat_low = lat_corner_u[0,0]
        lat_high = lat_corner_u[1,0]
                
        for i, coord in enumerate (oro.coords()):
            if coord.standard_name=='grid_latitude':
                lat_dim_coord_oro = i
            if coord.standard_name=='grid_longitude':
                lon_dim_coord_oro = i

        csur=cs.ellipsoid  
     
        oro.remove_coord('grid_latitude')
        oro.remove_coord('grid_longitude')
        oro.add_dim_coord(iris.coords.DimCoord(points=lat, standard_name='grid_latitude', units='degrees', coord_system=csur), lat_dim_coord_oro)
        oro.add_dim_coord(iris.coords.DimCoord(points=lon, standard_name='grid_longitude', units='degrees', coord_system=csur), lon_dim_coord_oro)

    else:

        lons, lats = np.meshgrid(lon, lat)
        lons_w, lats_w = np.meshgrid(lon_w, lat_w)

        lon_low= np.min(lons)
        lon_high = np.max(lons)
        lat_low = np.min(lats)
        lat_high = np.max(lats)
        


############## Regrid and Difference #################################

  # Regrid Height and Temp/Specific humidity to global grid
    h_regrid = np.empty((len(lat_g_oro), len(lon_g_oro)))
    v_regrid = np.empty((len(lat_g_oro), len(lon_g_oro)))

    for p in plot_levels:
  
        ### Search for pressure level match
    
        s = np.searchsorted(p_levels[::-1], p)
        h_regrid = scipy.interpolate.griddata((lats.flatten(),lons.flatten()),mean_heights[:,:,-(s+1)].flatten() , (lats_go,lons_go),method='linear')


        v_regrid = scipy.interpolate.griddata((lats.flatten(),lons.flatten()),mean_var[:,:,-(s+1)].flatten() , (lats_go,lons_go),method='linear')
   
# Difference heights

        plt_h = np.where(np.isnan(h_regrid), np.nan, h_regrid - mean_heights_global[:,:,-(s+1)])

#Difference temperature/specific humidity
   
        plt_v = np.where(np.isnan(v_regrid), np.nan, v_regrid - mean_var_global[:,:,-(s+1)])
    
    # Set u,v for winds, linear interpolate to approx. 2 degree grid
        sc =  np.searchsorted(p_levs, p)

                        
    ##### Does not work on iris1.0 as on Leeds computers. Does work on later versions

        #u_interp = u_wind[sc,:,:]
        #v_interp = v_wind[sc,:,:].
        #sample_points = [('grid_latitude', np.arange(lat_low,lat_high,2)), ('grid_longitude', np.arange(lon_low,lon_high,2))]

        #u = iris.analysis.interpolate.linear(u_interp, sample_points, extrapolation_mode='linear')
        #v = iris.analysis.interpolate.linear(v_interp, sample_points).data


    ##### Does work on Iris 1.0

        # 2 degree lats lon lists for wind regridding on plot

        lat_wind_1deg = np.arange(lat_low,lat_high, 2)
        lon_wind_1deg = np.arange(lon_low,lon_high, 2)

    ### Regrid winds to global, difference, and then regrid to 2 degree spacing

        fl_la_lo = (lats_w.flatten(),lons_w.flatten())

        # print u_wind[sc,:,:].data.flatten().shape

        u_wind_rg_to_glob = scipy.interpolate.griddata(fl_la_lo, u_wind[sc,:,:].data.flatten(), (lats_g, lons_g), method='linear')
        v_wind_rg_to_glob = scipy.interpolate.griddata(fl_la_lo, v_wind[sc,:,:].data.flatten(), (lats_g, lons_g), method='linear')

        u_w=u_wind_rg_to_glob-u_global[sc,:,:].data
        v_w=v_wind_rg_to_glob-v_global[sc,:,:].data

        #u_interp = u_wind[sc,:,:].data
        #v_interp = v_wind[sc,:,:].data
       
        lons_wi, lats_wi = np.meshgrid(lon_wind_1deg, lat_wind_1deg)

        fl_la_lo = (lats_g.flatten(),lons_g.flatten())

        u = scipy.interpolate.griddata(fl_la_lo, u_w.flatten(), (lats_wi, lons_wi), method='linear')
        v = scipy.interpolate.griddata(fl_la_lo, v_w.flatten(), (lats_wi, lons_wi), method='linear')
       


        
#######################################################################################

### Plotting #########################################################################

    

        #m_title = 'Height of %s-hPa level (m)' % (p)

# Set pressure height contour min/max
        if p == 925:
            clev_min = -24.
            clev_max = 24.
        elif p == 850:
            clev_min = -24.
            clev_max = 24.
        elif p == 700:
            clev_min = -24.
            clev_max = 24.
        elif p == 500:
            clev_min = -24.
            clev_max = 24.
        else:
            print 'Contour min/max not set for this pressure level'

# Set potential temperature min/max       
        if p == 925:
            clevpt_min = -10.
            clevpt_max = 10.
        elif p == 850:
            clevpt_min = -3.
            clevpt_max = 3.
        elif p == 700:
            clevpt_min = -3.
            clevpt_max = 3.
        elif p == 500:
            clevpt_min = -3.
            clevpt_max = 3.
        else:
            print 'Potential temperature min/max not set for this pressure level'

 # Set specific humidity min/max       
        if p == 925:
            clevsh_min = -0.0025
            clevsh_max = 0.0025
        elif p == 850:
            clevsh_min = -0.0025
            clevsh_max = 0.0025
        elif p == 700:
            clevsh_min = -0.0025
            clevsh_max = 0.0025
        elif p == 500:
            clevsh_min = -0.0025
            clevsh_max = 0.0025
        else:
            print 'Specific humidity min/max not set for this pressure level'

       #clevs_col = np.arange(clev_min, clev_max)
        clevs_lin = np.linspace(clev_min, clev_max, num=24)


        m =\
Basemap(llcrnrlon=lon_low,llcrnrlat=lat_low,urcrnrlon=lon_high,urcrnrlat=lat_high, rsphere = 6371229)

        #x, y = m(lons, lats)
        x,y = m(lons_go,lats_go)
        print x.shape
        x_w,y_w = m(lons_wi, lats_wi)
        fig=plt.figure(figsize=(8,8))
        ax = fig.add_axes([0.05,0.05,0.9,0.85], axisbg='#262626')

        m.drawcoastlines(color='#262626')  
        m.drawcountries(color='#262626')  
        m.drawcoastlines(linewidth=0.5)
        #m.fillcontinents(color='#CCFF99')
        m.drawparallels(np.arange(-80,81,10),labels=[1,1,0,0])
        m.drawmeridians(np.arange(0,360,10),labels=[0,0,0,1])
    
        cs_lin = m.contour(x,y, plt_h, clevs_lin,colors='#262626',linewidths=0.5)
       
        cmap=plt.cm.RdBu_r
        #cmap.set_bad('#262626', 1.)
        #cmap.set_over('#262626')
        #cmap.set_under('#262626')
        

        if plot_diag=='temp':
            
             plt_v = np.ma.masked_outside(plt_v, clevpt_max+20,  clevpt_min-20)

             cs_col = m.contourf(x,y, plt_v,  np.linspace(clevpt_min, clevpt_max), cmap=cmap, extend='both')
             
             cbar = m.colorbar(cs_col,location='bottom',pad="5%", format = '%d')  
             cbar.set_ticks(np.arange(clevpt_min,clevpt_max+2,2.))
             cbar.set_ticklabels(np.arange(clevpt_min,clevpt_max+2,2.))
             cbar.set_label('K')  
             plt.suptitle('Difference from global model (Model - global ) of Height, Potential Temperature and Wind Vectors  at %s hPa'% (p), fontsize=10)  

        elif plot_diag=='sp_hum':
             plt_v = np.ma.masked_outside(plt_v, clevsh_max+20,  clevsh_min-20)

             cs_col = m.contourf(x,y, plt_v,  np.linspace(clevsh_min, clevsh_max), cmap=cmap, extend='both')
             cbar = m.colorbar(cs_col,location='bottom',pad="5%", format = '%.3f') 
             cbar.set_label('kg/kg')
             
             plt.suptitle('Difference from global model (Model - Global Model ) of Height, Specific Humidity and Wind Vectors  at %s hPa'% (p), fontsize=10) 

        wind = m.quiver(x_w,y_w, u, v, scale=150,color='#262626' )
        qk = plt.quiverkey(wind, 0.1, 0.1, 5, '5 m/s', labelpos='W')
                
        plt.clabel(cs_lin, fontsize=10, fmt='%d', color='black')

        #plt.title('%s\n%s' % (m_title, model_name_convert_title.main(experiment_id)), fontsize=10)
        plt.title('\n'.join(wrap('%s' % (model_name_convert_title.main(experiment_id)), 80)), fontsize=10)
        
        #plt.show()  
        if not os.path.exists('/nfs/a90/eepdw/Mean_State_Plot_Data/Figures/%s/%s' % (experiment_id, plot_diag)): os.makedirs('/nfs/a90/eepdw/Mean_State_Plot_Data/Figures/%s/%s' % (experiment_id, plot_diag))
        plt.savefig('/nfs/a90/eepdw/Mean_State_Plot_Data/Figures/%s/%s/geop_height_difference_120LAM_%shPa_%s_%s.png' % (experiment_id, plot_diag, p, experiment_id, plot_diag), format='png', bbox_inches='tight')
Esempio n. 46
0
def plot_timeseries(dat, met, float):

    f, ax = plt.subplots(6, 1, sharex=True)
    if float != '7782b':

        met = met.sel(floatid=float)
        met['tau'] = np.sqrt(met.tx**2 + met.ty**2)
        met.tx.plot(ax=ax[0], label=r'$\tau_x$')
        met.ty.plot(ax=ax[0], label=r'$\tau_y$')
        met.tau.plot(ax=ax[0], label=r'$\tau$')
        ax[0].legend()
        ax[0].set_xlabel(None)
        ax[0].set_ylabel(r'wind stress [Nm$-2$]')

        met = met.resample(time='9h', skipna=True).mean()
        quiveropts = dict(headlength=0,
                          headwidth=1,
                          scale_units='y',
                          scale=1,
                          color='k')
        qv = ax[1].quiver(met.time.values, np.zeros(met.time.shape), met.tx, met.ty,met.tau,
                     **quiveropts)
        plt.quiverkey(qv, 0.9, 0.8, 0.5, '0.5 Nm$^{-2}$', coordinates='axes')
        ax[1].set_xlabel(None)
        ax[1].set_ylabel(r'wind stress vectors')
        ax[1].set_ylim(-1,1)

    dat.mld.plot(ax=ax[2], label=r'mld (0.03kgm$^{-3}$ from $\rho_{10m}$)')
    ax[2].legend()
    ax[2].set_xlabel(None)
    ax[2].set_ylabel('Mixed layer depth [m]')

    dat.hke.plot(ax=ax[3],marker='.',lw=0, label='total hke')
    dat.hke_lowpass.plot(ax=ax[3],marker='.',lw=0, label='lowpass hke')
    dat.hke_resid.plot(ax=ax[3], label='resid hke')
    dat.hke_ni.plot(ax=ax[3], label='ni hke')
    ax[3].legend()
    ax[3].set_xlabel(None)
    ax[3].set_ylabel('HKE [m$^2$s$^2$]')

    dat.dHKEdt_total.pipe(np.abs).pipe(np.log10).plot(ax=ax[4],
                                         lw=0,
                                         marker='.',
                                         label='total dhke/dt')
    dat.dHKEdt_lowpass.pipe(np.abs).pipe(np.log10).plot(ax=ax[4],
                                           lw=0,
                                           marker='.',
                                           label='lowpass dhke/dt')
    dat.dHKEdt_resid.pipe(np.abs).pipe(np.log10).plot(ax=ax[4],
                                         marker='.',
                                         label='resid dhke/dt')
    dat.dHKEdt_ni.pipe(np.abs).pipe(np.log10).plot(ax=ax[4],
                                      marker='.',
                                      label='ni dhke/dt')
    ax[4].legend()
    ax[4].set_xlabel(None)
    ax[4].set_ylabel(r'$\frac{\partial HKE}{\partial t}$ [m$^2$s$^3$]')

    dat.eps.pipe(np.abs).pipe(np.log10).plot(ax=ax[5],
                                marker='.',
                                lw=0.1,
                                label=r'$log_{10}(\epsilon)$')
    # ax[7].set_ylim(-8,0)
    ax[5].legend()
    ax[5].set_xlabel(None)
    ax[5].set_ylabel(r'$\epsilon$ [m$^2$s$^3$]')

    ax[-1].set_xlim(dat.mld.time.values.min(), dat.mld.time.values.max())
    plt.tight_layout()
    plt.subplots_adjust(hspace=0.1)
    plt.savefig(f'figures/storms/nov152017/{float:s}.pdf')
    plt.close()
Esempio n. 47
0
def plot_uv(ds, grd, block=2):

    # Radius of the Earth in metres
    r = 6.371e6
    # Degrees to radians conversion factor
    deg2rad = np.pi / 180
    # Side length of blocks to average vectors over (can't plot vector at every
    # single point or the plot will be way too crowded)

    lon = grd.lon_rho.values
    lat = grd.lat_rho.values

    u = ds.ubar.values
    v = ds.vbar.values

    angle = np.zeros(np.shape(lon))
    u_rho, v_rho = rotate_vector_roms(u, v, angle)

    speed = np.sqrt(np.square(u_rho) + np.square(v_rho))

    #print('initialize and fill up the arrays')
    numy = np.size(lon, 0)  #530
    numx = np.size(lon, 1)  #630
    x = np.arange(numx)
    y = np.arange(numy)
    xmesh, ymesh = np.meshgrid(x, y)
    #print(numx,numy,x,y)

    # Average x, y, u_circ, and v_circ over block x block intervals
    # Calculate number of blocks
    size0 = int(np.ceil(numy / float(block)))
    size1 = int(np.ceil(numx / float(block)))

    # Set up arrays for averaged fields
    x_block = np.ma.empty([size0, size1])
    y_block = np.ma.empty([size0, size1])
    u_block = np.ma.empty([size0, size1])
    v_block = np.ma.empty([size0, size1])
    # Set up arrays containing boundary indices
    posn0 = list(np.arange(0, numy, block))
    posn0.append(numy)
    posn1 = list(np.arange(0, numx, block))
    posn1.append(numx)
    #print(posn0,posn1)
    # Double loop to average each block (can't find a more efficient way to do
    # this)
    for j in np.arange(size0):
        for i in np.arange(size1):
            start0 = posn0[j]
            end0 = posn0[j + 1]
            start1 = posn1[i]
            end1 = posn1[i + 1]
            x_block[j, i] = np.mean(xmesh[start0:end0, start1:end1])
            y_block[j, i] = np.mean(ymesh[start0:end0, start1:end1])
            u_block[j, i] = np.mean(u_rho[start0:end0, start1:end1])
            v_block[j, i] = np.mean(v_rho[start0:end0, start1:end1])

    # Make the plot
    fig, ax0 = plt.subplots(1, figsize=(15, 10))

    speedP = ax0.pcolormesh(xmesh,
                            ymesh,
                            speed * 100,
                            vmin=0,
                            vmax=10,
                            cmap=cmo.speed)
    plt.colorbar(speedP, ax=ax0)
    # Add vectors for each block
    quiverP = ax0.quiver(x_block,
                         y_block,
                         u_block,
                         v_block,
                         pivot="mid",
                         color='black',
                         scale_units='xy',
                         scale=0.01)
    plt.quiverkey(quiverP,
                  0.75,
                  0.99,
                  0.1,
                  r'$10 \frac{cm}{s}$',
                  labelpos='E',
                  coordinates='figure')
    ax0.set_title('Mean barotropic velocity (cm/s)', fontsize=16)
    ax0.set_aspect('equal')
    ax0.axis('off')

    print('test')
    return fig
Esempio n. 48
0
def plotear(lllat,
            urlat,
            lllon,
            urlon,
            dist_lat,
            dist_lon,
            Lon,
            Lat,
            mapa,
            bar_min,
            bar_max,
            unds,
            titulo,
            path,
            C_T='k',
            wind=False,
            mapa_u=None,
            mapa_v=None):

    # lllat (low-left-lat)   : float con la latitud de la esquina inferior izquierda
    # urlat (uper-right-lat) : float con la latitud de la esquina superior derecha
    # lllon (low-left-lon)   : float con la longitud de la esquina inferior izquierda en coordenas negativas este
    # urlon (uper-right-lon) : float con la longitud de la esquina superior derecha en coordenas negativas este
    # dist_lat               : entero que indica cada cuanto dibujar las lineas de los paralelos
    # dist_lon               : entero que indica cada cuanto dibujar las lineas de los meridianos
    # Lon                    : array de numpy con las longitudes del mapa a plotearse en coordenadas negativas este
    # Lat                    : array de numpy con las longitudes del mapa a plotearse
    # mapa                   : array de numpy 2D a plotearse con contourf
    # bar_min                : mínimo valor del mapa a plotearse
    # bar_max                : máximo valor del mapa a plotearse
    # unds                   : string de las unidades de la variable que se va a plotear
    # titulo                 : string del titulo que llevará el mapa
    # path                   : 'string de la dirección y el nombre del archivo que contendrá la figura a generarse'
    # wind                   : boolean que diga si se quiere pintar flechas de viento (corrientes), donde True es que sí se va a hacer
    # mapa_u                 : array de numpay 2D con la componente en x de la velocidad y que será utilizado para pintar las flechas. Este tomara algun valor siempre y cuando wind=True
    # mapa_v                 : array de numpay 2D con la componente en y de la velocidad y que será utilizado para pintar las flechas. Este tomara algun valor siempre y cuando wind=True

    # return                 : gráfica o mapa

    fig = plt.figure(figsize=(8, 8), edgecolor='W', facecolor='W')
    ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])

    map = Basemap(projection='merc',
                  llcrnrlat=lllat,
                  urcrnrlat=urlat,
                  llcrnrlon=lllon,
                  urcrnrlon=urlon,
                  resolution='i')
    map.drawcoastlines(linewidth=0.8)
    map.drawcountries(linewidth=0.8)
    map.drawparallels(np.arange(lllat, urlat, dist_lat), labels=[1, 0, 0, 1])
    map.drawmeridians(np.arange(lllon, urlon, dist_lon), labels=[1, 0, 0, 1])

    lons, lats = np.meshgrid(Lon, Lat)
    x, y = map(lons, lats)

    bounds = np.linspace(bar_min, bar_max, 20)
    bounds = np.around(bounds, decimals=2)

    if wind == False:
        CF1 = map.contourf(x,
                           y,
                           mapa,
                           20,
                           norm=MidpointNormalize(midpoint=0),
                           cmap=plt.cm.viridis,
                           levels=bounds,
                           extend='max')  #plt.cm.rainbow , plt.cm.RdYlBu_r
        CF2 = map.contourf(x,
                           y,
                           mapa,
                           20,
                           norm=MidpointNormalize(midpoint=0),
                           cmap=plt.cm.viridis,
                           levels=bounds,
                           extend='min')  #plt.cm.rainbow, plt.cm.RdYlBu_r
    else:
        CF1 = map.contourf(x,
                           y,
                           mapa,
                           20,
                           cmap=plt.cm.rainbow,
                           levels=bounds,
                           extend='max')  #plt.cm.rainbow , plt.cm.RdYlBu_r
        CF2 = map.contourf(x,
                           y,
                           mapa,
                           20,
                           cmap=plt.cm.rainbow,
                           levels=bounds,
                           extend='min')  #plt.cm.rainbow, plt.cm.RdYlBu_r

    cb1 = plt.colorbar(CF1,
                       orientation='horizontal',
                       pad=0.05,
                       shrink=0.8,
                       boundaries=bounds)
    cb1.set_label(unds)
    ax.set_title(titulo, size='15', color=C_T)

    if wind == True:
        Q = map.quiver(x[::2, ::2],
                       y[::2, ::2],
                       mapa_u[::2, ::2],
                       mapa_v[::2, ::2],
                       scale=20)
        plt.quiverkey(Q, 0.93, 0.05, 2, '2 m/s')

    #map.fillcontinents(color='white')
    plt.savefig(path + '.png', bbox_inches='tight', dpi=300)
    plt.close('all')
Esempio n. 49
0
def corr_box():
    srfc = cnst.ERA_MONTHLY_SRFC_SYNOP
    pl = cnst.ERA_MONTHLY_PL_SYNOP
    mcs = cnst.GRIDSAT + 'aggs/gridsat_WA_-65_monthly_count_-40base_15-21UTC_1000km2.nc'  # -70count

    fpath = cnst.network_data + 'figs/CLOVER/months/'

    dicm = pkl.load(
        open(
            cnst.network_data + 'data/CLOVER/saves/storm_frac_synop12UTC_SA.p',
            'rb'))
    dicmean = pkl.load(
        open(
            cnst.network_data +
            'data/CLOVER/saves/storm_frac_mean_synop12UTC_SA.p', 'rb'))

    # mcsbox = cnst.GRIDSAT + 'aggs/SAboxWest_meanT-40_1000km2.nc' # box_13W-13E-4-8N_meanT-50_from5000km2.nc'
    # mcs_temp = xr.open_dataset(mcsbox)
    # mcs_temp = mcs_temp['tir']

    box = [5, 55, -36, 0]  #[-18,55,-35,35]#[-10,55,-35,0]

    da = xr.open_dataset(pl)
    da = u_darrays.flip_lat(da)
    da = da.sel(longitude=slice(box[0], box[1]),
                latitude=slice(box[2], box[3]))  # latitude=slice(36, -37))
    da2 = xr.open_dataset(srfc)
    da2 = u_darrays.flip_lat(da2)
    da2 = da2.sel(longitude=slice(box[0], box[1]),
                  latitude=slice(box[2], box[3]))  # latitude=slice(36, -37))
    da3 = xr.open_dataset(mcs)
    da3 = da3.sel(lon=slice(box[0], box[1]), lat=slice(box[2], box[3]))

    lons = da.longitude
    lats = da.latitude

    press = da2['sp']
    press = press[press['time.hour'] == 12]
    press.values = press.values * 1000
    low_press = 850
    up_press = 550

    q = da['q'].sel(level=slice(low_press - 50, low_press)).mean('level')
    q = q[q['time.hour'] == 12]
    t2d = da2['t2m']  #['t2m']
    #t2d = da['t'].sel(level=slice(800, 850)).mean('level')
    t2d = t2d[t2d['time.hour'] == 12]

    u600 = da['u'].sel(level=slice(up_press - 50, up_press)).mean('level')
    u600 = u600[u600['time.hour'] == 12]
    v600 = da['v'].sel(level=slice(up_press - 50, up_press)).mean('level')
    v600 = v600[v600['time.hour'] == 12]

    ws600 = u_met.u_v_to_ws_wd(u600, v600)

    u800 = da['u'].sel(level=slice(low_press - 50, low_press)).mean('level')
    u800 = u800[u800['time.hour'] == 12]

    v800 = da['v'].sel(level=slice(low_press - 50, low_press)).mean('level')
    v800 = v800[v800['time.hour'] == 12]

    shear_u = u600 - u800  #u600-
    shear_v = v600 - v800  # v600-

    ws_shear = u_met.u_v_to_ws_wd(shear_u.values, shear_v.values)

    ws_600 = t2d.copy(deep=True)
    ws_600.name = 'ws'
    ws_600.values = ws600[0]

    shear = t2d.copy(deep=True)
    shear.name = 'shear'
    shear.values = ws_shear[0]

    q.values = q.values * 1000

    tir = da3['tir']
    tir = t2d.salem.lookup_transform(tir)

    def array_juggling(data, month, hour=None):

        m = month

        if hour is not None:
            if len(month) > 1:

                data = data[((data['time.month'] >= month[0])
                             | (data['time.month'] <= month[1]))
                            & (data['time.hour'] == hour) &
                            (data['time.year'] >= 1983) &
                            (data['time.year'] <= 2017)]
            else:

                data = data[(data['time.month'] == month[0])
                            & (data['time.hour'] == hour) &
                            (data['time.year'] >= 1983) &
                            (data['time.year'] <= 2017)]
        else:
            if len(month) > 1:
                data = data[((data['time.month'] >= month[0])
                             | (data['time.month'] <= month[1]))
                            & (data['time.year'] >= 1983) &
                            (data['time.year'] <= 2017)]
            else:
                data = data[(data['time.month'] == month[0])
                            & (data['time.year'] >= 1983) &
                            (data['time.year'] <= 2017)]

        data_years = data.groupby('time.year').mean(axis=0)

        data_mean = data.mean(axis=0)

        # diff = xr.DataArray(data_years.values[1::, :, :] - data_years.values[0:-1, :, :],
        #                     coords=[data_years.year[1::], data.latitude, data.longitude], dims=['year','latitude', 'longitude'] )
        diff = xr.DataArray(
            data_years.values,
            coords=[data_years.year, data.latitude, data.longitude],
            dims=['year', 'latitude', 'longitude'])
        # unstack back to lat lon coordinates
        return diff, data_mean

    def corr(a, b, bsingle=None, c_box=None):
        ds = xr.Dataset()
        ds['pval'] = a.copy(deep=True).sum('year') * np.nan
        ds['r'] = a.copy(deep=True).sum('year') * np.nan
        ds['slope'] = a.copy(deep=True).sum('year') * np.nan

        corr_box = c_box

        if bsingle:
            bb = b
        else:
            bb = b.sel(latitude=slice(corr_box[2], corr_box[3]),
                       longitude=slice(
                           corr_box[0],
                           corr_box[1])).mean(dim=['latitude', 'longitude'])

        for lat in a.latitude.values:
            for lon in a.longitude.values:
                aa = a.sel(latitude=lat, longitude=lon)
                if bsingle:
                    r, p = stats.pearsonr(aa.values, bb)

                    pf = np.polyfit(aa.values, bb, 1)
                else:
                    r, p = stats.pearsonr(aa.values, bb.values)
                    pf = np.polyfit(aa.values, bb.values, 1)

                slope = pf[0]

                if (np.nansum(aa.values == 0) >= 10):
                    p = np.nan
                    r = np.nan

                ds['r'].loc[{'latitude': lat, 'longitude': lon}] = r
                ds['pval'].loc[{'latitude': lat, 'longitude': lon}] = p
                ds['slope'].loc[{'latitude': lat, 'longitude': lon}] = slope

        return ds

    box_dic = {
        1: [16, 30, -25, -20],
        2: [12, 28, -10, 3],
        3: [16, 25, -23, -18],
        4: [16, 25, -23, -18],
        10: [14, 28, -15, -5],
        11: [16, 30, -20, -10],
        12: [16, 30, -22, -12],
        (11, 1): [18, 30, -23, -18]
    }

    months = [(11, 1), 2, 3, 10]

    for m in months:

        c_box = box_dic[m]

        if type(m) == int:
            m = [m]

        t2diff, t2year = array_juggling(t2d, m)  #
        qdiff, qyear = array_juggling(q, m)  #, hour=12
        shdiff, sheyear = array_juggling(shear, m)  #, hour=12
        vdiff, vyear = array_juggling(v800, m)  # , hour=12
        udiff, uyear = array_juggling(u800, m)  # , hour=12
        tirdiff, tiryear = array_juggling(tir, m)  # average frequency change

        #mcs_month = mcs_temp[mcs_temp['time.month'] == m] # meanT box average change

        #tirdiff = mcs_month.values[1::]-mcs_month.values[0:-1]

        bs = False
        try:
            qcorr = corr(qdiff, tirdiff, bsingle=bs, c_box=c_box)
        except:
            continue
        shearcorr = corr(shdiff, tirdiff, bsingle=bs, c_box=c_box)
        tcorr = corr(t2diff, tirdiff, bsingle=bs, c_box=c_box)

        dicm[m[0]].values[dicm[m[0]].values == 0] = np.nan

        print('plot')

        if len(m) == 1:
            fp = fpath + 'corr_mid_-70C_synop_-50base_linear_850T' + str(
                m[0]).zfill(2) + '.png'
        else:
            fp = fpath + 'corr_mid_-70C_synop_-50base_linear_850T' + str(
                m[0]).zfill(2) + '-' + str(m[1]).zfill(2) + '.png'

        map = shear.salem.get_map()

        xx, yy = map.grid.transform(shear.longitude.values,
                                    shear.latitude.values,
                                    crs=shear.salem.grid.proj)

        xx, yy = np.meshgrid(xx, yy)

        # Quiver only every 7th grid point
        u = uyear.values[1::2, 1::2]
        v = vyear.values[1::2, 1::2]

        xx = xx[1::2, 1::2]
        yy = yy[1::2, 1::2]

        #ipdb.set_trace()
        f = plt.figure(figsize=(15, 8), dpi=350)
        ax1 = f.add_subplot(221)

        map.set_data(tcorr['r'], interp='linear')  # interp='linear'
        map.set_contour(t2year - 273.15,
                        interp='linear',
                        levels=np.arange(24, 37, 4),
                        colors='k',
                        linewidths=0.5)

        map.set_plot_params(
            cmap='RdBu_r',
            extend='both',
            levels=[-0.7, -0.6, -0.5, -0.4, -0.3, 0.3, 0.4, 0.5, 0.6,
                    0.7])  # levels=np.arange(-0.5,0.51,0.1),
        dic = map.visualize(ax=ax1,
                            title='2m temperature corr. | contours: mean T',
                            cbar_title='K decade-1')
        contours = dic['contour'][0]
        plt.clabel(contours, inline=True, fontsize=7, fmt='%1.1f')

        ax2 = f.add_subplot(222)
        map.set_data(qcorr['r'], interp='linear')  # interp='linear'
        map.set_contour(qyear,
                        interp='linear',
                        levels=np.arange(5, 19, 3),
                        colors='k',
                        linewidths=0.5)

        map.set_plot_params(
            cmap='RdBu_r',
            extend='both',
            levels=[-0.7, -0.6, -0.5, -0.4, -0.3, 0.3, 0.4, 0.5, 0.6,
                    0.7])  # levels=np.arange(-0.5,0.51,0.1),
        dic = map.visualize(
            ax=ax2,
            title='800hPa Spec. humidity corr. | contours: mean q',
            cbar_title='g kg-1 decade-1')
        contours = dic['contour'][0]
        plt.clabel(contours, inline=True, fontsize=7, fmt='%1.1f')

        ax3 = f.add_subplot(223)
        # map.set_data(shearcorr['r'], interp='linear')  # interp='linear'
        # map.set_plot_params(cmap='RdBu_r', extend='both', levels=[-0.7,-0.6,-0.5,-0.4, -0.3,0.3,0.4,0.5,0.6,0.7])
        #map.set_contour(sheyear, interp='linear', levels=np.arange(-10,1,6), colors='k', linewidths=0.5)
        map.set_data(tcorr['r'], interp='linear')  # interp='linear'
        map.set_plot_params(
            cmap='RdBu_r',
            extend='both',
            levels=[-0.7, -0.6, -0.5, -0.4, -0.3, 0.3, 0.4, 0.5, 0.6, 0.7])

        qu = ax3.quiver(xx, yy, u, v, scale=50, width=0.002)
        qk = plt.quiverkey(qu,
                           0.4,
                           0.03,
                           4,
                           '4 m s$^{-1}$',
                           labelpos='E',
                           coordinates='figure')

        # levels=np.arange(-0.5,0.51,0.1)
        dic = map.visualize(
            ax=ax3,
            title='800-500hPa wind shear corr., mean 500hPa wind vectors',
            cbar_title='m s-1 decade-1')
        contours = dic['contour'][0]
        plt.clabel(contours, inline=True, fontsize=7, fmt='%1.1f')

        ax4 = f.add_subplot(224)
        map.set_contour(dicmean[m[0]],
                        interp='linear',
                        levels=[0.1, 0.5, 1, 2.5],
                        colors='k',
                        linewidths=0.5)

        map.set_data(dicm[m[0]])  #
        #ax4.axhspan(-26,18)  #[15,25,-26,-18]
        coord = c_box  #[17, 25, -28, -22]
        geom = shpg.box(coord[0], coord[2], coord[1], coord[3])
        map.set_geometry(geom,
                         zorder=99,
                         color='darkorange',
                         linewidth=3,
                         linestyle='--',
                         alpha=0.3)
        # ax4.axvline(x=25, ymin=-26, ymax=-18)
        # ax4.axhline(y=-26, xmin=15, xmax=25)
        # ax4.axhline(y=-18, xmin=15, xmax=25)

        map.set_plot_params(
            cmap='viridis', extend='both', levels=np.arange(
                10, 41,
                10))  # levels=np.arange(20,101,20)  #np.arange(20,101,20)
        dic = map.visualize(ax=ax4,
                            title='-65C cloud cover change | >1000km2 -40C',
                            cbar_title='$\%$ decade-1')
        contours = dic['contour'][0]
        plt.clabel(contours, inline=True, fontsize=7, fmt='%1.1f')

        plt.tight_layout()
        plt.savefig(fp)
        plt.close('all')
Esempio n. 50
0
    def plot(self):
        if self.filetype == 'geotiff':
            f, fname = tempfile.mkstemp()
            os.close(f)

            driver = gdal.GetDriverByName('GTiff')
            outRaster = driver.Create(fname, self.latitude.shape[1],
                                      self.longitude.shape[0], 1,
                                      gdal.GDT_Float64)
            x = [self.longitude[0, 0], self.longitude[-1, -1]]
            y = [self.latitude[0, 0], self.latitude[-1, -1]]
            outRasterSRS = osr.SpatialReference()

            x, y = self.basemap(x, y)
            outRasterSRS.ImportFromProj4(self.basemap.proj4string)

            pixelWidth = (x[-1] - x[0]) / self.longitude.shape[0]
            pixelHeight = (y[-1] - y[0]) / self.latitude.shape[0]
            outRaster.SetGeoTransform(
                (x[0], pixelWidth, 0, y[0], 0, pixelHeight))

            outband = outRaster.GetRasterBand(1)
            d = self.data.astype("Float64")
            ndv = d.fill_value
            outband.WriteArray(d.filled(ndv))
            outband.SetNoDataValue(ndv)
            outRaster.SetProjection(outRasterSRS.ExportToWkt())
            outband.FlushCache()
            outRaster = None

            with open(fname, 'r', encoding="latin-1") as f:
                buf = f.read()
            os.remove(fname)

            return (buf, self.mime, self.filename.replace(".geotiff", ".tif"))
        # Figure size
        figuresize = list(map(float, self.size.split("x")))
        fig = plt.figure(figsize=figuresize, dpi=self.dpi)
        ax = plt.gca()

        if self.scale:
            vmin = self.scale[0]
            vmax = self.scale[1]
        else:
            vmin = np.amin(self.data)
            vmax = np.amax(self.data)
            if self.compare:
                vmax = max(abs(vmax), abs(vmin))
                vmin = -vmax

        c = self.basemap.imshow(self.data,
                                vmin=vmin,
                                vmax=vmax,
                                cmap=self.cmap)

        if len(self.quiver_data) == 2:
            qx, qy = self.quiver_data
            qx, qy, x, y = self.basemap.rotate_vector(qx,
                                                      qy,
                                                      self.quiver_longitude,
                                                      self.quiver_latitude,
                                                      returnxy=True)
            quiver_mag = np.sqrt(qx**2 + qy**2)

            if self.quiver['magnitude'] != 'length':
                qx = qx / quiver_mag
                qy = qy / quiver_mag
                qscale = 50
            else:
                qscale = None

            if self.quiver['magnitude'] == 'color':
                if self.quiver['colormap'] is None or \
                   self.quiver['colormap'] == 'default':
                    qcmap = colormap.colormaps.get('speed')
                else:
                    qcmap = colormap.colormaps.get(self.quiver['colormap'])
                q = self.basemap.quiver(
                    x,
                    y,
                    qx,
                    qy,
                    quiver_mag,
                    width=0.0035,
                    headaxislength=4,
                    headlength=4,
                    scale=qscale,
                    pivot='mid',
                    cmap=qcmap,
                )
            else:
                q = self.basemap.quiver(
                    x,
                    y,
                    qx,
                    qy,
                    width=0.0025,
                    headaxislength=4,
                    headlength=4,
                    scale=qscale,
                    pivot='mid',
                )

            if self.quiver['magnitude'] == 'length':
                unit_length = np.mean(quiver_mag) * 2
                unit_length = np.round(unit_length,
                                       -int(np.floor(np.log10(unit_length))))
                if unit_length >= 1:
                    unit_length = int(unit_length)

                plt.quiverkey(q,
                              .65,
                              .01,
                              unit_length,
                              self.quiver_name.title() + " " +
                              str(unit_length) + " " +
                              utils.mathtext(self.quiver_unit),
                              coordinates='figure',
                              labelpos='E')

        if self.show_bathymetry:
            # Plot bathymetry on top
            cs = self.basemap.contour(
                self.longitude,
                self.latitude,
                self.bathymetry,
                latlon=True,
                linewidths=0.5,
                norm=LogNorm(vmin=1, vmax=6000),
                cmap=mcolors.LinearSegmentedColormap.from_list(
                    'transparent_gray', [(0, 0, 0, 0.5), (0, 0, 0, 0.1)]),
                levels=[100, 200, 500, 1000, 2000, 3000, 4000, 5000, 6000])
            plt.clabel(cs, fontsize='xx-small', fmt='%1.0fm')

        if self.area and self.show_area:
            for a in self.area:
                polys = []
                for co in a['polygons'] + a['innerrings']:
                    coords = np.array(co).transpose()
                    mx, my = self.basemap(coords[1], coords[0])
                    map_coords = list(zip(mx, my))
                    polys.append(Polygon(map_coords))

                paths = []
                for poly in polys:
                    paths.append(poly.get_path())
                path = concatenate_paths(paths)

                poly = PathPatch(path,
                                 fill=None,
                                 edgecolor='#ffffff',
                                 linewidth=5)
                plt.gca().add_patch(poly)
                poly = PathPatch(path, fill=None, edgecolor='k', linewidth=2)
                plt.gca().add_patch(poly)

            if self.names is not None and len(self.names) > 1:
                for idx, name in enumerate(self.names):
                    x, y = self.basemap(self.centroids[idx].y,
                                        self.centroids[idx].x)
                    plt.annotate(
                        xy=(x, y),
                        s=name,
                        ha='center',
                        va='center',
                        size=12,
                        # weight='bold'
                    )

        if len(self.contour_data) > 0:
            if (self.contour_data[0].min() != self.contour_data[0].max()):
                cmin, cmax = utils.normalize_scale(self.contour_data[0],
                                                   self.contour_name,
                                                   self.contour_unit)
                levels = None
                if self.contour.get('levels') is not None and \
                    self.contour['levels'] != 'auto' and \
                        self.contour['levels'] != '':
                    try:
                        levels = list(
                            set([
                                float(xx)
                                for xx in self.contour['levels'].split(",")
                                if xx.strip()
                            ]))
                        levels.sort()
                    except ValueError:
                        pass

                if levels is None:
                    levels = np.linspace(cmin, cmax, 5)
                cmap = self.contour['colormap']
                if cmap is not None:
                    cmap = colormap.colormaps.get(cmap)
                    if cmap is None:
                        cmap = colormap.find_colormap(self.contour_name)

                if not self.contour.get('hatch'):
                    contours = self.basemap.contour(self.longitude,
                                                    self.latitude,
                                                    self.contour_data[0],
                                                    latlon=True,
                                                    linewidths=2,
                                                    levels=levels,
                                                    cmap=cmap)
                else:
                    hatches = [
                        '//', 'xx', '\\\\', '--', '||', '..', 'oo', '**'
                    ]
                    if len(levels) + 1 < len(hatches):
                        hatches = hatches[0:len(levels) + 2]
                    self.basemap.contour(self.longitude,
                                         self.latitude,
                                         self.contour_data[0],
                                         latlon=True,
                                         linewidths=1,
                                         levels=levels,
                                         colors='k')
                    contours = self.basemap.contourf(self.longitude,
                                                     self.latitude,
                                                     self.contour_data[0],
                                                     latlon=True,
                                                     colors=['none'],
                                                     levels=levels,
                                                     hatches=hatches,
                                                     vmin=cmin,
                                                     vmax=cmax,
                                                     extend='both')

                if self.contour['legend']:
                    handles, l = contours.legend_elements()
                    labels = []
                    for i, lab in enumerate(l):
                        if self.contour.get('hatch'):
                            if self.contour_unit == 'fraction':
                                if i == 0:
                                    labels.append(
                                        "$x \\leq {0: .0f}\\%$".format(
                                            levels[i] * 100))
                                elif i == len(levels):
                                    labels.append("$x > {0: .0f}\\%$".format(
                                        levels[i - 1] * 100))
                                else:
                                    labels.append(
                                        "${0:.0f}\\% < x \\leq {1:.0f}\\%$".
                                        format(levels[i - 1] * 100,
                                               levels[i] * 100))
                            else:
                                if i == 0:
                                    labels.append("$x \\leq %.3g$" % levels[i])
                                elif i == len(levels):
                                    labels.append("$x > %.3g$" % levels[i - 1])
                                else:
                                    labels.append("$%.3g < x \\leq %.3g$" %
                                                  (levels[i - 1], levels[i]))
                        else:
                            if self.contour_unit == 'fraction':
                                labels.append("{0:.0%}".format(levels[i]))
                            else:
                                labels.append(
                                    "%.3g %s" %
                                    (levels[i],
                                     utils.mathtext(self.contour_unit)))

                    ax = plt.gca()

                    if self.contour_unit != 'fraction' and not \
                            self.contour.get('hatch'):
                        contour_title = "%s (%s)" % (self.contour_name,
                                                     utils.mathtext(
                                                         self.contour_unit))
                    else:
                        contour_title = self.contour_name

                    leg = ax.legend(handles[::-1],
                                    labels[::-1],
                                    loc='lower left',
                                    fontsize='medium',
                                    frameon=True,
                                    framealpha=0.75,
                                    title=contour_title)
                    leg.get_title().set_fontsize('medium')
                    if not self.contour.get('hatch'):
                        for legobj in leg.legendHandles:
                            legobj.set_linewidth(3)

        # Map Info
        self.basemap.drawmapboundary(fill_color=(0.3, 0.3, 0.3), zorder=-1)
        self.basemap.drawcoastlines(linewidth=0.5)
        self.basemap.fillcontinents(color='grey', lake_color='dimgrey')

        def find_lines(values):
            if np.amax(values) - np.amin(values) < 1:
                return [values.mean()]
            elif np.amax(values) - np.amin(values) < 25:
                return np.round(
                    np.arange(np.amin(values), np.amax(values),
                              round(np.amax(values) - np.amin(values)) / 5))
            else:
                return np.arange(round(np.amin(values), -1),
                                 round(np.amax(values), -1), 5)

        parallels = find_lines(self.latitude)
        meridians = find_lines(self.longitude)
        self.basemap.drawparallels(parallels,
                                   labels=[1, 0, 0, 0],
                                   color=(0, 0, 0, 0.5))
        self.basemap.drawmeridians(meridians,
                                   labels=[0, 0, 0, 1],
                                   color=(0, 0, 0, 0.5),
                                   latmax=85)

        title = self.plotTitle

        if self.plotTitle is None or self.plotTitle == "":
            area_title = "\n".join(wrap(", ".join(self.names), 60)) + "\n"

            title = "%s %s %s, %s" % (area_title, self.variable_name.title(),
                                      self.depth_label,
                                      self.date_formatter(self.timestamp))
        plt.title(title.strip())
        ax = plt.gca()
        divider = make_axes_locatable(ax)
        cax = divider.append_axes("right", size="5%", pad=0.05)
        bar = plt.colorbar(c, cax=cax)
        bar.set_label(
            "%s (%s)" %
            (self.variable_name.title(), utils.mathtext(self.variable_unit)),
            fontsize=14)

        if self.quiver is not None and \
            self.quiver['variable'] != '' and \
            self.quiver['variable'] != 'none' and \
                self.quiver['magnitude'] == 'color':
            bax = divider.append_axes("bottom", size="5%", pad=0.35)
            qbar = plt.colorbar(q, orientation='horizontal', cax=bax)
            qbar.set_label(self.quiver_name.title() + " " +
                           utils.mathtext(self.quiver_unit),
                           fontsize=14)

        fig.tight_layout(pad=3, w_pad=4)

        return super(MapPlotter, self).plot(fig)
Esempio n. 51
0
        index.append(i)  #November index
uc = u[index[yr]][0][:]  #surface layer 0 eastward flow
vc = v[index[yr]][0][:]  #surface layer 0 northward flow
uwse = uws[index[yr]][:]  #eastward windstress
vwsn = vws[index[yr]][:]  #northward windstress
xi = np.arange(gbox[0], gbox[1], gridscale)  #region of interest
yi = np.arange(gbox[2], gbox[3], gridscale)
xb, yb, ub_mean, ub_median, ub_std, ub_num = sh_bindata(lonc, latc, uc, xi, yi)
xb, yb, vb_mean, vb_median, vb_std, vb_num = sh_bindata(lonc, latc, vc, xi, yi)
xxb, yyb = np.meshgrid(xb, yb)
fig = plt.figure()
ax1 = fig.add_subplot(211, aspect=1.3)
Q = plt.quiver(xxb, yyb, ub_mean.T, vb_mean.T, scale=3.)  #current vectors
qk = plt.quiverkey(Q,
                   0.7,
                   0.12,
                   .1,
                   r'$.1m/s$',
                   fontproperties={'weight': 'bold'})
ax1.plot(CL['lon'], CL['lat'])
ax1.set_xlim([gbox[0], gbox[1]])
ax1.set_ylim([gbox[2], gbox[3]])
ax1.set_title(str(2014 + yr) + ' mean surface current')
ax1.set_xticklabels('', visible=False)  # shut off xticklabels
xb, yb, uw_mean, uw_median, uw_std, uw_num = sh_bindata(
    lonc, latc, uwse, xi, yi)
xb, yb, vw_mean, vw_median, vw_std, vw_num = sh_bindata(
    lonc, latc, vwsn, xi, yi)
ax2 = fig.add_subplot(212, aspect=1.3)
Q = plt.quiver(xxb, yyb, uw_mean.T, vw_mean.T, scale=3.)  # wind stress vectors
qk = plt.quiverkey(Q,
                   0.7,
df.tail()

Let's take a look at our fake data.

%matplotlib inline


import matplotlib.pyplot as plt
from oceans.plotting import stick_plot

q = stick_plot([t.to_pydatetime() for t in df["time"]], df["u"], df["v"])

ref = 1
qk = plt.quiverkey(
    q, 0.1, 0.85, ref, f"{ref} m s$^{-1}$", labelpos="N", coordinates="axes"
)

plt.xticks(rotation=70)

`pocean.dsg` is relatively simple to use. The user must provide a DataFrame, like the one above, and a dictionary of attributes that maps to the data and adhere to the DSG conventions desired. 

Because we want the file to work seamlessly with ERDDAP we also added some ERDDAP specific attributes like `cdm_timeseries_variables`, and `subsetVariables`.

attributes = {
    "global": {
        "title": "Fake mooring",
        "summary": "Vector current meter ADCP @ 10 m",
        "institution": "Restaurant at the end of the universe",
        "cdm_timeseries_variables": "station",
        "subsetVariables": "depth",
Esempio n. 53
0
# create a figure, add an axes.
fig = plt.figure(figsize=(8, 8))
ax = fig.add_axes([0.1, 0.1, 0.7, 0.7])
# rotate wind vectors to map projection coordinates.
# (also compute native map projections coordinates of lat/lon grid)
# only do Northern Hemisphere.
urot, vrot, x, y = m.rotate_vector(u[36:, :],
                                   v[36:, :],
                                   lons[36:, :],
                                   lats[36:, :],
                                   returnxy=True)
# plot filled contours over map.
cs = m.contourf(x, y, p[36:, :], 15, cmap=plt.cm.jet)
# plot wind vectors over map.
Q = m.quiver(x, y, urot, vrot)  #or specify, e.g., width=0.003, scale=400)
qk = plt.quiverkey(Q, 0.95, 1.05, 25, '25 m/s', labelpos='W')
cax = plt.axes([0.875, 0.1, 0.05, 0.7])  # setup colorbar axes.
plt.colorbar(cax=cax)  # draw colorbar
plt.axes(ax)  # make the original axes current again
m.drawcoastlines()
m.drawcountries()
# draw parallels
delat = 20.
circles = np.arange(0.,90.+delat,delat).tolist()+\
          np.arange(-delat,-90.-delat,-delat).tolist()
m.drawparallels(circles, labels=[1, 1, 1, 1])
# draw meridians
delon = 45.
meridians = np.arange(-180, 180, delon)
m.drawmeridians(meridians, labels=[1, 1, 1, 1])
plt.title('Surface Winds Winds and Pressure (lat-lon grid)', y=1.075)
Esempio n. 54
0
          '20170118.015_lp_2min-fitcal_2dVEF_001001',
          '20170118.017_lp_2min-fitcal_2dVEF_001001',
          '20170118.019_lp_2min-fitcal_2dVEF_001001',
          '20170118.021_lp_2min-fitcal_2dVEF_001001']
          
for runname in runnames:
    print runname
    d=io_utils.read_whole_h5file(runname+'.h5')
    
    plt.rcParams['figure.figsize']=10,10
    plt.rcParams['font.size']=16
    
    for r in range(d['/Fit2D']['DivE'].shape[0]):
        fig=plt.figure()
        div_clrs=plt.pcolormesh(d['/Grid']['x'][0,:],d['/Grid']['y'][0,:],d['/Fit2D']['DivE'][r,:,:],vmin=-1e-5,vmax=1e-5,cmap='RdBu_r')
        qv=plt.quiver(d['/Grid']['x'][0,:],d['/Grid']['y'][0,:],d['/Fit2D']['Ex'][r,:,:],d['/Fit2D']['Ey'][r,:,:],d['/Fit2D']['Emag'][r,:,:],scale=2500,cmap='bone_r')
        qk = plt.quiverkey(qv, 0.5, 0.875, 100, '100 mV/m',
                            labelpos='E',
                            coordinates='figure',
                            fontproperties={'weight': 'bold'}) 
        plt.title(datetime.datetime(1970,1,1)+datetime.timedelta(seconds=int(d['/Time']['UnixTime'][r,0])))
        plt.xlabel('Mag Longitude')
        plt.ylabel('Mag Latitude')
        
        hc=plt.colorbar(div_clrs)
        hc.set_label('DivE')
        
        plt.savefig('./figtmp/fig_'+runname+'_'+str(r)+'.png',format='png',dpi=100)
        plt.close(fig)
        
    os.system('ffmpeg -r 4 -i figtmp/fig_'+runname+'_%d.png -c:v libx264 -pix_fmt yuv420p ' + runname + '_divE.mp4')
Esempio n. 55
0
def test(err=0, mknewcat=True, pattern_error=100, dev_pat=True, distort=True, debug_plots=False, order_pattern_error=False, trim_cam=False, fix_trans=False, fit=True, npos=3, rot_ang_l=[0, 90, 180, 270], step_size=250, Niter=5, plot_in=False, order=4, correct_ref=False, lab_offsets=False, plot_dist=True, Nmissing=None, pattern_from_distortion=True, order_pattern=1):
    '''
    Test function for disotriotn fitting routine that includes altering the refernece positions 
    The fit_all.simul_wref() takes a list of xpositoins, ypositions and offsets, compares them to a perfect square reference and then fits for both the distortion and the pattern deviation

    err is the size of measurment error in pixels
    pattern error is the size of the (random) deviations applied ot each pinhole
    correct_ref(bool): If True, the reference coordinates used in the fit are chaged to the correct deviated values.  This validates that the fit works if you give it the right answer

    To simulate:
      -First create a perfect square reference 
      -For each mask position:
          -Apply a pattern deviation (function of reference pixel location as a single second order polynomial)  TEST:redo using arbitrary deviations 
          -Apply a translation offset (~1000 pixels)
          -Apply a distortion map (function of translated pixels)
          -Add noise if desired
      Note:Deviations (distortion and pattern) must be smaller than 30 pixels in total, as that is the matching radius in the code.  To match measured data the distortion should be ~0.3 pixels and the pattern deviation should be ~ 0.016 pixels.

    Do the tests in terms of the coeffiicients not just the residuals.
    Walk up distoriton solutions from fits order in separate functions
    '''
    colors = ['black', 'blue', 'green', 'purple', 'brown', 'magenta', 'teal', 'yellow', 'gray', 'black', 'blue', 'green', 'purple', 'brown', 'magenta', 'teal', 'yellow', 'gray','black', 'blue', 'green', 'purple', 'brown', 'magenta', 'teal', 'yellow', 'gray', 'black', 'blue', 'green', 'purple', 'brown', 'magenta', 'teal', 'yellow', 'gray','black', 'blue', 'green', 'purple', 'brown', 'magenta', 'teal', 'yellow', 'gray', 'black', 'blue', 'green', 'purple', 'brown', 'magenta', 'teal', 'yellow', 'gray','black', 'blue', 'green', 'purple', 'brown', 'magenta', 'teal', 'yellow', 'gray', 'black', 'blue', 'green', 'purple', 'brown', 'magenta', 'teal', 'yellow', 'gray','black', 'blue', 'green', 'purple', 'brown', 'magenta', 'teal', 'yellow', 'gray', 'black', 'blue', 'green', 'purple', 'brown', 'magenta', 'teal', 'yellow', 'gray','black', 'blue', 'green', 'purple', 'brown', 'magenta', 'teal', 'yellow', 'gray', 'black', 'blue', 'green', 'purple', 'brown', 'magenta', 'teal', 'yellow', 'gray']
            

    wd = os.getcwd()
    if not 'tmp' in wd:
        os.mkdir('tmp')
        os.chdir('./tmp')
    if mknewcat:
        #make the reference catalog that the fitting code will use
        fit_all.mkrefcat(ang=0)
    #make a starting reference catalog that we will deviate and use to create simulated measurements.
    #fit_all.mkrefcat(outf='ref_test.txt', ang=0)
        
    ref = Table.read('reference.txt', format='ascii.basic')

    #need to declare a pattern deviation
    t = transforms.PolyTransform(np.ones(10), np.ones(10), np.ones(10), np.ones(10), 4)
    #change this to directly call the astropy.models directly 
    #now we can declare the polynomial coefficients
    #translation = 0
    t.px.c0_0 = 0
    #x scale
    t.px.c1_0 = 0 #-0.00002
    #linear cross term
    t.px.c0_1 = 0 #0.00004
    #quadratic terms
    t.px.c2_0 = 2 * 10**-8
    t.px.c0_2 = 0 #-4 * 10**-9
    t.px.c1_1 =  0# 5 * 10**-10

    t.px.c3_0 = 0 #10**-12
    t.px.c2_1 = 0
    t.px.c1_2 = 0
    t.px.c0_3 = 0

    t.px.c4_0 = 0 #10**-14
    t.px.c3_1 = 0
    t.px.c2_2 = 0
    t.px.c1_3 = 0
    t.px.c0_4 = 0

    t.py.c0_0 =  0
    t.py.c1_0 =  0 # 0.00009
    t.py.c0_1 =  0 #-0.00005

    t.py.c2_0 = 0 # 7 * 10**-10
    t.py.c1_1 =  0 #6  * 10**-9
    t.py.c0_2 =  0 #2* * 10**-9

    t.py.c3_0 = 0 #10**-12
    t.py.c2_1 = 0
    t.py.c1_2 = 0
    t.py.c0_3 = 0

    t.py.c4_0 = 0# 10**-14
    t.py.c3_1 = 0
    t.py.c2_2 = 0
    t.py.c1_3 = 0
    t.py.c0_4 = 0

    
    #now apply this as a function  of reference position
    xmin = 1000
    xmax = 6000
    ymin = 1000
    ymax = 5500
    cb = (ref['x'] < xmax) * (ref['x'] > xmin) * (ref['y'] < ymax) * (ref['y'] > ymin)

    inco = Table.read('best_fit.txt', format='ascii.basic')
    #only keep the linear terms
    if order_pattern == 2:
        #only keep the quadratic trerms from the distortion as pattern deviation
        inco[-9:] = 0.0
        inco[-21:-12] = 0.0
        
    if order_pattern == 3:
        #4th order Y terms
        inco[-5:] = 0
        #2nd order Y terms
        inco[-12:-10] = 0
        #4th order x terms
        inco[-17:-12] = 0
        #2nd order x terms
        inco[-24:-21] = 0

    if order_pattern == 4:
        #3rd order Y terms
        inco[-9:-5] = 0
        #2nd order Y terms
        inco[-12:-9] = 0
        #3rd order x terms
        inco[-21:-18] = 0
        #2nd order x terms
        inco[-24:-21] = 0
    #chop out the linear parameters at the begining of this array
    inco = inco[-30:]

    xmin = 0
    xmax = np.inf
    ymin = 0
    ymax = np.inf
    
    xmin = 965.148
    
    xmax = 7263.57
    
    ymin = 490.87
    ymax = 5218.0615
    rb = (ref['x'] > xmin) * (ref['x'] < xmax) * (ref['y'] < ymax) * (ref['y'] > ymin)
    print('input RMS deviations')
    
    #import pdb;pdb.set_trace()
    dx_pd, dy_pd = fit_all.com_mod(inco['col0'], [ref['x']], [ref['y']], [ref['x']], [ref['y']], order=4, evaluate=True, ret_dist=True)
    print(np.std(dx_pd[0][rb])*6000, np.std(dy_pd[0][rb])*6000)
    #rb2 = np.invert(rb)
    #dx_pd[0][rb2] = 0
    #dy_pd[0][rb2] = 0

    if not pattern_from_distortion:
        dx_pd = 0
        dy_pd = 0
  
    
    if order_pattern_error:
        dx, dy = t.evaluate(ref['x']-np.median(ref['x']), ref['y']-np.median(ref['y']))
    
    else:
        dx = np.zeros(len(ref['x']))
        dy = np.zeros(len(ref['y']))
   # import pdb;pdb.set_trace()
    print(np.std(dx[cb])*6000.0,np.std(dy[cb])*6000.0)
    print(np.min(dx[cb])*6000.0, np.max(dx[cb])*6000.0, np.min(dy[cb])*6000.0, np.max(dy[cb])*6000.0)

    _norm_pattern = scipy.stats.norm(loc=0, scale=pattern_error/6000.0)
    _xerr = _norm_pattern.rvs(len(ref['x']))
    _yerr = _norm_pattern.rvs(len(ref['x']))
    xpin = ref['x'] + _xerr + dx + dx_pd
    ypin = ref['y'] + _yerr + dy +dy_pd
    xpin = np.array(xpin)[0]
    ypin = np.array(ypin)[0]
    plt.close('all')

    if correct_ref:
        _out = ref
        _out['x'] = xpin
        _out['y'] = ypin
        _out.write('reference.txt', format='ascii.basic')

    if debug_plots:
        mkplots_1(ref, dx, dy, _xerr, _yerr, xpin, ypin)
 
    #now we need to apply translation offsets and create the "average stacked catalogs"
    #these are the offsets from s8, used in paper
    #offsets = [[753, 333],[356,336],[7388-7096,5705-7015],[6203-7096,5707-7015],[6173-7055,300--40.6],[1192-40.6,5758-7055.0], [ 1500, 330], [1500, -1300], [0,0]]
    rot_ang = []
    if lab_offsets:
        offsets_s = [[447-40.6, 5894-7055], [770-40.6, 5895-7055], [945-40.6, 5888-7055], [944-40.6, 5644-7055], [697-40.6, 5620-7055], [488-40.6, 5619-7055], [486-40.6, 5376-7055], [745-40.6, 5381-7055], [982-40.6, 5371-7055]]
    #create a square gird (npos x npos) of obsevations at each rot_ang note these are now input keyword arguements
    
    offsets = []
    #rot_ang_l = [0, 90, 180, 270]
    #import pdb;pdb.set_trace()
    for _ang in rot_ang_l:
        if not lab_offsets:
            for i in range(npos):
                for j in range(npos):
                    offsets.append([i * step_size, j * step_size])
                    rot_ang.append(_ang)
        else:
            for k in range(len(offsets_s)):
                
                offsets.append(offsets_s[k])
                rot_ang.append(_ang)
    xlis = []
    ylis = []

    plt.figure(2)
    plt.clf()
    offsets_in = []
    _norm = scipy.stats.norm(loc=0 , scale=err)
    for _iii, _off in enumerate(offsets):
        _ang =  -1.0*np.deg2rad(rot_ang[_iii])
        _xtmp = (xpin-4000)*np.cos(_ang) - (ypin-3000)*np.sin(_ang)
        _ytmp = (ypin-3000)*np.cos(_ang) + (xpin-4000)*np.sin(_ang)
        #now we need to move the measured coordiantes such that the lowest value points (lower left) is at offsets[i][0,1]
        #import pdb;pdb.set_trace()    
        _dx = _off[0]  + 4000
        _dy = _off[1]  + 3000
        
        xlis.append(np.array(_xtmp + _dx))
        ylis.append(np.array(_ytmp + _dy))

        offsets_in.append(((xlis[-1][0]),ylis[-1][0]) )

        #if _ang != 0:
        #    import pdb;pdb.set_trace()
                
        print(offsets_in[-1])

        if debug_plots:
            plt.figure(2)
            plt.scatter(xlis[-1], ylis[-1], label='catalog '+str(_iii))
            plt.title('Measured Position with no distortion')
            plt.legend(loc='upper right')
    
    #this is a 4th order Legendre Polynomial -- measured for single stack s6/pos_1/    
    td = mkdist() #look in def mkdist for details of the current distortion applied
    
    xmax = 8000
    xmin = -1

    ymax = 8000
    ymin = -1

    xln = []
    yln = []
    xrn = []
    yrn = []
    xrnC = []
    yrnC = []
    
    plt.figure(100)
    plt.clf()
    #import pdb;pdb.set_trace()
    for i in range(len(xlis)):
        cbool = (xlis[i] < xmax) * (xlis[i] > xmin) * (ylis[i] < ymax) * (ylis[i] > ymin)
        cbool = np.ones(len(xlis[i]), dtype='bool')
        dxd, dyd = td.evaluate(xlis[i][cbool]-4000.0, ylis[i][cbool]-3000.0)
        print('RMS size of distortion', np.std(dxd)*6000, np.std(dyd)*6000.0, np.median(dxd)*6000, np.median(dyd)*6000)
        #import pdb;pdb.set_trace()
        if not distort:
            dxd = np.zeros(np.sum(cbool))
            dyd = np.zeros(np.sum(cbool))
        if plot_dist:
            
            plt.figure(2200)
            q = plt.quiver(xlis[i][cbool], ylis[i][cbool],dxd, dyd, scale =10, color=colors[i])
            
            plt.quiverkey(q, -50, -50, 1, '6000 nm', coordinates='data', color='red')
                
        #add the distortion term to the measurments
        xln.append(xlis[i][cbool]+dxd+ _norm.rvs(np.sum(cbool)))
        yln.append(ylis[i][cbool]+dyd+ _norm.rvs(np.sum(cbool)))
        #create the array of reference positions that is matched to the measurements
        xrnC.append(xpin[cbool])
        yrnC.append(ypin[cbool])

        #create transformstion for the debugging plots
        tl = transforms.PolyTransform(ref['x'], ref['y'], xln[-1], yln[-1], 1)
        __xn, __yn = tl.evaluate(ref['x'], ref['y'])
        xrn.append(__xn)
        yrn.append(__yn)
        
        if debug_plots:
            #need
            mk_debug_plots(ref, xln, yln) 
        
    #import pdb;pdb.set_trace()
    #now we are ready to run the fitting routine
    #we iterate to allow the reference positions to converge 
    #fit_all.simul_wref(xln,yln,offsets)
    if not fit:
        import pdb;pdb.set_trace()
        init_guess = fit_all.guess_co(xln, yln, xrnC, yrnC, order=order)
        res = leastsq(fit_all.com_mod, init_guess, args=(xln, yln, xrnC, yrnC, fix_trans, init_guess, order))
        outres = fit_all.com_mod(res[0], xln, yln, xrnC, yrnC,fix_trans=fix_trans, order=order, evaluate=False, init_guess=init_guess)
        return outres, res
    if Nmissing is None:
        Nmissing = len(xln)+1
    res = fit_all.simul_wref(xln, yln, offsets_in,  order=order, rot_ang=rot_ang, Niter=Niter, dev_pat=dev_pat, Nmissing=len(xln)+1, sig_clip=False, fourp=False, trim_cam=trim_cam, fix_trans=fix_trans, debug=True, plot_ind=plot_in, trim_pin=False)
   
    
    #import pdb;pdb.set_trace()
    #return 
    #if the fitting procedure has updated reference.txt with fixed coordiantes -> these should match xpin and ypin
    refn = Table.read('reference_new.txt', format='ascii.basic')
    cb = (refn['x'] - refn['xorig']) != 0.0
    __dx = (refn['x'] - xpin) #this is the input deviation
    __dy = (refn['y'] - ypin)
   

    #make scatter plots of the recovered pinhole deviation errors
    plt.figure(2000)
    mkplots_2(refn, xpin, ypin, cb, __dx, __dy)
    #now we compare coefficients to the fit



    fit_all.mksamp(outf='dist_test.txt', order=order)
    _dist = Table.read('dist_test.txt', format='ascii.basic')

    if distort:
        _dxin, _dyin = td.evaluate(_dist['x']-4000, _dist['y']-3000)
    else:
        _dxin = np.zeros(len(_dist['x']))
        _dyin = np.zeros(len(_dist['y']))
    #to do this comparrison you need to eliminate the linear terms in the input distortion
    plt.figure(2005)
    
    #_tl = transforms.PolyTransform(_dist['x']+_dxin, _dist['y']+_dyin, _dist['dx']+_dist['x'], _dist['dy']+_dist['y'], 1)
    _tl = transforms.PolyTransform(_dist['x'], _dist['y'],_dist['dx']+_dxin,_dist['dy']+ _dyin,  1)
    _xmd, _ymd = _tl.evaluate(_dist['x'], _dist['y'])

    #_tl1 = transforms.PolyTransform(_dist['x'], _dist['y'],_dist['dx'], _dist['dy'],  1)
    #_xmd1, _ymd1 = _tl.evaluate(_dist['x'], _dist['y'])
    
    diffx = _dist['dx'] + _dxin  - _xmd
    diffy = _dist['dy'] + _dyin  - _ymd
    import pdb;pdb.set_trace()
    #diffx = _dist['dx']+_dxin
    #diffx = diffx - np.mean(diffx)
    #diffy = _dist['dy']+_dyin
    #diffy = diffy - np.mean(diffy)
    plt.figure(2005)

    plt.scatter(_dist['x'], _dist['y'], c=diffx*6000.0)
    plt.title('X Camera Distortion Meaurement Mistake (model - input)')
    plt.xlabel("X reference (pix)")
    plt.ylabel("Y reference (pix)")
    plt.colorbar()
    plt.tight_layout()

    plt.figure(2006)
    plt.scatter(_dist['x'], _dist['y'], c=diffy*6000.0)
    plt.title('Y Camera Distortion Measurement Mistake (model - input)')
    plt.xlabel("X reference (pix)")
    plt.ylabel("Y reference (pix)")
    plt.colorbar()
    plt.tight_layout()

    plt.figure(2007)
    plt.hist((diffx)*6000.0, histtype='step', label='x', lw=3)
    plt.hist((diffy)*6000.0, histtype='step', label='y', lw=3)
    plt.xlabel("Camera Distortion Meaurement Mistake (model - input)")
    plt.ylabel("N")
    plt.legend(loc='upper left')
    co = Table.read('fit.txt', format='ascii.basic')
Esempio n. 56
0
        #Q1 = plt.quiver(x[::dec,::dec],y[::dec,::dec],Gx[::dec,::dec],Gy[::dec,::dec],
        #                scale=500,width=0.006)
        plot_fig_label(ax, xc=0.95, yc=.05, label="b")
    else:
        plt.contour(x, y, qpsi / (Ue * ke), cq0[2:], colors='k')
        plt.contour(x, y, qpsi / (Ue * ke), cq0[:2], colors='k')
        Q = plt.quiver(x[::dec, ::dec],
                       y[::dec, ::dec],
                       Fwx[::dec, ::dec],
                       Fwy[::dec, ::dec],
                       scale=5e-2,
                       width=0.006)
        qk = plt.quiverkey(Q,
                           0.175,
                           .8285,
                           5e-3,
                           r'$5\times10^{-3}\times\,\,{\mathcal{{\bf F}}}/F$',
                           labelpos='E',
                           coordinates='figure')
        plot_fig_label(ax, xc=0.95, yc=.05, label="a")
    plt.xlim(xlim)
    plt.ylim(xlim)
    ax.set_xlabel(r"$x\times k_e/2\pi$")
    ax.set_xticks([-1., 0, 1])

    if i == 0:
        ax.set_ylabel(r"$y\times k_e/2\pi$")
        ax.set_yticks([-1., 0, 1])
    elif i == 1 or i == 2:
        ax.set_yticks([])
    else:
Esempio n. 57
0
def bin_by_fov(ccd, x, y, dT, de1, de2, bands):

    import numpy as np
    import matplotlib.pyplot as plt
    from toFocal import toFocal

    all_x = np.array([])
    all_y = np.array([])
    all_e1 = np.array([])
    all_e2 = np.array([])
    all_T = np.array([])

    nwhisk = 5
    x_bins = np.linspace(0, 2048, nwhisk + 1)
    y_bins = np.linspace(0, 4096, 2 * nwhisk + 1)

    ccdnums = np.unique(ccd)
    for ccdnum in ccdnums:
        mask = np.where(ccd == ccdnum)[0]
        print('ccdnum = ', ccdnum, ', nstar = ', mask.sum())
        if mask.sum() < 100: continue

        x_index = np.digitize(x[mask], x_bins)
        y_index = np.digitize(y[mask], y_bins)

        bin_de1 = np.array([
            de1[mask][(x_index == i) & (y_index == j)].mean()
            for i in range(1, len(x_bins)) for j in range(1, len(y_bins))
        ])
        print('bin_de1 = ', bin_de1)
        bin_de2 = np.array([
            de2[mask][(x_index == i) & (y_index == j)].mean()
            for i in range(1, len(x_bins)) for j in range(1, len(y_bins))
        ])
        print('bin_de2 = ', bin_de2)
        bin_dT = np.array([
            dT[mask][(x_index == i) & (y_index == j)].mean()
            for i in range(1, len(x_bins)) for j in range(1, len(y_bins))
        ])
        print('bin_dT = ', bin_dT)
        bin_x = np.array([
            x[mask][(x_index == i) & (y_index == j)].mean()
            for i in range(1, len(x_bins)) for j in range(1, len(y_bins))
        ])
        print('bin_x = ', bin_x)
        bin_y = np.array([
            y[mask][(x_index == i) & (y_index == j)].mean()
            for i in range(1, len(x_bins)) for j in range(1, len(y_bins))
        ])
        print('bin_y = ', bin_y)
        bin_count = np.array([((x_index == i) & (y_index == j)).sum()
                              for i in range(1, len(x_bins))
                              for j in range(1, len(y_bins))])
        print('bin_count = ', bin_count)

        focal_x, focal_y = toFocal(ccdnum, bin_x, bin_y)

        mask2 = np.where(bin_count > 0)[0]
        print('num with count > 0 = ', mask2.sum())
        all_x = np.append(all_x, focal_x[mask2])
        all_y = np.append(all_y, focal_y[mask2])
        all_e1 = np.append(all_e1, bin_de1[mask2])
        all_e2 = np.append(all_e2, bin_de2[mask2])
        all_T = np.append(all_T, bin_dT[mask2])

    plt.clf()
    #plt.title('PSF Ellipticity residuals in DES focal plane')
    theta = np.arctan2(all_e2, all_e1) / 2.
    r = np.sqrt(all_e1**2 + all_e2**2)
    u = r * np.cos(theta)
    v = r * np.sin(theta)
    plt.xlim(-250, 250)
    plt.ylim(-250, 250)
    print('all_x = ', all_x)
    print('len(all_x) = ', len(all_x))
    qv = plt.quiver(all_x,
                    all_y,
                    u,
                    v,
                    pivot='middle',
                    scale_units='xy',
                    headwidth=0.,
                    headlength=0.,
                    headaxislength=0.,
                    width=0.001,
                    scale=1.e-3,
                    color='blue')
    ref_scale = 0.01
    if 'raw' in bands:
        ref_label = 'e = ' + str(ref_scale)
    else:
        ref_label = 'de = ' + str(ref_scale)
    plt.quiverkey(qv,
                  0.10,
                  0.08,
                  ref_scale,
                  ref_label,
                  coordinates='axes',
                  color='darkred',
                  labelcolor='darkred',
                  labelpos='E',
                  fontproperties={'size': 'x-small'})
    plt.axis('off')
    plt.savefig('de_fov_' + bands + '.png')
    plt.savefig('de_fov_' + bands + '.pdf')
    plt.savefig('de_fov_' + bands + '.eps')
Esempio n. 58
0
    def plot(self,
             timedata=None,
             udata=None,
             vdata=None,
             ylabel=None,
             **kwargs):

        if kwargs['rotate'] != 0.0:
            #when rotating vectors - positive(+) rotation is equal to cw of the axis (ccw of vector)
            #                      - negative(+) rotation is equal to ccw of the axis (cw of the vector)
            print "rotating vectors"
            angle_offset_rad = np.deg2rad(kwargs['rotate'])
            udata = udata * np.cos(angle_offset_rad) + vdata * np.sin(
                angle_offset_rad)
            vdata = -1. * udata * np.sin(angle_offset_rad) + vdata * np.cos(
                angle_offset_rad)

        magnitude = np.sqrt(udata**2 + vdata**2)

        fig = plt.figure(1)
        ax1 = plt.subplot2grid((2, 1), (0, 0), colspan=1, rowspan=1)
        ax2 = plt.subplot2grid((2, 1), (1, 0), colspan=1, rowspan=1)

        # Plot u and v components
        # Plot quiver
        ax1.set_ylim(-1 * np.nanmax(magnitude), np.nanmax(magnitude))
        fill1 = ax1.fill_between(timedata, magnitude, 0, color='k', alpha=0.1)

        # Fake 'box' to be able to insert a legend for 'Magnitude'
        p = ax1.add_patch(plt.Rectangle((1, 1), 1, 1, fc='k', alpha=0.1))
        leg1 = ax1.legend([p], ["Current magnitude [cm/s]"], loc='lower right')
        leg1._drawFrame = False

        # 1D Quiver plot
        q = ax1.quiver(timedata,
                       0,
                       udata,
                       vdata,
                       color='r',
                       units='y',
                       scale_units='y',
                       scale=1,
                       headlength=1,
                       headaxislength=1,
                       width=0.04,
                       alpha=.95)
        qk = plt.quiverkey(q,
                           0.2,
                           0.05,
                           5,
                           r'$5 \frac{cm}{s}$',
                           labelpos='W',
                           fontproperties={'weight': 'bold'})

        # Plot u and v components
        ax1.set_xticklabels(ax1.get_xticklabels(), visible=False)
        ax2.set_xticklabels(ax2.get_xticklabels(), visible=True)
        ax1.axes.get_xaxis().set_visible(False)
        ax1.set_xlim(timedata.min() - 0.5, timedata.max() + 0.5)
        ax1.set_ylabel("Velocity (cm/s)")
        ax2.plot(timedata, vdata, 'b-', linewidth=0.25)
        ax2.plot(timedata, udata, 'g-', linewidth=0.25)
        ax2.set_xlim(timedata.min() - 0.5, timedata.max() + 0.5)
        ax2.set_xlabel("Date (UTC)")
        ax2.set_ylabel("Velocity (cm/s)")
        ax2.xaxis.set_major_locator(MonthLocator())
        ax2.xaxis.set_minor_locator(
            MonthLocator(bymonth=range(1, 13), bymonthday=15))
        ax2.xaxis.set_major_formatter(ticker.NullFormatter())
        ax2.xaxis.set_minor_formatter(DateFormatter('%b %y'))
        ax1.spines['bottom'].set_visible(False)
        ax2.spines['top'].set_visible(False)
        ax1.xaxis.set_ticks_position('top')
        ax2.xaxis.set_ticks_position('bottom')
        ax2.yaxis.set_ticks_position('both')
        ax2.tick_params(axis='both', which='minor', labelsize=self.labelsize)
        ax1.tick_params(axis='both', which='minor', labelsize=self.labelsize)
        #manual time limit sets
        #ax1.set_xlim([datetime.datetime(2016,2,1),datetime.datetime(2016,9,15)])
        #ax2.set_xlim([datetime.datetime(2016,2,1),datetime.datetime(2016,9,15)])
        # Set legend location - See: http://matplotlib.org/Volumes/WDC_internal/users/legend_guide.html#legend-location
        leg2 = plt.legend(['v', 'u'], loc='upper left')
        leg2._drawFrame = False

        return plt, fig
ax.set_xticks(np.arange(40,80,10))
ax.set_xticklabels((r'$40^o$E', r'$50^o$E', r'$60^o$E', r'$70^o$E'))
ax.set_yticks(np.arange(-20,10,10))
ax.set_yticklabels((r'$20^o$S', r'$10^o$S', r'$0^o$S'))
ax.text(0.03, 0.88, 'h)',
        transform=ax.transAxes, bbox=dict(facecolor='white',
         alpha=0.5), color='k', fontsize=14)

#plt.axis([51.63, 58.36, -8.9, -1.06])
plt.axis([42, 65, -18, 3])
# fig.suptitle('ssh clim 1993-2009')
fig.subplots_adjust(left=0.07, right=0.9, hspace=0.03, wspace=0.01)
cbar_ax = fig.add_axes([0.91, 0.15, 0.02, 0.7])
cbar = fig.colorbar(ctop, cax=cbar_ax, extend='both', ticks=np.arange(-10,12,2))
cbar.set_label('[cm]')
qk = plt.quiverkey(Q, 0.90, 0.08, 10, r'$10 \frac{cm}{s}$', labelpos='E',
                   coordinates='figure')
plt.savefig('aviso_pop_comp_seas_large.pdf', bbox_inches='tight')



# Calculate the monthly average - the 19 year average
uavg_sat = u_sat.mean(0)
vavg_sat = v_sat.mean(0)
sshavg_sat = ssh_sat.mean(0)
uavg_pop = u_pop.mean(0)
vavg_pop = v_pop.mean(0)
sshavg_pop = ssh_pop.mean(0)

colori = cmocean.cm.balance
colori = cm.bwr
li = 4
    q = ax1.quiver(xdate,
                   0,
                   ucomp,
                   vcomp,
                   color='r',
                   units='y',
                   scale_units='y',
                   scale=1,
                   headlength=2,
                   headaxislength=2,
                   width=0.1,
                   alpha=.95)
    qk = plt.quiverkey(q,
                       0.2,
                       0.05,
                       5,
                       r'$5 \frac{m}{s}$',
                       labelpos='W',
                       fontproperties={'weight': 'bold'})

    ax1.set_ylim(vcomp.min(), vcomp.max())
    ax1.set_ylabel("(m/s)")
    ax1.set_xlim(
        datetime.datetime(2010 + i - 1, 8, 01).toordinal(),
        datetime.datetime(2011 + i - 1, 10, 31).toordinal())
    ax1.xaxis.set_major_locator(MonthLocator())
    ax1.xaxis.set_minor_locator(
        MonthLocator(bymonth=range(1, 13), bymonthday=15))
    ax1.xaxis.set_major_formatter(ticker.NullFormatter())
    ax1.xaxis.set_minor_formatter(DateFormatter('%b %y'))
    ax1.tick_params(axis='both', which='minor', labelsize=12)