Context Navigation

source: lmdz_wrf/trunk/tools/drawing_tools.py @ 740

Last change on this file since 740 was 705, checked in by lfita, 9 years ago
Adding `draw_river_desc' to plot rivers' description after` river_desc.nc' from ORCDHIEE
File size: 236.1 KB

Rev	Line
[192]	1	# -- coding: iso-8859-15 --
	2	#import pylab as plt
	3	# From http://stackoverflow.com/questions/13336823/matplotlib-python-error
	4	import numpy as np
	5	import matplotlib as mpl
	6	mpl.use('Agg')
[705]	7	from matplotlib.pylab import *
[192]	8	import matplotlib.pyplot as plt
	9	from mpl_toolkits.basemap import Basemap
	10	import os
	11	from netCDF4 import Dataset as NetCDFFile
[341]	12	import nc_var_tools as ncvar
[192]	13
	14	errormsg = 'ERROR -- error -- ERROR -- error'
	15	warnmsg = 'WARNING -- waring -- WARNING -- warning'
	16
	17	fillValue = 1.e20
[560]	18	fillValueF = 1.e20
[192]	19
[687]	20	colorsauto = ['#FF0000', '#00FF00', '#0000FF', '#FF00FF', '#00FFFF', '#FFAA00', \
	21	'#AA0000', '#00AA00', '#0000AA', '#AA00AA', '#00AAAA', '#AA3200']
[681]	22	pointkindsauto = ['.', ',', 'x', '+', '*', '\|', '_', 'o', '<', '>', 'v', '^', \
[682]	23	's', 'D', 'p' ,'h' ,'H']
[683]	24	linekindsauto = ['-', '--', '-.', ':']
[687]	25	linewidthsauto = [1.]
	26	pointsizesauto = [7.]
[681]	27
[192]	28	####### Funtions
	29	# searchInlist:
	30	# datetimeStr_datetime:
	31	# dateStr_date:
	32	# numVector_String:
	33	# timeref_datetime:
[637]	34	# slice_variable: Function to return a slice of a given variable according to values to its dimension
[192]	35	# interpolate_locs:
	36	# datetimeStr_conversion:
	37	# percendone:
	38	# netCDFdatetime_realdatetime:
	39	# file_nlines:
	40	# variables_values:
	41	# check_colorBar:
	42	# units_lunits:
	43	# ASCII_LaTeX:
	44	# pretty_int:
	45	# DegGradSec_deg:
	46	# intT2dt:
[698]	47	# lonlat2D: Function to return lon, lat 2D matrices from any lon,lat matrix
[192]	48	# lonlat_values:
	49	# date_CFtime:
	50	# pot_values:
	51	# CFtimes_plot:
	52	# color_lines:
	53	# output_kind:
	54	# check_arguments:
	55	# Str_Bool:
	56	# plot_points:
	57	# plot_2Dfield:
	58	# plot_2Dfield_easy:
	59	# plot_topo_geogrid:
	60	# plot_topo_geogrid_boxes:
	61	# plot_2D_shadow:
	62	# plot_2D_shadow_time: Plotting a 2D field with one of the axes being time
	63	# plot_Neighbourghood_evol:Plotting neighbourghood evolution# plot_Trajectories
	64	# plot_2D_shadow_contour:
	65	# plot_2D_shadow_contour_time:
	66	# dxdy_lonlat: Function to provide lon/lat 2D lilke-matrices from any sort of dx,dy values
	67	# plot_2D_shadow_line:
	68	# plot_lines: Function to plot a collection of lines
[625]	69	# plot_ZQradii: Function to plot following radial averages only at exact grid poins
[192]	70
	71	# From nc_var_tools.py
[545]	72	def reduce_spaces(string):
	73	""" Function to give words of a line of text removing any extra space
	74	"""
	75	values = string.replace('\n','').split(' ')
	76	vals = []
	77	for val in values:
	78	if len(val) > 0:
	79	vals.append(val)
	80
	81	return vals
	82
[192]	83	def searchInlist(listname, nameFind):
	84	""" Function to search a value within a list
	85	listname = list
	86	nameFind = value to find
	87	>>> searInlist(['1', '2', '3', '5'], '5')
	88	True
	89	"""
	90	for x in listname:
	91	if x == nameFind:
	92	return True
[539]	93	break
[192]	94	return False
	95
	96	def datetimeStr_datetime(StringDT):
	97	""" Function to transform a string date ([YYYY]-[MM]-[DD]_[HH]:[MI]:[SS] format) to a date object
	98	>>> datetimeStr_datetime('1976-02-17_00:00:00')
	99	1976-02-17 00:00:00
	100	"""
	101	import datetime as dt
	102
	103	fname = 'datetimeStr_datetime'
	104
	105	dateD = np.zeros((3), dtype=int)
	106	timeT = np.zeros((3), dtype=int)
	107
[655]	108	# quit()
	109
[192]	110	dateD[0] = int(StringDT[0:4])
	111	dateD[1] = int(StringDT[5:7])
	112	dateD[2] = int(StringDT[8:10])
	113
	114	trefT = StringDT.find(':')
	115	if not trefT == -1:
	116	# print ' ' + fname + ': refdate with time!'
	117	timeT[0] = int(StringDT[11:13])
	118	timeT[1] = int(StringDT[14:16])
	119	timeT[2] = int(StringDT[17:19])
	120
	121	if int(dateD[0]) == 0:
	122	print warnmsg
	123	print ' ' + fname + ': 0 reference year!! changing to 1'
	124	dateD[0] = 1
	125
	126	newdatetime = dt.datetime(dateD[0], dateD[1], dateD[2], timeT[0], timeT[1], timeT[2])
	127
	128	return newdatetime
	129
	130	def dateStr_date(StringDate):
	131	""" Function to transform a string date ([YYYY]-[MM]-[DD] format) to a date object
	132	>>> dateStr_date('1976-02-17')
	133	1976-02-17
	134	"""
	135	import datetime as dt
	136
	137	dateD = StringDate.split('-')
	138	if int(dateD[0]) == 0:
	139	print warnmsg
	140	print ' dateStr_date: 0 reference year!! changing to 1'
	141	dateD[0] = 1
	142	newdate = dt.date(int(dateD[0]), int(dateD[1]), int(dateD[2]))
	143	return newdate
	144
	145	def numVector_String(vec,char):
	146	""" Function to transform a vector of numbers to a single string [char] separated
	147	numVector_String(vec,char)
	148	vec= vector with the numerical values
	149	char= single character to split the values
	150	>>> print numVector_String(np.arange(10),' ')
	151	0 1 2 3 4 5 6 7 8 9
	152	"""
	153	fname = 'numVector_String'
	154
	155	if vec == 'h':
	156	print fname + '_____________________________________________________________'
	157	print numVector_String.__doc__
	158	quit()
	159
	160	Nvals = len(vec)
	161
	162	string=''
	163	for i in range(Nvals):
	164	if i == 0:
	165	string = str(vec[i])
	166	else:
	167	string = string + char + str(vec[i])
	168
	169	return string
	170
	171	def timeref_datetime(refd, timeval, tu):
	172	""" Function to transform from a [timeval] in [tu] units from the time referece [tref] to datetime object
	173	refd: time of reference (as datetime object)
	174	timeval: time value (as [tu] from [tref])
	175	tu: time units
	176	>>> timeref = date(1949,12,1,0,0,0)
	177	>>> timeref_datetime(timeref, 229784.36, hours)
	178	1976-02-17 08:21:36
	179	"""
	180	import datetime as dt
	181	import numpy as np
	182
	183	## Not in timedelta
	184	# if tu == 'years':
	185	# realdate = refdate + dt.timedelta(years=float(timeval))
	186	# elif tu == 'months':
	187	# realdate = refdate + dt.timedelta(months=float(timeval))
	188	if tu == 'weeks':
	189	realdate = refd + dt.timedelta(weeks=float(timeval))
	190	elif tu == 'days':
	191	realdate = refd + dt.timedelta(days=float(timeval))
	192	elif tu == 'hours':
	193	realdate = refd + dt.timedelta(hours=float(timeval))
	194	elif tu == 'minutes':
	195	realdate = refd + dt.timedelta(minutes=float(timeval))
	196	elif tu == 'seconds':
	197	realdate = refd + dt.timedelta(seconds=float(timeval))
	198	elif tu == 'milliseconds':
	199	realdate = refd + dt.timedelta(milliseconds=float(timeval))
	200	else:
	201	print errormsg
	202	print ' timeref_datetime: time units "' + tu + '" not ready!!!!'
	203	quit(-1)
	204
	205	return realdate
	206
	207	def slice_variable(varobj, dimslice):
	208	""" Function to return a slice of a given variable according to values to its
	209	dimensions
	210	slice_variable(varobj, dims)
	211	varobj= object wit the variable
	212	dimslice= [[dimname1]:[value1]\|[[dimname2]:[value2], ...] pairs of dimension
	213	[value]:
	214	* [integer]: which value of the dimension
	215	* -1: all along the dimension
	216	* [beg]:[end] slice from [beg] to [end]
[652]	217	* -9: last value of the dimension
	218
[192]	219	"""
	220	fname = 'slice_variable'
	221
	222	if varobj == 'h':
	223	print fname + '_____________________________________________________________'
	224	print slice_variable.__doc__
	225	quit()
	226
	227	vardims = varobj.dimensions
	228	Ndimvar = len(vardims)
	229
	230	Ndimcut = len(dimslice.split('\|'))
[396]	231	if Ndimcut == 0:
	232	Ndimcut = 1
	233	dimcut = list(dimslice)
	234
[192]	235	dimsl = dimslice.split('\|')
	236
	237	varvalsdim = []
	238	dimnslice = []
[652]	239	monodim = []
[192]	240	for idd in range(Ndimvar):
[396]	241	found = False
[192]	242	for idc in range(Ndimcut):
	243	dimcutn = dimsl[idc].split(':')[0]
	244	dimcutv = dimsl[idc].split(':')[1]
[396]	245	if vardims[idd] == dimcutn:
	246	posfrac = dimcutv.find('@')
[192]	247	if posfrac != -1:
[396]	248	inifrac = int(dimcutv.split('@')[0])
	249	endfrac = int(dimcutv.split('@')[1])
[192]	250	varvalsdim.append(slice(inifrac,endfrac))
	251	dimnslice.append(vardims[idd])
	252	else:
	253	if int(dimcutv) == -1:
	254	varvalsdim.append(slice(0,varobj.shape[idd]))
	255	dimnslice.append(vardims[idd])
[396]	256	elif int(dimcutv) == -9:
[652]	257	varvalsdim.append(varobj.shape[idd]-1)
	258	monodim.append(vardims[idd])
[192]	259	else:
	260	varvalsdim.append(int(dimcutv))
[652]	261	monodim.append(vardims[idd])
[399]	262	found = True
[192]	263	break
[652]	264	if not found and not searchInlist(dimnslice,vardims[idd]) and \
	265	not searchInlist(monodim,vardims[idd]):
[396]	266	varvalsdim.append(slice(0,varobj.shape[idd]))
	267	dimnslice.append(vardims[idd])
[192]	268	varvalues = varobj[tuple(varvalsdim)]
	269
[652]	270	varvalues = np.squeeze(varobj[tuple(varvalsdim)])
	271
[192]	272	return varvalues, dimnslice
	273
	274	def interpolate_locs(locs,coords,kinterp):
	275	""" Function to provide interpolate locations on a given axis
	276	interpolate_locs(locs,axis,kinterp)
	277	locs= locations to interpolate
	278	coords= axis values with the reference of coordinates
	279	kinterp: kind of interpolation
	280	'lin': linear
	281	>>> coordinates = np.arange((10), dtype=np.float)
	282	>>> values = np.array([-1.2, 2.4, 5.6, 7.8, 12.0])
	283	>>> interpolate_locs(values,coordinates,'lin')
	284	[ -1.2 2.4 5.6 7.8 13. ]
	285	>>> coordinates[0] = 0.5
	286	>>> coordinates[2] = 2.5
	287	>>> interpolate_locs(values,coordinates,'lin')
	288	[ -3.4 1.93333333 5.6 7.8 13. ]
	289	"""
	290
	291	fname = 'interpolate_locs'
	292
	293	if locs == 'h':
	294	print fname + '_____________________________________________________________'
	295	print interpolate_locs.__doc__
	296	quit()
	297
	298	Nlocs = locs.shape[0]
	299	Ncoords = coords.shape[0]
	300
	301	dcoords = coords[Ncoords-1] - coords[0]
	302
	303	intlocs = np.zeros((Nlocs), dtype=np.float)
	304	minc = np.min(coords)
	305	maxc = np.max(coords)
	306
	307	for iloc in range(Nlocs):
	308	for icor in range(Ncoords-1):
	309	if locs[iloc] < minc and dcoords > 0.:
	310	a = 0.
	311	b = 1. / (coords[1] - coords[0])
	312	c = coords[0]
	313	elif locs[iloc] > maxc and dcoords > 0.:
	314	a = (Ncoords-1)*1.
	315	b = 1. / (coords[Ncoords-1] - coords[Ncoords-2])
	316	c = coords[Ncoords-2]
	317	elif locs[iloc] < minc and dcoords < 0.:
	318	a = (Ncoords-1)*1.
	319	b = 1. / (coords[Ncoords-1] - coords[Ncoords-2])
	320	c = coords[Ncoords-2]
	321	elif locs[iloc] > maxc and dcoords < 0.:
	322	a = 0.
	323	b = 1. / (coords[1] - coords[0])
	324	c = coords[0]
	325	elif locs[iloc] >= coords[icor] and locs[iloc] < coords[icor+1] and dcoords > 0.:
	326	a = icor*1.
	327	b = 1. / (coords[icor+1] - coords[icor])
	328	c = coords[icor]
	329	print coords[icor], locs[iloc], coords[icor+1], ':', icor, '->', a, b
	330	elif locs[iloc] <= coords[icor] and locs[iloc] > coords[icor+1] and dcoords < 0.:
	331	a = icor*1.
	332	b = 1. / (coords[icor+1] - coords[icor])
	333	c = coords[icor]
	334
	335	if kinterp == 'lin':
	336	intlocs[iloc] = a + (locs[iloc] - c)*b
	337	else:
	338	print errormsg
	339	print ' ' + fname + ": interpolation kind '" + kinterp + "' not ready !!!!!"
	340	quit(-1)
	341
	342	return intlocs
	343
	344	def datetimeStr_conversion(StringDT,typeSi,typeSo):
	345	""" Function to transform a string date to an another date object
	346	StringDT= string with the date and time
	347	typeSi= type of datetime string input
	348	typeSo= type of datetime string output
	349	[typeSi/o]
	350	'cfTime': [time],[units]; ]time in CF-convention format [units] = [tunits] since [refdate]
	351	'matYmdHMS': numerical vector with [[YYYY], [MM], [DD], [HH], [MI], [SS]]
	352	'YmdHMS': [YYYY][MM][DD][HH][MI][SS] format
	353	'Y-m-d_H:M:S': [YYYY]-[MM]-[DD]_[HH]:[MI]:[SS] format
	354	'Y-m-d H:M:S': [YYYY]-[MM]-[DD] [HH]:[MI]:[SS] format
	355	'Y/m/d H-M-S': [YYYY]/[MM]/[DD] [HH]-[MI]-[SS] format
	356	'WRFdatetime': [Y], [Y], [Y], [Y], '-', [M], [M], '-', [D], [D], '_', [H],
	357	[H], ':', [M], [M], ':', [S], [S]
	358	>>> datetimeStr_conversion('1976-02-17_08:32:05','Y-m-d_H:M:S','matYmdHMS')
	359	[1976 2 17 8 32 5]
	360	>>> datetimeStr_conversion(str(137880)+',minutes since 1979-12-01_00:00:00','cfTime','Y/m/d H-M-S')
	361	1980/03/05 18-00-00
	362	"""
	363	import datetime as dt
	364
	365	fname = 'datetimeStr_conversion'
	366
	367	if StringDT[0:1] == 'h':
	368	print fname + '_____________________________________________________________'
	369	print datetimeStr_conversion.__doc__
	370	quit()
	371
	372	if typeSi == 'cfTime':
	373	timeval = np.float(StringDT.split(',')[0])
	374	tunits = StringDT.split(',')[1].split(' ')[0]
	375	Srefdate = StringDT.split(',')[1].split(' ')[2]
	376
	377	# Does reference date contain a time value [YYYY]-[MM]-[DD] [HH]:[MI]:[SS]
	378	##
	379	yrref=Srefdate[0:4]
	380	monref=Srefdate[5:7]
	381	dayref=Srefdate[8:10]
	382
	383	trefT = Srefdate.find(':')
	384	if not trefT == -1:
	385	# print ' ' + fname + ': refdate with time!'
	386	horref=Srefdate[11:13]
	387	minref=Srefdate[14:16]
	388	secref=Srefdate[17:19]
	389	refdate = datetimeStr_datetime( yrref + '-' + monref + '-' + dayref + \
	390	'_' + horref + ':' + minref + ':' + secref)
	391	else:
	392	refdate = datetimeStr_datetime( yrref + '-' + monref + '-' + dayref + \
	393	+ '_00:00:00')
	394
	395	if tunits == 'weeks':
	396	newdate = refdate + dt.timedelta(weeks=float(timeval))
	397	elif tunits == 'days':
	398	newdate = refdate + dt.timedelta(days=float(timeval))
	399	elif tunits == 'hours':
	400	newdate = refdate + dt.timedelta(hours=float(timeval))
	401	elif tunits == 'minutes':
	402	newdate = refdate + dt.timedelta(minutes=float(timeval))
	403	elif tunits == 'seconds':
	404	newdate = refdate + dt.timedelta(seconds=float(timeval))
	405	elif tunits == 'milliseconds':
	406	newdate = refdate + dt.timedelta(milliseconds=float(timeval))
	407	else:
	408	print errormsg
	409	print ' timeref_datetime: time units "' + tunits + '" not ready!!!!'
	410	quit(-1)
	411
	412	yr = newdate.year
	413	mo = newdate.month
	414	da = newdate.day
	415	ho = newdate.hour
	416	mi = newdate.minute
	417	se = newdate.second
	418	elif typeSi == 'matYmdHMS':
	419	yr = StringDT[0]
	420	mo = StringDT[1]
	421	da = StringDT[2]
	422	ho = StringDT[3]
	423	mi = StringDT[4]
	424	se = StringDT[5]
	425	elif typeSi == 'YmdHMS':
	426	yr = int(StringDT[0:4])
	427	mo = int(StringDT[4:6])
	428	da = int(StringDT[6:8])
	429	ho = int(StringDT[8:10])
	430	mi = int(StringDT[10:12])
	431	se = int(StringDT[12:14])
	432	elif typeSi == 'Y-m-d_H:M:S':
	433	dateDT = StringDT.split('_')
	434	dateD = dateDT[0].split('-')
	435	timeT = dateDT[1].split(':')
	436	yr = int(dateD[0])
	437	mo = int(dateD[1])
	438	da = int(dateD[2])
	439	ho = int(timeT[0])
	440	mi = int(timeT[1])
	441	se = int(timeT[2])
	442	elif typeSi == 'Y-m-d H:M:S':
	443	dateDT = StringDT.split(' ')
	444	dateD = dateDT[0].split('-')
	445	timeT = dateDT[1].split(':')
	446	yr = int(dateD[0])
	447	mo = int(dateD[1])
	448	da = int(dateD[2])
	449	ho = int(timeT[0])
	450	mi = int(timeT[1])
	451	se = int(timeT[2])
	452	elif typeSi == 'Y/m/d H-M-S':
	453	dateDT = StringDT.split(' ')
	454	dateD = dateDT[0].split('/')
	455	timeT = dateDT[1].split('-')
	456	yr = int(dateD[0])
	457	mo = int(dateD[1])
	458	da = int(dateD[2])
	459	ho = int(timeT[0])
	460	mi = int(timeT[1])
	461	se = int(timeT[2])
	462	elif typeSi == 'WRFdatetime':
	463	yr = int(StringDT[0])1000 + int(StringDT[1])100 + int(StringDT[2])*10 + \
	464	int(StringDT[3])
	465	mo = int(StringDT[5])*10 + int(StringDT[6])
	466	da = int(StringDT[8])*10 + int(StringDT[9])
	467	ho = int(StringDT[11])*10 + int(StringDT[12])
	468	mi = int(StringDT[14])*10 + int(StringDT[15])
	469	se = int(StringDT[17])*10 + int(StringDT[18])
	470	else:
	471	print errormsg
	472	print ' ' + fname + ': type of String input date "' + typeSi + \
	473	'" not ready !!!!'
	474	quit(-1)
	475
	476	if typeSo == 'matYmdHMS':
	477	dateYmdHMS = np.zeros((6), dtype=int)
	478	dateYmdHMS[0] = yr
	479	dateYmdHMS[1] = mo
	480	dateYmdHMS[2] = da
	481	dateYmdHMS[3] = ho
	482	dateYmdHMS[4] = mi
	483	dateYmdHMS[5] = se
	484	elif typeSo == 'YmdHMS':
	485	dateYmdHMS = str(yr).zfill(4) + str(mo).zfill(2) + str(da).zfill(2) + \
	486	str(ho).zfill(2) + str(mi).zfill(2) + str(se).zfill(2)
	487	elif typeSo == 'Y-m-d_H:M:S':
	488	dateYmdHMS = str(yr).zfill(4) + '-' + str(mo).zfill(2) + '-' + \
	489	str(da).zfill(2) + '_' + str(ho).zfill(2) + ':' + str(mi).zfill(2) + ':' + \
	490	str(se).zfill(2)
	491	elif typeSo == 'Y-m-d H:M:S':
	492	dateYmdHMS = str(yr).zfill(4) + '-' + str(mo).zfill(2) + '-' + \
	493	str(da).zfill(2) + ' ' + str(ho).zfill(2) + ':' + str(mi).zfill(2) + ':' + \
	494	str(se).zfill(2)
	495	elif typeSo == 'Y/m/d H-M-S':
	496	dateYmdHMS = str(yr).zfill(4) + '/' + str(mo).zfill(2) + '/' + \
	497	str(da).zfill(2) + ' ' + str(ho).zfill(2) + '-' + str(mi).zfill(2) + '-' + \
	498	str(se).zfill(2)
	499	elif typeSo == 'WRFdatetime':
	500	dateYmdHMS = []
	501	yM = yr/1000
	502	yC = (yr-yM*1000)/100
	503	yD = (yr-yM1000-yC100)/10
	504	yU = yr-yM1000-yC100-yD*10
	505
	506	mD = mo/10
	507	mU = mo-mD*10
	508
	509	dD = da/10
	510	dU = da-dD*10
	511
	512	hD = ho/10
	513	hU = ho-hD*10
	514
	515	miD = mi/10
	516	miU = mi-miD*10
	517
	518	sD = se/10
	519	sU = se-sD*10
	520
	521	dateYmdHMS.append(str(yM))
	522	dateYmdHMS.append(str(yC))
	523	dateYmdHMS.append(str(yD))
	524	dateYmdHMS.append(str(yU))
	525	dateYmdHMS.append('-')
	526	dateYmdHMS.append(str(mD))
	527	dateYmdHMS.append(str(mU))
	528	dateYmdHMS.append('-')
	529	dateYmdHMS.append(str(dD))
	530	dateYmdHMS.append(str(dU))
	531	dateYmdHMS.append('_')
	532	dateYmdHMS.append(str(hD))
	533	dateYmdHMS.append(str(hU))
	534	dateYmdHMS.append(':')
	535	dateYmdHMS.append(str(miD))
	536	dateYmdHMS.append(str(miU))
	537	dateYmdHMS.append(':')
	538	dateYmdHMS.append(str(sD))
	539	dateYmdHMS.append(str(sU))
	540	else:
	541	print errormsg
	542	print ' ' + fname + ': type of output date "' + typeSo + '" not ready !!!!'
	543	quit(-1)
	544
	545	return dateYmdHMS
	546
	547	def percendone(nvals,tot,percen,msg):
	548	""" Function to provide the percentage of an action across the matrix
	549	nvals=number of values
	550	tot=total number of values
	551	percen=percentage frequency for which the message is wanted
	552	msg= message
	553	"""
	554	from sys import stdout
	555
	556	num = int(tot * percen/100)
	557	if (nvals%num == 0):
	558	print '\r ' + msg + '{0:8.3g}'.format(nvals*100./tot) + ' %',
	559	stdout.flush()
	560
	561	return ''
	562
	563	def netCDFdatetime_realdatetime(units, tcalendar, times):
	564	""" Function to transfrom from netCDF CF-compilant times to real time
	565	"""
	566	import datetime as dt
	567
	568	txtunits = units.split(' ')
	569	tunits = txtunits[0]
	570	Srefdate = txtunits[len(txtunits) - 1]
	571
	572	# Calendar type
	573	##
	574	is360 = False
	575	if tcalendar is not None:
	576	print ' netCDFdatetime_realdatetime: There is a calendar attribute'
	577	if tcalendar == '365_day' or tcalendar == 'noleap':
	578	print ' netCDFdatetime_realdatetime: No leap years!'
	579	isleapcal = False
	580	elif tcalendar == 'proleptic_gregorian' or tcalendar == 'standard' or tcalendar == 'gregorian':
	581	isleapcal = True
	582	elif tcalendar == '360_day':
	583	is360 = True
	584	isleapcal = False
	585	else:
	586	print errormsg
	587	print ' netCDFdatetime_realdatetime: Calendar "' + tcalendar + '" not prepared!'
	588	quit(-1)
	589
	590	# Does reference date contain a time value [YYYY]-[MM]-[DD] [HH]:[MI]:[SS]
	591	##
	592	timeval = Srefdate.find(':')
	593
	594	if not timeval == -1:
	595	print ' netCDFdatetime_realdatetime: refdate with time!'
	596	refdate = datetimeStr_datetime(Srefdate)
	597	else:
	598	refdate = dateStr_date(Srefdate + '_00:00:00')
	599
	600	dimt = len(times)
	601	# datetype = type(dt.datetime(1972,02,01))
	602	# realdates = np.array(dimt, datetype)
	603	# print realdates
	604
	605	## Not in timedelta
	606	# if tunits == 'years':
	607	# for it in range(dimt):
	608	# realdate = refdate + dt.timedelta(years=float(times[it]))
	609	# realdates[it] = int(realdate.year)
	610	# elif tunits == 'months':
	611	# for it in range(dimt):
	612	# realdate = refdate + dt.timedelta(months=float(times[it]))
	613	# realdates[it] = int(realdate.year)
	614	# realdates = []
	615	realdates = np.zeros((dimt, 6), dtype=int)
	616	if tunits == 'weeks':
	617	for it in range(dimt):
	618	realdate = refdate + dt.timedelta(weeks=float(times[it]))
	619	realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
	620	elif tunits == 'days':
	621	for it in range(dimt):
	622	realdate = refdate + dt.timedelta(days=float(times[it]))
	623	realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
	624	elif tunits == 'hours':
	625	for it in range(dimt):
	626	realdate = refdate + dt.timedelta(hours=float(times[it]))
	627	# if not isleapcal:
	628	# Nleapdays = cal.leapdays(int(refdate.year), int(realdate.year))
	629	# realdate = realdate - dt.timedelta(days=Nleapdays)
	630	# if is360:
	631	# Nyears360 = int(realdate.year) - int(refdate.year) + 1
	632	# realdate = realdate -dt.timedelta(days=Nyears360*5)
	633	# realdates[it] = realdate
	634	# realdates = refdate + dt.timedelta(hours=float(times))
	635	realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
	636	elif tunits == 'minutes':
	637	for it in range(dimt):
	638	realdate = refdate + dt.timedelta(minutes=float(times[it]))
	639	realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
	640	elif tunits == 'seconds':
	641	for it in range(dimt):
	642	realdate = refdate + dt.timedelta(seconds=float(times[it]))
	643	realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
	644	elif tunits == 'milliseconds':
	645	for it in range(dimt):
	646	realdate = refdate + dt.timedelta(milliseconds=float(times[it]))
	647	realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
	648	elif tunits == 'microseconds':
	649	for it in range(dimt):
	650	realdate = refdate + dt.timedelta(microseconds=float(times[it]))
	651	realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
	652	else:
	653	print errormsg
	654	print ' netCDFdatetime_realdatetime: time units "' + tunits + '" is not ready!!!'
	655	quit(-1)
	656
	657	return realdates
	658
	659	def file_nlines(filen):
	660	""" Function to provide the number of lines of a file
	661	filen= name of the file
	662	>>> file_nlines('trajectory.dat')
	663	49
	664	"""
	665	fname = 'file_nlines'
	666
	667	if not os.path.isfile(filen):
	668	print errormsg
	669	print ' ' + fname + ' file: "' + filen + '" does not exist !!'
	670	quit(-1)
	671
	672	fo = open(filen,'r')
	673
	674	nlines=0
	675	for line in fo: nlines = nlines + 1
	676
	677	fo.close()
	678
	679	return nlines
	680
	681	def realdatetime1_CFcompilant(time, Srefdate, tunits):
	682	""" Function to transform a matrix with a real time value ([year, month, day,
	683	hour, minute, second]) to a netCDF one
	684	time= matrix with time
	685	Srefdate= reference date ([YYYY][MM][DD][HH][MI][SS] format)
	686	tunits= units of time respect to Srefdate
	687	>>> realdatetime1_CFcompilant([1976, 2, 17, 8, 20, 0], '19491201000000', 'hours')
	688	229784.33333333
	689	"""
	690
	691	import datetime as dt
	692	yrref=int(Srefdate[0:4])
	693	monref=int(Srefdate[4:6])
	694	dayref=int(Srefdate[6:8])
	695	horref=int(Srefdate[8:10])
	696	minref=int(Srefdate[10:12])
	697	secref=int(Srefdate[12:14])
	698
	699	refdate=dt.datetime(yrref, monref, dayref, horref, minref, secref)
	700
	701	if tunits == 'weeks':
	702	cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5])-refdate
	703	cfdates = (cfdate.days + cfdate.seconds/(3600.*24.))/7.
	704	elif tunits == 'days':
	705	cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5]) - refdate
	706	cfdates = cfdate.days + cfdate.seconds/(3600.*24.)
	707	elif tunits == 'hours':
	708	cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5]) - refdate
	709	cfdates = cfdate.days*24. + cfdate.seconds/3600.
	710	elif tunits == 'minutes':
	711	cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5]) - refdate
	712	cfdates = cfdate.days24.60. + cfdate.seconds/60.
	713	elif tunits == 'seconds':
	714	cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5]) - refdate
	715	cfdates = cfdate.days24.3600. + cfdate.seconds
	716	elif tunits == 'milliseconds':
	717	cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5]) - refdate
	718	cfdates = cfdate.days1000.24.3600. + cfdate.seconds1000.
	719	elif tunits == 'microseconds':
	720	cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],times[5]) - refdate
	721	cfdates = cfdate.days1000000.24.3600. + cfdate.seconds1000000.
	722	else:
	723	print errormsg
	724	print ' ' + fname + ': time units "' + tunits + '" is not ready!!!'
	725	quit(-1)
	726
	727	return cfdates
	728
	729	def basicvardef(varobj, vstname, vlname, vunits):
	730	""" Function to give the basic attributes to a variable
	731	varobj= netCDF variable object
	732	vstname= standard name of the variable
	733	vlname= long name of the variable
	734	vunits= units of the variable
	735	"""
	736	attr = varobj.setncattr('standard_name', vstname)
	737	attr = varobj.setncattr('long_name', vlname)
	738	attr = varobj.setncattr('units', vunits)
	739
	740	return
	741
	742	def variables_values(varName):
[361]	743	""" Function to provide values to plot the different variables values from ASCII file
	744	'variables_values.dat'
	745	variables_values(varName)
	746	[varName]= name of the variable
	747	return: [var name], [std name], [minimum], [maximum],
	748	[long name]('\|' for spaces), [units], [color palette] (following:
	749	http://matplotlib.org/1.3.1/examples/color/colormaps_reference.html)
	750	[varn]: original name of the variable
	751	NOTE: It might be better doing it with an external ASII file. But then we
	752	got an extra dependency...
	753	>>> variables_values('WRFght')
	754	['z', 'geopotential_height', 0.0, 80000.0, 'geopotential\|height', 'm2s-2', 'rainbow']
	755	"""
[369]	756	import subprocess as sub
	757
[361]	758	fname='variables_values'
	759
	760	if varName == 'h':
	761	print fname + '_____________________________________________________________'
	762	print variables_values.__doc__
	763	quit()
	764
[370]	765	# This does not work....
	766	# folderins = sub.Popen(["pwd"], stdout=sub.PIPE)
	767	# folder = list(folderins.communicate())[0].replace('\n','')
	768	# From http://stackoverflow.com/questions/4934806/how-can-i-find-scripts-directory-with-python
	769	folder = os.path.dirname(os.path.realpath(__file__))
[361]	770
[369]	771	infile = folder + '/variables_values.dat'
	772
[361]	773	if not os.path.isfile(infile):
	774	print errormsg
	775	print ' ' + fname + ": File '" + infile + "' does not exist !!"
	776	quit(-1)
	777
	778	# Variable name might come with a statistical surname...
	779	stats=['min','max','mean','stdv', 'sum']
	780
[376]	781	# Variables with a statistical section on their name...
	782	NOstatsvars = ['zmaxth', 'zmax_th', 'lmax_th', 'lmaxth']
	783
[361]	784	ifst = False
[376]	785	if not searchInlist(NOstatsvars, varName.lower()):
	786	for st in stats:
	787	if varName.find(st) > -1:
	788	print ' '+ fname + ": varibale '" + varName + "' with a " + \
	789	"statistical surname: '",st,"' !!"
	790	Lst = len(st)
	791	LvarName = len(varName)
	792	varn = varName[0:LvarName - Lst]
	793	ifst = True
	794	break
[361]	795	if not ifst:
	796	varn = varName
	797
[371]	798	ncf = open(infile, 'r')
[361]	799
	800	for line in ncf:
	801	if line[0:1] != '#':
	802	values = line.replace('\n','').split(',')
	803	if len(values) != 8:
	804	print errormsg
	805	print "problem in varibale:'", values[0], \
	806	'it should have 8 values and it has',len(values)
	807	quit(-1)
	808
	809	if varn[0:6] == 'varDIM':
	810	# Variable from a dimension (all with 'varDIM' prefix)
	811	Lvarn = len(varn)
	812	varvals = [varn[6:Lvarn+1], varn[6:Lvarn+1], 0., 1., \
	813	"variable\|from\|size\|of\|dimension\|'" + varn[6:Lvarn+1] + "'", '1', \
	814	'rainbow']
	815	else:
	816	varvals = [values[1].replace(' ',''), values[2].replace(' ',''), \
	817	np.float(values[3]), np.float(values[4]),values[5].replace(' ',''),\
	818	values[6].replace(' ',''), values[7].replace(' ','')]
	819	if values[0] == varn:
	820	ncf.close()
	821	return varvals
	822	break
	823
	824	print errormsg
	825	print ' ' + fname + ": variable '" + varn + "' not defined !!!"
[363]	826	ncf.close()
[361]	827	quit(-1)
	828
	829	return
	830
	831	def variables_values_old(varName):
[192]	832	""" Function to provide values to plot the different variables
	833	variables_values(varName)
	834	[varName]= name of the variable
	835	return: [var name], [std name], [minimum], [maximum],
	836	[long name]('\|' for spaces), [units], [color palette] (following:
	837	http://matplotlib.org/1.3.1/examples/color/colormaps_reference.html)
	838	[varn]: original name of the variable
	839	NOTE: It might be better doing it with an external ASII file. But then we
	840	got an extra dependency...
	841	>>> variables_values('WRFght')
	842	['z', 'geopotential_height', 0.0, 80000.0, 'geopotential\|height', 'm2s-2', 'rainbow']
	843	"""
	844	fname='variables_values'
	845
	846	if varName == 'h':
	847	print fname + '_____________________________________________________________'
	848	print variables_values.__doc__
	849	quit()
	850
	851	# Variable name might come with a statistical surname...
[327]	852	stats=['min','max','mean','stdv', 'sum']
[192]	853
	854	ifst = False
	855	for st in stats:
	856	if varName.find(st) > -1:
	857	print ' '+ fname + ": varibale '" + varName + "' with a statistical "+\
	858	" surname: '",st,"' !!"
	859	Lst = len(st)
	860	LvarName = len(varName)
	861	varn = varName[0:LvarName - Lst]
	862	ifst = True
	863	break
	864	if not ifst:
	865	varn = varName
	866
	867	if varn[0:6] == 'varDIM':
	868	# Variable from a dimension (all with 'varDIM' prefix)
	869	Lvarn = len(varn)
	870	varvals = [varn[6:Lvarn+1], varn[6:Lvarn+1], 0., 1., \
	871	"variable\|from\|size\|of\|dimension\|'" + varn[6:Lvarn+1] + "'", '1', 'rainbox']
	872	elif varn == 'a_tht' or varn == 'LA_THT':
[238]	873	varvals = ['ath', 'total_thermal_plume_cover', 0., 1., \
[192]	874	'total\|column\|thermal\|plume\|cover', '1', 'YlGnBu']
[327]	875	elif varn == 'acprc' or varn == 'RAINC':
	876	varvals = ['acprc', 'accumulated_cmulus_precipitation', 0., 3.e4, \
	877	'accumulated\|cmulus\|precipitation', 'mm', 'Blues']
	878	elif varn == 'acprnc' or varn == 'RAINNC':
	879	varvals = ['acprnc', 'accumulated_non-cmulus_precipitation', 0., 3.e4, \
	880	'accumulated\|non-cmulus\|precipitation', 'mm', 'Blues']
[192]	881	elif varn == 'bils' or varn == 'LBILS':
	882	varvals = ['bils', 'surface_total_heat_flux', -100., 100., \
	883	'surface\|total\|heat\|flux', 'Wm-2', 'seismic']
	884	elif varn == 'landcat' or varn == 'category':
	885	varvals = ['landcat', 'land_categories', 0., 22., 'land\|categories', '1', \
	886	'rainbow']
	887	elif varn == 'c' or varn == 'QCLOUD' or varn == 'oliq' or varn == 'OLIQ':
	888	varvals = ['c', 'condensed_water_mixing_ratio', 0., 3.e-4, \
	889	'condensed\|water\|mixing\|ratio', 'kgkg-1', 'BuPu']
[238]	890	elif varn == 'ci' or varn == 'iwcon' or varn == 'LIWCON':
	891	varvals = ['ci', 'cloud_iced_water_mixing_ratio', 0., 0.0003, \
	892	'cloud\|iced\|water\|mixing\|ratio', 'kgkg-1', 'Purples']
	893	elif varn == 'cl' or varn == 'lwcon' or varn == 'LLWCON':
	894	varvals = ['cl', 'cloud_liquidwater_mixing_ratio', 0., 0.0003, \
	895	'cloud\|liquid\|water\|mixing\|ratio', 'kgkg-1', 'Blues']
[233]	896	elif varn == 'cld' or varn == 'CLDFRA' or varn == 'rneb' or varn == 'lrneb' or \
	897	varn == 'LRNEB':
	898	varvals = ['cld', 'cloud_area_fraction', 0., 1., 'cloud\|fraction', '1', \
	899	'gist_gray']
[234]	900	elif varn == 'cldc' or varn == 'rnebcon' or varn == 'lrnebcon' or \
	901	varn == 'LRNEBCON':
[233]	902	varvals = ['cldc', 'convective_cloud_area_fraction', 0., 1., \
	903	'convective\|cloud\|fraction', '1', 'gist_gray']
	904	elif varn == 'cldl' or varn == 'rnebls' or varn == 'lrnebls' or varn == 'LRNEBLS':
	905	varvals = ['cldl', 'large_scale_cloud_area_fraction', 0., 1., \
	906	'large\|scale\|cloud\|fraction', '1', 'gist_gray']
[192]	907	elif varn == 'clt' or varn == 'CLT' or varn == 'cldt' or \
	908	varn == 'Total cloudiness':
	909	varvals = ['clt', 'cloud_area_fraction', 0., 1., 'total\|cloud\|cover', '1', \
	910	'gist_gray']
	911	elif varn == 'cll' or varn == 'cldl' or varn == 'LCLDL' or \
	912	varn == 'Low-level cloudiness':
	913	varvals = ['cll', 'low_level_cloud_area_fraction', 0., 1., \
	914	'low\|level\|(p\|>\|680\|hPa)\|cloud\|fraction', '1', 'gist_gray']
	915	elif varn == 'clm' or varn == 'cldm' or varn == 'LCLDM' or \
	916	varn == 'Mid-level cloudiness':
	917	varvals = ['clm', 'mid_level_cloud_area_fraction', 0., 1., \
	918	'medium\|level\|(440\|<\|p\|<\|680\|hPa)\|cloud\|fraction', '1', 'gist_gray']
	919	elif varn == 'clh' or varn == 'cldh' or varn == 'LCLDH' or \
	920	varn == 'High-level cloudiness':
	921	varvals = ['clh', 'high_level_cloud_area_fraction', 0., 1., \
	922	'high\|level\|(p\|<\|440\|hPa)\|cloud\|fraction', '1', 'gist_gray']
[249]	923	elif varn == 'clmf' or varn == 'fbase' or varn == 'LFBASE':
	924	varvals = ['clmf', 'cloud_base_max_flux', -0.3, 0.3, 'cloud\|base\|max\|flux', \
	925	'kgm-2s-1', 'seismic']
	926	elif varn == 'clp' or varn == 'pbase' or varn == 'LPBASE':
	927	varvals = ['clp', 'cloud_base_pressure', -0.3, 0.3, 'cloud\|base\|pressure', \
	928	'Pa', 'Reds']
	929	elif varn == 'cpt' or varn == 'ptconv' or varn == 'LPTCONV':
	930	varvals = ['cpt', 'convective_point', 0., 1., 'convective\|point', '1', \
	931	'seismic']
[192]	932	elif varn == 'dqajs' or varn == 'LDQAJS':
	933	varvals = ['dqajs', 'dry_adjustment_water_vapor_tendency', -0.0003, 0.0003, \
	934	'dry\|adjustment\|water\|vapor\|tendency', 'kg/kg/s', 'seismic']
	935	elif varn == 'dqcon' or varn == 'LDQCON':
	936	varvals = ['dqcon', 'convective_water_vapor_tendency', -3e-8, 3.e-8, \
	937	'convective\|water\|vapor\|tendency', 'kg/kg/s', 'seismic']
	938	elif varn == 'dqdyn' or varn == 'LDQDYN':
	939	varvals = ['dqdyn', 'dynamics_water_vapor_tendency', -3.e-7, 3.e-7, \
	940	'dynamics\|water\|vapor\|tendency', 'kg/kg/s', 'seismic']
	941	elif varn == 'dqeva' or varn == 'LDQEVA':
	942	varvals = ['dqeva', 'evaporation_water_vapor_tendency', -3.e-6, 3.e-6, \
	943	'evaporation\|water\|vapor\|tendency', 'kg/kg/s', 'seismic']
	944	elif varn == 'dqlscst' or varn == 'LDQLSCST':
	945	varvals = ['dqlscst', 'stratocumulus_water_vapor_tendency', -3.e-7, 3.e-7, \
	946	'stratocumulus\|water\|vapor\|tendency', 'kg/kg/s', 'seismic']
	947	elif varn == 'dqlscth' or varn == 'LDQLSCTH':
	948	varvals = ['dqlscth', 'thermals_water_vapor_tendency', -3.e-7, 3.e-7, \
	949	'thermal\|plumes\|water\|vapor\|tendency', 'kg/kg/s', 'seismic']
	950	elif varn == 'dqlsc' or varn == 'LDQLSC':
	951	varvals = ['dqlsc', 'condensation_water_vapor_tendency', -3.e-6, 3.e-6, \
	952	'condensation\|water\|vapor\|tendency', 'kg/kg/s', 'seismic']
	953	elif varn == 'dqphy' or varn == 'LDQPHY':
	954	varvals = ['dqphy', 'physics_water_vapor_tendency', -3.e-7, 3.e-7, \
	955	'physics\|water\|vapor\|tendency', 'kg/kg/s', 'seismic']
	956	elif varn == 'dqthe' or varn == 'LDQTHE':
	957	varvals = ['dqthe', 'thermals_water_vapor_tendency', -3.e-7, 3.e-7, \
	958	'thermal\|plumes\|water\|vapor\|tendency', 'kg/kg/s', 'seismic']
	959	elif varn == 'dqvdf' or varn == 'LDQVDF':
	960	varvals = ['dqvdf', 'vertical_difussion_water_vapor_tendency', -3.e-8, 3.e-8,\
	961	'vertical\|difussion\|water\|vapor\|tendency', 'kg/kg/s', 'seismic']
	962	elif varn == 'dqwak' or varn == 'LDQWAK':
	963	varvals = ['dqwak', 'wake_water_vapor_tendency', -3.e-7, 3.e-7, \
	964	'wake\|water\|vapor\|tendency', 'kg/kg/s', 'seismic']
[249]	965	elif varn == 'dta' or varn == 'tnt' or varn == 'LTNT':
	966	varvals = ['dta', 'tendency_air_temperature', -3.e-3, 3.e-3, \
	967	'tendency\|of\|air\|temperature', 'K/s', 'seismic']
	968	elif varn == 'dtac' or varn == 'tntc' or varn == 'LTNTC':
[250]	969	varvals = ['dtac', 'moist_convection_tendency_air_temperature', -3.e-3, \
	970	3.e-3, 'moist\|convection\|tendency\|of\|air\|temperature', 'K/s', 'seismic']
[249]	971	elif varn == 'dtar' or varn == 'tntr' or varn == 'LTNTR':
	972	varvals = ['dtar', 'radiative_heating_tendency_air_temperature', -3.e-3, \
	973	3.e-3, 'radiative\|heating\|tendency\|of\|air\|temperature', 'K/s', 'seismic']
	974	elif varn == 'dtascpbl' or varn == 'tntscpbl' or varn == 'LTNTSCPBL':
	975	varvals = ['dtascpbl', \
	976	'stratiform_cloud_precipitation_BL_mixing_tendency_air_temperature', \
	977	-3.e-6, 3.e-6, \
	978	'stratiform\|cloud\|precipitation\|Boundary\|Layer\|mixing\|tendency\|air\|' +
	979	'temperature', 'K/s', 'seismic']
[192]	980	elif varn == 'dtajs' or varn == 'LDTAJS':
	981	varvals = ['dtajs', 'dry_adjustment_thermal_tendency', -3.e-5, 3.e-5, \
	982	'dry\|adjustment\|thermal\|tendency', 'K/s', 'seismic']
	983	elif varn == 'dtcon' or varn == 'LDTCON':
	984	varvals = ['dtcon', 'convective_thermal_tendency', -3.e-5, 3.e-5, \
	985	'convective\|thermal\|tendency', 'K/s', 'seismic']
	986	elif varn == 'dtdyn' or varn == 'LDTDYN':
	987	varvals = ['dtdyn', 'dynamics_thermal_tendency', -3.e-4, 3.e-4, \
	988	'dynamics\|thermal\|tendency', 'K/s', 'seismic']
	989	elif varn == 'dteva' or varn == 'LDTEVA':
	990	varvals = ['dteva', 'evaporation_thermal_tendency', -3.e-3, 3.e-3, \
	991	'evaporation\|thermal\|tendency', 'K/s', 'seismic']
	992	elif varn == 'dtlscst' or varn == 'LDTLSCST':
	993	varvals = ['dtlscst', 'stratocumulus_thermal_tendency', -3.e-4, 3.e-4, \
	994	'stratocumulus\|thermal\|tendency', 'K/s', 'seismic']
	995	elif varn == 'dtlscth' or varn == 'LDTLSCTH':
	996	varvals = ['dtlscth', 'thermals_thermal_tendency', -3.e-4, 3.e-4, \
	997	'thermal\|plumes\|thermal\|tendency', 'K/s', 'seismic']
	998	elif varn == 'dtlsc' or varn == 'LDTLSC':
	999	varvals = ['dtlsc', 'condensation_thermal_tendency', -3.e-3, 3.e-3, \
	1000	'condensation\|thermal\|tendency', 'K/s', 'seismic']
[249]	1001	elif varn == 'dtlwr' or varn == 'LDTLWR':
	1002	varvals = ['dtlwr', 'long_wave_thermal_tendency', -3.e-3, 3.e-3, \
	1003	'long\|wave\|radiation\|thermal\|tendency', 'K/s', 'seismic']
[192]	1004	elif varn == 'dtphy' or varn == 'LDTPHY':
	1005	varvals = ['dtphy', 'physics_thermal_tendency', -3.e-4, 3.e-4, \
	1006	'physics\|thermal\|tendency', 'K/s', 'seismic']
[249]	1007	elif varn == 'dtsw0' or varn == 'LDTSW0':
	1008	varvals = ['dtsw0', 'cloudy_sky_short_wave_thermal_tendency', -3.e-4, 3.e-4, \
	1009	'cloudy\|sky\|short\|wave\|radiation\|thermal\|tendency', 'K/s', 'seismic']
[192]	1010	elif varn == 'dtthe' or varn == 'LDTTHE':
	1011	varvals = ['dtthe', 'thermals_thermal_tendency', -3.e-4, 3.e-4, \
	1012	'thermal\|plumes\|thermal\|tendency', 'K/s', 'seismic']
	1013	elif varn == 'dtvdf' or varn == 'LDTVDF':
	1014	varvals = ['dtvdf', 'vertical_difussion_thermal_tendency', -3.e-5, 3.e-5, \
	1015	'vertical\|difussion\|thermal\|tendency', 'K/s', 'seismic']
	1016	elif varn == 'dtwak' or varn == 'LDTWAK':
	1017	varvals = ['dtwak', 'wake_thermal_tendency', -3.e-4, 3.e-4, \
	1018	'wake\|thermal\|tendency', 'K/s', 'seismic']
[206]	1019	elif varn == 'ducon' or varn == 'LDUCON':
	1020	varvals = ['ducon', 'convective_eastward_wind_tendency', -3.e-3, 3.e-3, \
	1021	'convective\|eastward\|wind\|tendency', 'ms-2', 'seismic']
	1022	elif varn == 'dudyn' or varn == 'LDUDYN':
	1023	varvals = ['dudyn', 'dynamics_eastward_wind_tendency', -3.e-3, 3.e-3, \
	1024	'dynamics\|eastward\|wind\|tendency', 'ms-2', 'seismic']
	1025	elif varn == 'duvdf' or varn == 'LDUVDF':
	1026	varvals = ['duvdf', 'vertical_difussion_eastward_wind_tendency', -3.e-3, \
	1027	3.e-3, 'vertical\|difussion\|eastward\|wind\|tendency', 'ms-2', 'seismic']
	1028	elif varn == 'dvcon' or varn == 'LDVCON':
	1029	varvals = ['dvcon', 'convective_difussion_northward_wind_tendency', -3.e-3, \
	1030	3.e-3, 'convective\|northward\|wind\|tendency', 'ms-2', 'seismic']
	1031	elif varn == 'dvdyn' or varn == 'LDVDYN':
[327]	1032	varvals = ['dvdyn', 'dynamics_northward_wind_tendency', -3.e-3, \
[206]	1033	3.e-3, 'dynamics\|difussion\|northward\|wind\|tendency', 'ms-2', 'seismic']
	1034	elif varn == 'dvvdf' or varn == 'LDVVDF':
	1035	varvals = ['dvvdf', 'vertical_difussion_northward_wind_tendency', -3.e-3, \
	1036	3.e-3, 'vertical\|difussion\|northward\|wind\|tendency', 'ms-2', 'seismic']
[327]	1037	elif varn == 'etau' or varn == 'ZNU':
	1038	varvals = ['etau', 'etau', 0., 1, 'eta values on half (mass) levels', '-', \
	1039	'reds']
	1040	elif varn == 'evspsbl' or varn == 'LEVAP' or varn == 'evap' or varn == 'SFCEVPde':
[192]	1041	varvals = ['evspsbl', 'water_evaporation_flux', 0., 1.5e-4, \
	1042	'water\|evaporation\|flux', 'kgm-2s-1', 'Blues']
[327]	1043	elif varn == 'evspsbl' or varn == 'SFCEVPde':
	1044	varvals = ['evspsblac', 'water_evaporation_flux_ac', 0., 1.5e-4, \
	1045	'accumulated\|water\|evaporation\|flux', 'kgm-2', 'Blues']
[228]	1046	elif varn == 'g' or varn == 'QGRAUPEL':
	1047	varvals = ['g', 'grauepl_mixing_ratio', 0., 0.0003, 'graupel\|mixing\|ratio', \
	1048	'kgkg-1', 'Purples']
[192]	1049	elif varn == 'h2o' or varn == 'LH2O':
	1050	varvals = ['h2o', 'water_mass_fraction', 0., 3.e-2, \
	1051	'mass\|fraction\|of\|water', '1', 'Blues']
[228]	1052	elif varn == 'h' or varn == 'QHAIL':
	1053	varvals = ['h', 'hail_mixing_ratio', 0., 0.0003, 'hail\|mixing\|ratio', \
	1054	'kgkg-1', 'Purples']
[192]	1055	elif varn == 'hfls' or varn == 'LH' or varn == 'LFLAT' or varn == 'flat':
	1056	varvals = ['hfls', 'surface_upward_latent_heat_flux', -400., 400., \
	1057	'upward\|latnt\|heat\|flux\|at\|the\|surface', 'Wm-2', 'seismic']
[345]	1058	elif varn == 'hfss' or varn == 'LSENS' or varn == 'sens' or varn == 'HFX':
[192]	1059	varvals = ['hfss', 'surface_upward_sensible_heat_flux', -150., 150., \
	1060	'upward\|sensible\|heat\|flux\|at\|the\|surface', 'Wm-2', 'seismic']
[349]	1061	elif varn == 'hfso' or varn == 'GRDFLX':
	1062	varvals = ['hfso', 'downward_heat_flux_in_soil', -150., 150., \
	1063	'Downward\|soil\|heat\|flux', 'Wm-2', 'seismic']
[192]	1064	elif varn == 'hus' or varn == 'WRFrh' or varn == 'LMDZrh' or varn == 'rhum' or \
	1065	varn == 'LRHUM':
	1066	varvals = ['hus', 'specific_humidity', 0., 1., 'specific\|humidty', '1', \
	1067	'BuPu']
	1068	elif varn == 'huss' or varn == 'WRFrhs' or varn == 'LMDZrhs' or varn == 'rh2m' or\
	1069	varn == 'LRH2M':
	1070	varvals = ['huss', 'specific_humidity', 0., 1., 'specific\|humidty\|at\|2m', \
	1071	'1', 'BuPu']
[238]	1072	elif varn == 'i' or varn == 'QICE':
[228]	1073	varvals = ['i', 'iced_water_mixing_ratio', 0., 0.0003, \
[206]	1074	'iced\|water\|mixing\|ratio', 'kgkg-1', 'Purples']
[192]	1075	elif varn == 'lat' or varn == 'XLAT' or varn == 'XLAT_M' or varn == 'latitude':
	1076	varvals = ['lat', 'latitude', -90., 90., 'latitude', 'degrees North', \
	1077	'seismic']
[233]	1078	elif varn == 'lcl' or varn == 's_lcl' or varn == 'ls_lcl' or varn == 'LS_LCL':
	1079	varvals = ['lcl', 'condensation_level', 0., 2500., 'level\|of\|condensation', \
	1080	'm', 'Greens']
[249]	1081	elif varn == 'lambdath' or varn == 'lambda_th' or varn == 'LLAMBDA_TH':
	1082	varvals = ['lambdath', 'thermal_plume_vertical_velocity', -30., 30., \
[252]	1083	'thermal\|plume\|vertical\|velocity', 'm/s', 'seismic']
[249]	1084	elif varn == 'lmaxth' or varn == 'LLMAXTH':
	1085	varvals = ['lmaxth', 'upper_level_thermals', 0., 100., 'upper\|level\|thermals'\
	1086	, '1', 'Greens']
[192]	1087	elif varn == 'lon' or varn == 'XLONG' or varn == 'XLONG_M':
	1088	varvals = ['lon', 'longitude', -180., 180., 'longitude', 'degrees East', \
	1089	'seismic']
	1090	elif varn == 'longitude':
	1091	varvals = ['lon', 'longitude', 0., 360., 'longitude', 'degrees East', \
	1092	'seismic']
	1093	elif varn == 'orog' or varn == 'HGT' or varn == 'HGT_M':
	1094	varvals = ['orog', 'orography', 0., 3000., 'surface\|altitude', 'm','terrain']
[249]	1095	elif varn == 'pfc' or varn == 'plfc' or varn == 'LPLFC':
	1096	varvals = ['pfc', 'pressure_free_convection', 100., 1100., \
	1097	'pressure\|free\|convection', 'hPa', 'BuPu']
	1098	elif varn == 'plcl' or varn == 'LPLCL':
	1099	varvals = ['plcl', 'pressure_lifting_condensation_level', 700., 1100., \
	1100	'pressure\|lifting\|condensation\|level', 'hPa', 'BuPu']
[192]	1101	elif varn == 'pr' or varn == 'RAINTOT' or varn == 'precip' or \
	1102	varn == 'LPRECIP' or varn == 'Precip Totale liq+sol':
	1103	varvals = ['pr', 'precipitation_flux', 0., 1.e-4, 'precipitation\|flux', \
	1104	'kgm-2s-1', 'BuPu']
[220]	1105	elif varn == 'prprof' or varn == 'vprecip' or varn == 'LVPRECIP':
[227]	1106	varvals = ['prprof', 'precipitation_profile', 0., 1.e-3, \
	1107	'precipitation\|profile', 'kg/m2/s', 'BuPu']
	1108	elif varn == 'prprofci' or varn == 'pr_con_i' or varn == 'LPR_CON_I':
	1109	varvals = ['prprofci', 'precipitation_profile_convective_i', 0., 1.e-3, \
	1110	'precipitation\|profile\|convective\|i', 'kg/m2/s', 'BuPu']
	1111	elif varn == 'prprofcl' or varn == 'pr_con_l' or varn == 'LPR_CON_L':
	1112	varvals = ['prprofcl', 'precipitation_profile_convective_l', 0., 1.e-3, \
	1113	'precipitation\|profile\|convective\|l', 'kg/m2/s', 'BuPu']
	1114	elif varn == 'prprofli' or varn == 'pr_lsc_i' or varn == 'LPR_LSC_I':
	1115	varvals = ['prprofli', 'precipitation_profile_large_scale_i', 0., 1.e-3, \
	1116	'precipitation\|profile\|large\|scale\|i', 'kg/m2/s', 'BuPu']
	1117	elif varn == 'prprofll' or varn == 'pr_lsc_l' or varn == 'LPR_LSC_L':
	1118	varvals = ['prprofll', 'precipitation_profile_large_scale_l', 0., 1.e-3, \
	1119	'precipitation\|profile\|large\|scale\|l', 'kg/m2/s', 'BuPu']
[192]	1120	elif varn == 'pracc' or varn == 'ACRAINTOT':
	1121	varvals = ['pracc', 'precipitation_amount', 0., 100., \
	1122	'accumulated\|precipitation', 'kgm-2', 'BuPu']
[327]	1123	elif varn == 'prc' or varn == 'LPLUC' or varn == 'pluc' or varn == 'WRFprc' or \
	1124	varn == 'RAINCde':
[192]	1125	varvals = ['prc', 'convective_precipitation_flux', 0., 2.e-4, \
	1126	'convective\|precipitation\|flux', 'kgm-2s-1', 'Blues']
[206]	1127	elif varn == 'prci' or varn == 'pr_con_i' or varn == 'LPR_CON_I':
	1128	varvals = ['prci', 'convective_ice_precipitation_flux', 0., 0.003, \
	1129	'convective\|ice\|precipitation\|flux', 'kgm-2s-1', 'Purples']
	1130	elif varn == 'prcl' or varn == 'pr_con_l' or varn == 'LPR_CON_L':
	1131	varvals = ['prcl', 'convective_liquid_precipitation_flux', 0., 0.003, \
	1132	'convective\|liquid\|precipitation\|flux', 'kgm-2s-1', 'Blues']
[220]	1133	elif varn == 'pres' or varn == 'presnivs' or varn == 'pressure' or \
	1134	varn == 'lpres' or varn == 'LPRES':
[192]	1135	varvals = ['pres', 'air_pressure', 0., 103000., 'air\|pressure', 'Pa', \
	1136	'Blues']
[327]	1137	elif varn == 'prls' or varn == 'WRFprls' or varn == 'LPLUL' or varn == 'plul' or \
	1138	varn == 'RAINNCde':
[192]	1139	varvals = ['prls', 'large_scale_precipitation_flux', 0., 2.e-4, \
	1140	'large\|scale\|precipitation\|flux', 'kgm-2s-1', 'Blues']
	1141	elif varn == 'prsn' or varn == 'SNOW' or varn == 'snow' or varn == 'LSNOW':
	1142	varvals = ['prsn', 'snowfall', 0., 1.e-4, 'snowfall\|flux', 'kgm-2s-1', 'BuPu']
	1143	elif varn == 'prw' or varn == 'WRFprh':
	1144	varvals = ['prw', 'atmosphere_water_vapor_content', 0., 10., \
	1145	'water\|vapor"path', 'kgm-2', 'Blues']
	1146	elif varn == 'ps' or varn == 'psfc' or varn =='PSFC' or varn == 'psol' or \
	1147	varn == 'Surface Pressure':
	1148	varvals=['ps', 'surface_air_pressure', 85000., 105400., 'surface\|pressure', \
	1149	'hPa', 'cool']
	1150	elif varn == 'psl' or varn == 'mslp' or varn =='WRFmslp':
	1151	varvals=['psl', 'air_pressure_at_sea_level', 85000., 104000., \
	1152	'mean\|sea\|level\|pressure', 'Pa', 'Greens']
[249]	1153	elif varn == 'qth' or varn == 'q_th' or varn == 'LQ_TH':
[238]	1154	varvals = ['qth', 'thermal_plume_total_water_content', 0., 25., \
[192]	1155	'total\|water\|cotent\|in\|thermal\|plume', 'mm', 'YlOrRd']
	1156	elif varn == 'r' or varn == 'QVAPOR' or varn == 'ovap' or varn == 'LOVAP':
	1157	varvals = ['r', 'water_mixing_ratio', 0., 0.03, 'water\|mixing\|ratio', \
	1158	'kgkg-1', 'BuPu']
[327]	1159	elif varn == 'r2' or varn == 'Q2':
	1160	varvals = ['r2', 'water_mixing_ratio_at_2m', 0., 0.03, 'water\|mixing\|' + \
	1161	'ratio\|at\|2\|m','kgkg-1', 'BuPu']
[192]	1162	elif varn == 'rsds' or varn == 'SWdnSFC' or varn == 'SWdn at surface' or \
	1163	varn == 'SWDOWN':
	1164	varvals=['rsds', 'surface_downwelling_shortwave_flux_in_air', 0., 1200., \
	1165	'downward\|SW\|surface\|radiation', 'Wm-2' ,'Reds']
	1166	elif varn == 'rsdsacc':
	1167	varvals=['rsdsacc', 'accumulated_surface_downwelling_shortwave_flux_in_air', \
	1168	0., 1200., 'accumulated\|downward\|SW\|surface\|radiation', 'Wm-2' ,'Reds']
	1169	elif varn == 'rvor' or varn == 'WRFrvor':
	1170	varvals = ['rvor', 'air_relative_vorticity', -2.5E-3, 2.5E-3, \
	1171	'air\|relative\|vorticity', 's-1', 'seismic']
	1172	elif varn == 'rvors' or varn == 'WRFrvors':
	1173	varvals = ['rvors', 'surface_air_relative_vorticity', -2.5E-3, 2.5E-3, \
	1174	'surface\|air\|relative\|vorticity', 's-1', 'seismic']
[228]	1175	elif varn == 's' or varn == 'QSNOW':
	1176	varvals = ['s', 'snow_mixing_ratio', 0., 0.0003, 'snow\|mixing\|ratio', \
	1177	'kgkg-1', 'Purples']
[238]	1178	elif varn == 'stherm' or varn == 'LS_THERM':
[249]	1179	varvals = ['stherm', 'thermals_excess', 0., 0.8, 'thermals\|excess', 'K', \
[192]	1180	'Reds']
	1181	elif varn == 'ta' or varn == 'WRFt' or varn == 'temp' or varn == 'LTEMP' or \
	1182	varn == 'Air temperature':
	1183	varvals = ['ta', 'air_temperature', 195., 320., 'air\|temperature', 'K', \
	1184	'YlOrRd']
[249]	1185	elif varn == 'tah' or varn == 'theta' or varn == 'LTHETA':
	1186	varvals = ['tah', 'potential_air_temperature', 195., 320., \
	1187	'potential\|air\|temperature', 'K', 'YlOrRd']
[192]	1188	elif varn == 'tas' or varn == 'T2' or varn == 't2m' or varn == 'T2M' or \
	1189	varn == 'Temperature 2m':
	1190	varvals = ['tas', 'air_temperature', 240., 310., 'air\|temperature\|at\|2m', ' \
	1191	K', 'YlOrRd']
	1192	elif varn == 'tds' or varn == 'TH2':
	1193	varvals = ['tds', 'air_dew_point_temperature', 240., 310., \
	1194	'air\|dew\|point\|temperature\|at\|2m', 'K', 'YlGnBu']
[233]	1195	elif varn == 'tke' or varn == 'TKE' or varn == 'tke' or varn == 'LTKE':
	1196	varvals = ['tke', 'turbulent_kinetic_energy', 0., 0.003, \
	1197	'turbulent\|kinetic\|energy', 'm2/s2', 'Reds']
[192]	1198	elif varn == 'time'or varn == 'time_counter':
	1199	varvals = ['time', 'time', 0., 1000., 'time', \
	1200	'hours\|since\|1949/12/01\|00:00:00', 'Reds']
[233]	1201	elif varn == 'tmla' or varn == 's_pblt' or varn == 'LS_PBLT':
	1202	varvals = ['tmla', 'atmosphere_top_boundary_layer_temperature', 250., 330., \
	1203	'atmosphere\|top\|boundary\|layer\|temperature', 'K', 'Reds']
[192]	1204	elif varn == 'ua' or varn == 'vitu' or varn == 'U' or varn == 'Zonal wind' or \
	1205	varn == 'LVITU':
	1206	varvals = ['ua', 'eastward_wind', -30., 30., 'eastward\|wind', 'ms-1', \
	1207	'seismic']
	1208	elif varn == 'uas' or varn == 'u10m' or varn == 'U10' or varn =='Vent zonal 10m':
	1209	varvals = ['uas', 'eastward_wind', -30., 30., 'eastward\|2m\|wind', \
	1210	'ms-1', 'seismic']
	1211	elif varn == 'va' or varn == 'vitv' or varn == 'V' or varn == 'Meridional wind' \
	1212	or varn == 'LVITV':
	1213	varvals = ['va', 'northward_wind', -30., 30., 'northward\|wind', 'ms-1', \
	1214	'seismic']
	1215	elif varn == 'vas' or varn == 'v10m' or varn == 'V10' or \
	1216	varn =='Vent meridien 10m':
	1217	varvals = ['vas', 'northward_wind', -30., 30., 'northward\|2m\|wind', 'ms-1', \
	1218	'seismic']
[238]	1219	elif varn == 'wakedeltaq' or varn == 'wake_deltaq' or varn == 'lwake_deltaq' or \
	1220	varn == 'LWAKE_DELTAQ':
	1221	varvals = ['wakedeltaq', 'wake_delta_vapor', -0.003, 0.003, \
[233]	1222	'wake\|delta\|mixing\|ratio', '-', 'seismic']
[238]	1223	elif varn == 'wakedeltat' or varn == 'wake_deltat' or varn == 'lwake_deltat' or \
	1224	varn == 'LWAKE_DELTAT':
	1225	varvals = ['wakedeltat', 'wake_delta_temp', -0.003, 0.003, \
[233]	1226	'wake\|delta\|temperature', '-', 'seismic']
[238]	1227	elif varn == 'wakeh' or varn == 'wake_h' or varn == 'LWAKE_H':
	1228	varvals = ['wakeh', 'wake_height', 0., 1000., 'height\|of\|the\|wakes', 'm', \
[192]	1229	'YlOrRd']
[238]	1230	elif varn == 'wakeomg' or varn == 'wake_omg' or varn == 'lwake_omg' or \
	1231	varn == 'LWAKE_OMG':
	1232	varvals = ['wakeomg', 'wake_omega', 0., 3., 'wake\|omega', \
[233]	1233	'-', 'BuGn']
[238]	1234	elif varn == 'wakes' or varn == 'wake_s' or varn == 'LWAKE_S':
	1235	varvals = ['wakes', 'wake_area_fraction', 0., 0.5, 'wake\|spatial\|fraction', \
[192]	1236	'1', 'BuGn']
	1237	elif varn == 'wa' or varn == 'W' or varn == 'Vertical wind':
	1238	varvals = ['wa', 'upward_wind', -10., 10., 'upward\|wind', 'ms-1', \
	1239	'seismic']
	1240	elif varn == 'wap' or varn == 'vitw' or varn == 'LVITW':
	1241	varvals = ['wap', 'upward_wind', -3.e-10, 3.e-10, 'upward\|wind', 'mPa-1', \
	1242	'seismic']
	1243	elif varn == 'wss' or varn == 'SPDUV':
	1244	varvals = ['wss', 'air_velocity', 0., 30., 'surface\|horizontal\|wind\|speed', \
	1245	'ms-1', 'Reds']
[327]	1246	# Water budget
	1247	# Water budget de-accumulated
	1248	elif varn == 'ccond' or varn == 'CCOND' or varn == 'ACCCONDde':
	1249	varvals = ['ccond', 'cw_cond', 0., 30., \
	1250	'cloud\|water\|condensation', 'mm', 'Reds']
	1251	elif varn == 'wbr' or varn == 'ACQVAPORde':
	1252	varvals = ['wbr', 'wbr', 0., 30., 'Water\|Budget\|water\|wapor', 'mm', 'Blues']
	1253	elif varn == 'diabh' or varn == 'DIABH' or varn == 'ACDIABHde':
	1254	varvals = ['diabh', 'diabh', 0., 30., 'diabatic\|heating', 'K', 'Reds']
	1255	elif varn == 'wbpw' or varn == 'WBPW' or varn == 'WBACPWde':
	1256	varvals = ['wbpw', 'water_budget_pw', 0., 30., 'Water\|Budget\|water\|content',\
	1257	'mms-1', 'Reds']
	1258	elif varn == 'wbf' or varn == 'WBACF' or varn == 'WBACFde':
	1259	varvals = ['wbf', 'water_budget_hfcqv', 0., 30., \
	1260	'Water\|Budget\|horizontal\|convergence\|of\|water\|vapour\|(+,\|' + \
	1261	'conv.;\|-,\|div.)', 'mms-1', 'Reds']
	1262	elif varn == 'wbfc' or varn == 'WBFC' or varn == 'WBACFCde':
	1263	varvals = ['wbfc', 'water_budget_fc', 0., 30., \
	1264	'Water\|Budget\|horizontal\|convergence\|of\|cloud\|(+,\|conv.;\|-,\|' +\
	1265	'div.)', 'mms-1', 'Reds']
	1266	elif varn == 'wbfp' or varn == 'WBFP' or varn == 'WBACFPde':
	1267	varvals = ['wbfp', 'water_budget_cfp', 0., 30., \
	1268	'Water\|Budget\|horizontal\|convergence\|of\|precipitation\|(+,\|' + \
	1269	'conv.;\|-,\|div.)', 'mms-1', 'Reds']
	1270	elif varn == 'wbz' or varn == 'WBZ' or varn == 'WBACZde':
	1271	varvals = ['wbz', 'water_budget_z', 0., 30., \
	1272	'Water\|Budget\|vertical\|convergence\|of\|water\|vapour\|(+,\|conv.' +\
	1273	';\|-,\|div.)', 'mms-1', 'Reds']
	1274	elif varn == 'wbc' or varn == 'WBC' or varn == 'WBACCde':
	1275	varvals = ['wbc', 'water_budget_c', 0., 30., \
	1276	'Water\|Budget\|Cloud\|water\|species','mms-1', 'Reds']
	1277	elif varn == 'wbqvd' or varn == 'WBQVD' or varn == 'WBACQVDde':
	1278	varvals = ['wbqvd', 'water_budget_qvd', 0., 30., \
	1279	'Water\|Budget\|water\|vapour\|divergence', 'mms-1', 'Reds']
	1280	elif varn == 'wbqvblten' or varn == 'WBQVBLTEN' or varn == 'WBACQVBLTENde':
	1281	varvals = ['wbqvblten', 'water_budget_qv_blten', 0., 30., \
	1282	'Water\|Budget\|QV\|tendency\|due\|to\|pbl\|parameterization', \
	1283	'kg kg-1 s-1', 'Reds']
	1284	elif varn == 'wbqvcuten' or varn == 'WBQVCUTEN' or varn == 'WBACQVCUTENde':
	1285	varvals = ['wbqvcuten', 'water_budget_qv_cuten', 0., 30., \
	1286	'Water\|Budget\|QV\|tendency\|due\|to\|cu\|parameterization', \
	1287	'kg kg-1 s-1', 'Reds']
	1288	elif varn == 'wbqvshten' or varn == 'WBQVSHTEN' or varn == 'WBACQVSHTENde':
	1289	varvals = ['wbqvshten', 'water_budget_qv_shten', 0., 30., \
	1290	'Water\|Budget\|QV\|tendency\|due\|to\|shallow\|cu\|parameterization', \
	1291	'kg kg-1 s-1', 'Reds']
	1292	elif varn == 'wbpr' or varn == 'WBP' or varn == 'WBACPde':
	1293	varvals = ['wbpr', 'water_budget_pr', 0., 30., \
	1294	'Water\|Budget\|recipitation', 'mms-1', 'Reds']
	1295	elif varn == 'wbpw' or varn == 'WBPW' or varn == 'WBACPWde':
	1296	varvals = ['wbpw', 'water_budget_pw', 0., 30., \
	1297	'Water\|Budget\|water\|content', 'mms-1', 'Reds']
	1298	elif varn == 'wbcondt' or varn == 'WBCONDT' or varn == 'WBACCONDTde':
	1299	varvals = ['wbcondt', 'water_budget_condt', 0., 30., \
	1300	'Water\|Budget\|condensation\|and\|deposition', 'mms-1', 'Reds']
	1301	elif varn == 'wbqcm' or varn == 'WBQCM' or varn == 'WBACQCMde':
	1302	varvals = ['wbqcm', 'water_budget_qcm', 0., 30., \
	1303	'Water\|Budget\|hydrometeor\|change\|and\|convergence', 'mms-1', 'Reds']
	1304	elif varn == 'wbsi' or varn == 'WBSI' or varn == 'WBACSIde':
	1305	varvals = ['wbsi', 'water_budget_si', 0., 30., \
	1306	'Water\|Budget\|hydrometeor\|sink', 'mms-1', 'Reds']
	1307	elif varn == 'wbso' or varn == 'WBSO' or varn == 'WBACSOde':
	1308	varvals = ['wbso', 'water_budget_so', 0., 30., \
	1309	'Water\|Budget\|hydrometeor\|source', 'mms-1', 'Reds']
	1310	# Water Budget accumulated
	1311	elif varn == 'ccondac' or varn == 'ACCCOND':
	1312	varvals = ['ccondac', 'cw_cond_ac', 0., 30., \
	1313	'accumulated\|cloud\|water\|condensation', 'mm', 'Reds']
	1314	elif varn == 'rac' or varn == 'ACQVAPOR':
	1315	varvals = ['rac', 'ac_r', 0., 30., 'accumualted\|water\|wapor', 'mm', 'Blues']
	1316	elif varn == 'diabhac' or varn == 'ACDIABH':
	1317	varvals = ['diabhac', 'diabh_ac', 0., 30., 'accumualted\|diabatic\|heating', \
	1318	'K', 'Reds']
	1319	elif varn == 'wbpwac' or varn == 'WBACPW':
	1320	varvals = ['wbpwac', 'water_budget_pw_ac', 0., 30., \
	1321	'Water\|Budget\|accumulated\|water\|content', 'mm', 'Reds']
	1322	elif varn == 'wbfac' or varn == 'WBACF':
	1323	varvals = ['wbfac', 'water_budget_hfcqv_ac', 0., 30., \
	1324	'Water\|Budget\|accumulated\|horizontal\|convergence\|of\|water\|vapour\|(+,\|' + \
	1325	'conv.;\|-,\|div.)', 'mm', 'Reds']
	1326	elif varn == 'wbfcac' or varn == 'WBACFC':
	1327	varvals = ['wbfcac', 'water_budget_fc_ac', 0., 30., \
	1328	'Water\|Budget\|accumulated\|horizontal\|convergence\|of\|cloud\|(+,\|conv.;\|-,\|' +\
	1329	'div.)', 'mm', 'Reds']
	1330	elif varn == 'wbfpac' or varn == 'WBACFP':
	1331	varvals = ['wbfpac', 'water_budget_cfp_ac', 0., 30., \
	1332	'Water\|Budget\|accumulated\|horizontal\|convergence\|of\|precipitation\|(+,\|' + \
	1333	'conv.;\|-,\|div.)', 'mm', 'Reds']
	1334	elif varn == 'wbzac' or varn == 'WBACZ':
	1335	varvals = ['wbzac', 'water_budget_z_ac', 0., 30., \
	1336	'Water\|Budget\|accumulated\|vertical\|convergence\|of\|water\|vapour\|(+,\|conv.' +\
	1337	';\|-,\|div.)', 'mm', 'Reds']
	1338	elif varn == 'wbcac' or varn == 'WBACC':
	1339	varvals = ['wbcac', 'water_budget_c_ac', 0., 30., \
	1340	'Water\|Budget\|accumulated\|Cloud\|water\|species','mm', 'Reds']
	1341	elif varn == 'wbqvdac' or varn == 'WBACQVD':
	1342	varvals = ['wbqvdac', 'water_budget_qvd_ac', 0., 30., \
	1343	'Water\|Budget\|accumulated\|water\|vapour\|divergence', 'mm', 'Reds']
	1344	elif varn == 'wbqvbltenac' or varn == 'WBACQVBLTEN':
	1345	varvals = ['wbqvbltenac', 'water_budget_qv_blten_ac', 0., 30., \
	1346	'Water\|Budget\|accumulated\|QV\|tendency\|due\|to\|pbl\|parameterization', \
	1347	'kg kg-1 s-1', 'Reds']
	1348	elif varn == 'wbqvcutenac' or varn == 'WBACQVCUTEN':
	1349	varvals = ['wbqvcutenac', 'water_budget_qv_cuten_ac', 0., 30., \
	1350	'Water\|Budget\|accumulated\|QV\|tendency\|due\|to\|cu\|parameterization', \
	1351	'kg kg-1 s-1', 'Reds']
	1352	elif varn == 'wbqvshtenac' or varn == 'WBACQVSHTEN':
	1353	varvals = ['wbqvshtenac', 'water_budget_qv_shten_ac', 0., 30., \
	1354	'Water\|Budget\|accumulated\|QV\|tendency\|due\|to\|shallow\|cu\|parameterization', \
	1355	'kg kg-1 s-1', 'Reds']
	1356	elif varn == 'wbprac' or varn == 'WBACP':
	1357	varvals = ['wbprac', 'water_budget_pr_ac', 0., 30., \
	1358	'Water\|Budget\|accumulated\|precipitation', 'mm', 'Reds']
	1359	elif varn == 'wbpwac' or varn == 'WBACPW':
	1360	varvals = ['wbpwac', 'water_budget_pw_ac', 0., 30., \
	1361	'Water\|Budget\|accumulated\|water\|content', 'mm', 'Reds']
	1362	elif varn == 'wbcondtac' or varn == 'WBACCONDT':
	1363	varvals = ['wbcondtac', 'water_budget_condt_ac', 0., 30., \
	1364	'Water\|Budget\|accumulated\|condensation\|and\|deposition', 'mm', 'Reds']
	1365	elif varn == 'wbqcmac' or varn == 'WBACQCM':
	1366	varvals = ['wbqcmac', 'water_budget_qcm_ac', 0., 30., \
	1367	'Water\|Budget\|accumulated\|hydrometeor\|change\|and\|convergence', 'mm', 'Reds']
	1368	elif varn == 'wbsiac' or varn == 'WBACSI':
	1369	varvals = ['wbsiac', 'water_budget_si_ac', 0., 30., \
	1370	'Water\|Budget\|accumulated\|hydrometeor\|sink', 'mm', 'Reds']
	1371	elif varn == 'wbsoac' or varn == 'WBACSO':
	1372	varvals = ['wbsoac', 'water_budget_so_ac', 0., 30., \
	1373	'Water\|Budget\|accumulated\|hydrometeor\|source', 'mm', 'Reds']
	1374
[192]	1375	elif varn == 'xtime' or varn == 'XTIME':
	1376	varvals = ['xtime', 'time', 0., 1.e5, 'time', \
	1377	'minutes\|since\|simulation\|start', 'Reds']
	1378	elif varn == 'x' or varn == 'X':
	1379	varvals = ['x', 'x', 0., 100., 'x', '-', 'Reds']
	1380	elif varn == 'y' or varn == 'Y':
	1381	varvals = ['y', 'y', 0., 100., 'y', '-', 'Blues']
	1382	elif varn == 'z' or varn == 'Z':
	1383	varvals = ['z', 'z', 0., 100., 'z', '-', 'Greens']
	1384	elif varn == 'zg' or varn == 'WRFght' or varn == 'Geopotential height' or \
	1385	varn == 'geop' or varn == 'LGEOP':
	1386	varvals = ['zg', 'geopotential_height', 0., 80000., 'geopotential\|height', \
	1387	'm2s-2', 'rainbow']
[238]	1388	elif varn == 'zmaxth' or varn == 'zmax_th' or varn == 'LZMAX_TH':
	1389	varvals = ['zmaxth', 'thermal_plume_height', 0., 4000., \
[192]	1390	'maximum\|thermals\|plume\|height', 'm', 'YlOrRd']
	1391	elif varn == 'zmla' or varn == 's_pblh' or varn == 'LS_PBLH':
	1392	varvals = ['zmla', 'atmosphere_boundary_layer_thickness', 0., 2500., \
	1393	'atmosphere\|boundary\|layer\|thickness', 'm', 'Blues']
	1394	else:
	1395	print errormsg
[327]	1396	print ' ' + fname + ": variable '" + varn + "' not defined !!!"
[192]	1397	quit(-1)
	1398
	1399	return varvals
	1400
[545]	1401	def lonlat2D(lon,lat):
	1402	""" Function to return lon, lat 2D matrices from any lon,lat matrix
	1403	lon= matrix with longitude values
	1404	lat= matrix with latitude values
	1405	"""
	1406	fname = 'lonlat2D'
	1407
	1408	if len(lon.shape) != len(lat.shape):
	1409	print errormsg
	1410	print ' ' + fname + ': longitude values with shape:', lon.shape, \
	1411	'is different that latitude values with shape:', lat.shape, '(dif. size) !!'
	1412	quit(-1)
	1413
	1414	if len(lon.shape) == 3:
	1415	lonvv = lon[0,:,:]
	1416	latvv = lat[0,:,:]
	1417	elif len(lon.shape) == 2:
	1418	lonvv = lon[:]
	1419	latvv = lat[:]
	1420	elif len(lon.shape) == 1:
	1421	lonlatv = np.meshgrid(lon[:],lat[:])
	1422	lonvv = lonlatv[0]
	1423	latvv = lonlatv[1]
	1424
	1425	return lonvv, latvv
	1426
[192]	1427	####### ####### ####### ####### ####### ####### ####### ####### ####### #######
	1428
	1429	def check_colorBar(cbarn):
	1430	""" Check if the given colorbar exists in matplotlib
	1431	"""
	1432	fname = 'check_colorBar'
	1433
	1434	# Possible color bars
	1435	colorbars = ['binary', 'Blues', 'BuGn', 'BuPu', 'gist_yarg', 'GnBu', 'Greens', \
	1436	'Greys', 'Oranges', 'OrRd', 'PuBu', 'PuBuGn', 'PuRd', 'Purples', 'RdPu', \
	1437	'Reds', 'YlGn', 'YlGnBu', 'YlOrBr', 'YlOrRd', 'afmhot', 'autumn', 'bone', \
	1438	'cool', 'copper', 'gist_gray', 'gist_heat', 'gray', 'hot', 'pink', 'spring', \
	1439	'summer', 'winter', 'BrBG', 'bwr', 'coolwarm', 'PiYG', 'PRGn', 'PuOr', 'RdBu', \
	1440	'RdGy', 'RdYlBu', 'RdYlGn', 'seismic', 'Accent', 'Dark2', 'hsv', 'Paired', \
	1441	'Pastel1', 'Pastel2', 'Set1', 'Set2', 'Set3', 'spectral', 'gist_earth', \
	1442	'gist_ncar', 'gist_rainbow', 'gist_stern', 'jet', 'brg', 'CMRmap', 'cubehelix',\
	1443	'gnuplot', 'gnuplot2', 'ocean', 'rainbow', 'terrain', 'flag', 'prism']
	1444
	1445	if not searchInlist(colorbars,cbarn):
	1446	print warnmsg
	1447	print ' ' + fname + ' color bar: "' + cbarn + '" does not exist !!'
	1448	print ' a standard one will be use instead !!'
	1449
	1450	return
	1451
	1452	def units_lunits(u):
	1453	""" Fucntion to provide LaTeX equivalences from a given units
	1454	u= units to transform
	1455	>>> units_lunits('kgkg-1')
	1456	'$kgkg^{-1}$'
	1457	"""
	1458	fname = 'units_lunits'
	1459
	1460	if u == 'h':
	1461	print fname + '_____________________________________________________________'
	1462	print units_lunits.__doc__
	1463	quit()
	1464
	1465	# Units which does not change
[621]	1466	same = ['1', 'category', 'day', 'deg', 'degree', 'degrees', 'degrees East', \
	1467	'degrees Nord', 'degrees North', 'g', 'gpm', 'hour', 'hPa', 'K', 'Km', 'kg', \
	1468	'km', 'm', 'minute', 'mm', 'month', 'Pa', 's', 'second', 'um', 'year', '-']
[192]	1469
	1470	if searchInlist(same,u):
	1471	lu = '$' + u + '$'
	1472	elif len(u.split(' ')) > 1 and u.split(' ')[1] == 'since':
	1473	uparts = u.split(' ')
	1474	ip=0
	1475	for up in uparts:
	1476	if ip == 0:
	1477	lu = '$' + up
	1478	else:
	1479	lu = lu + '\ ' + up
	1480	ip=ip+1
	1481	lu = lu + '$'
	1482	else:
[208]	1483	if u == '': lu='-'
	1484	elif u == 'C': lu='$^{\circ}C$'
[192]	1485	elif u == 'days': lu='$day$'
	1486	elif u == 'degrees_east': lu='$degrees\ East$'
	1487	elif u == 'degree_east': lu='$degrees\ East$'
	1488	elif u == 'degrees longitude': lu='$degrees\ East$'
	1489	elif u == 'degrees latitude': lu='$degrees\ North$'
	1490	elif u == 'degrees_north': lu='$degrees\ North$'
	1491	elif u == 'degree_north': lu='$degrees\ North$'
	1492	elif u == 'deg C': lu='$^{\circ}C$'
	1493	elif u == 'degC': lu='$^{\circ}C$'
	1494	elif u == 'deg K': lu='$K$'
	1495	elif u == 'degK': lu='$K$'
[698]	1496	elif u == 'g/g': lu='$gg^{-1}$'
[192]	1497	elif u == 'hours': lu='$hour$'
	1498	elif u == 'J/kg': lu='$Jkg^{-1}$'
	1499	elif u == 'Jkg-1': lu='$Jkg^{-1}$'
	1500	elif u == 'K/m': lu='$Km^{-1}$'
	1501	elif u == 'Km-1': lu='$Km^{-1}$'
	1502	elif u == 'K/s': lu='$Ks^{-1}$'
	1503	elif u == 'Ks-1': lu='$Ks^{-1}$'
[254]	1504	elif u == 'K s-1': lu='$Ks^{-1}$'
[192]	1505	elif u == 'kg/kg': lu='$kgkg^{-1}$'
	1506	elif u == 'kgkg-1': lu='$kgkg^{-1}$'
	1507	elif u == 'kg kg-1': lu='$kgkg^{-1}$'
	1508	elif u == '(kg/kg)/s': lu='$kgkg^{-1}s^{-1}$'
	1509	elif u == 'kgkg-1s-1': lu='$kgkg^{-1}s^{-1}$'
[328]	1510	elif u == 'kg kg-1 s-1': lu='$kgkg^{-1}s^{-1}$'
[192]	1511	elif u == 'kg/m2': lu='$kgm^{-2}$'
	1512	elif u == 'kgm-2': lu='$kgm^{-2}$'
	1513	elif u == 'kg m-2': lu='$kgm^{-2}$'
	1514	elif u == 'Kg m-2': lu='$kgm^{-2}$'
	1515	elif u == 'kg/m2/s': lu='$kgm^{-2}s^{-1}$'
	1516	elif u == 'kg/(m2*s)': lu='$kgm^{-2}s^{-1}$'
	1517	elif u == 'kg/(s*m2)': lu='$kgm^{-2}s^{-1}$'
	1518	elif u == 'kgm-2s-1': lu='$kgm^{-2}s^{-1}$'
[396]	1519	elif u == 'kg m-2 s-1': lu='$kgm^{-2}s^{-1}$'
[192]	1520	elif u == '1/m': lu='$m^{-1}$'
	1521	elif u == 'm-1': lu='$m^{-1}$'
[705]	1522	elif u == 'm^2': lu='$m^{2}$'
[192]	1523	elif u == 'm2/s': lu='$m2s^{-1}$'
	1524	elif u == 'm2s-1': lu='$m2s^{-1}$'
	1525	elif u == 'm2/s2': lu='$m2s^{-2}$'
	1526	elif u == 'm/s': lu='$ms^{-1}$'
	1527	elif u == 'mmh-3': lu='$mmh^{-3}$'
	1528	elif u == 'ms-1': lu='$ms^{-1}$'
	1529	elif u == 'm s-1': lu='$ms^{-1}$'
	1530	elif u == 'm/s2': lu='$ms^{-2}$'
	1531	elif u == 'ms-2': lu='$ms^{-2}$'
	1532	elif u == 'minutes': lu='$minute$'
	1533	elif u == 'Pa/s': lu='$Pas^{-1}$'
	1534	elif u == 'Pas-1': lu='$Pas^{-1}$'
	1535	elif u == 'W m-2': lu='$Wm^{-2}$'
	1536	elif u == 'Wm-2': lu='$Wm^{-2}$'
	1537	elif u == 'W/m2': lu='$Wm^{-2}$'
	1538	elif u == '1/s': lu='$s^{-1}$'
	1539	elif u == 's-1': lu='$s^{-1}$'
	1540	elif u == 'seconds': lu='$second$'
	1541	elif u == '%': lu='\%'
[698]	1542	elif u == '?': lu='-'
[192]	1543	else:
	1544	print errormsg
	1545	print ' ' + fname + ': units "' + u + '" not ready!!!!'
	1546	quit(-1)
	1547
	1548	return lu
	1549
	1550	def ASCII_LaTeX(ln):
	1551	""" Function to transform from an ASCII line to LaTeX codification
	1552	>>> ASCII_LaTeX('Laboratoire de MÃ©tÃ©orologie Dynamique perÃ² HovmÃ¶ller')
	1553	Laboratoire de M\'et\'eorologie Dynamique per\`o Hovm\"oller
	1554	"""
	1555	fname='ASCII_LaTeX'
	1556
	1557	if ln == 'h':
	1558	print fname + '_____________________________________________________________'
	1559	print ASCII_LaTeX.__doc__
	1560	quit()
	1561
	1562	newln = ln.replace('\\', '\\textbackslash')
	1563
	1564	newln = newln.replace('Ã¡', "\\'a")
	1565	newln = newln.replace('Ã©', "\\'e")
	1566	newln = newln.replace('Ã', "\\'i")
	1567	newln = newln.replace('Ã³', "\\'o")
	1568	newln = newln.replace('Ãº', "\\'u")
	1569
	1570	newln = newln.replace('Ã ', "\\`a")
	1571	newln = newln.replace('Ãš', "\\`e")
	1572	newln = newln.replace('Ã¬', "\\`i")
	1573	newln = newln.replace('Ã²', "\\`o")
	1574	newln = newln.replace('Ã¹', "\\`u")
	1575
	1576	newln = newln.replace('Ã¢', "\\^a")
	1577	newln = newln.replace('Ãª', "\\^e")
	1578	newln = newln.replace('Ã®', "\\^i")
	1579	newln = newln.replace('ÃŽ', "\\^o")
	1580	newln = newln.replace('Ã»', "\\^u")
	1581
	1582	newln = newln.replace('Ã€', '\\"a')
	1583	newln = newln.replace('Ã«', '\\"e')
	1584	newln = newln.replace('Ã¯', '\\"i')
	1585	newln = newln.replace('Ã¶', '\\"o')
	1586	newln = newln.replace('ÃŒ', '\\"u')
	1587
	1588	newln = newln.replace('Ã§', '\c{c}')
	1589	newln = newln.replace('Ã±', '\~{n}')
	1590
	1591	newln = newln.replace('Ã', "\\'A")
	1592	newln = newln.replace('Ã', "\\'E")
	1593	newln = newln.replace('Ã', "\\'I")
	1594	newln = newln.replace('Ã', "\\'O")
	1595	newln = newln.replace('Ã', "\\'U")
	1596
	1597	newln = newln.replace('Ã', "\\`A")
	1598	newln = newln.replace('Ã', "\\`E")
	1599	newln = newln.replace('Ã', "\\`I")
	1600	newln = newln.replace('Ã', "\\`O")
	1601	newln = newln.replace('Ã', "\\`U")
	1602
	1603	newln = newln.replace('Ã', "\\^A")
	1604	newln = newln.replace('Ã', "\\^E")
	1605	newln = newln.replace('Ã', "\\^I")
	1606	newln = newln.replace('Ã', "\\^O")
	1607	newln = newln.replace('Ã', "\\^U")
	1608
	1609	newln = newln.replace('Ã', '\\"A')
	1610	newln = newln.replace('Ã', '\\"E')
	1611	newln = newln.replace('Ã', '\\"I')
	1612	newln = newln.replace('Ã', '\\"O')
	1613	newln = newln.replace('Ã', '\\"U')
	1614
	1615	newln = newln.replace('Ã', '\\c{C}')
	1616	newln = newln.replace('Ã', '\\~{N}')
	1617
	1618	newln = newln.replace('Â¡', '!`')
	1619	newln = newln.replace('Â¿', 'Â¿`')
	1620	newln = newln.replace('%', '\\%')
	1621	newln = newln.replace('#', '\\#')
	1622	newln = newln.replace('&', '\\&')
	1623	newln = newln.replace('$', '\\$')
	1624	newln = newln.replace('_', '\\_')
	1625	newln = newln.replace('Â·', '\\textperiodcentered')
	1626	newln = newln.replace('<', '$<$')
	1627	newln = newln.replace('>', '$>$')
	1628	newln = newln.replace('ï', '*')
	1629	# newln = newln.replace('Âº', '$^{\\circ}$')
	1630	newln = newln.replace('Âª', '$^{a}$')
	1631	newln = newln.replace('Âº', '$^{o}$')
	1632	newln = newln.replace('Â°', '$^{\\circ}$')
	1633	newln = newln.replace('\n', '\\\\\n')
	1634	newln = newln.replace('\t', '\\medskip')
	1635
	1636	return newln
	1637
	1638	def pretty_int(minv,maxv,Nint):
	1639	""" Function to plot nice intervals
	1640	minv= minimum value
	1641	maxv= maximum value
	1642	Nint= number of intervals
	1643	>>> pretty_int(23.50,67.21,5)
	1644	[ 25. 30. 35. 40. 45. 50. 55. 60. 65.]
	1645	>>> pretty_int(-23.50,67.21,15)
	1646	[ 0. 20. 40. 60.]
	1647	pretty_int(14.75,25.25,5)
	1648	[ 16. 18. 20. 22. 24.]
	1649	"""
	1650	fname = 'pretty_int'
	1651	nice_int = [1,2,5]
	1652
	1653	# print 'minv: ',minv,'maxv:',maxv,'Nint:',Nint
	1654
	1655	interval = np.abs(maxv - minv)
	1656
	1657	potinterval = np.log10(interval)
	1658	Ipotint = int(potinterval)
	1659	intvalue = np.float(interval / np.float(Nint))
	1660
	1661	# new
	1662	potinterval = np.log10(intvalue)
	1663	Ipotint = int(potinterval)
	1664
	1665	# print 'interval:', interval, 'intavlue:', intvalue, 'potinterval:', potinterval, \
	1666	# 'Ipotint:', Ipotint, 'intvalue:', intvalue
	1667
	1668	mindist = 10.e15
	1669	for inice in nice_int:
	1670	# print inice,':',inice10.Ipotint,np.abs(inice10.**Ipotint - intvalue),mindist
	1671	if np.abs(inice10.*Ipotint - intvalue) < mindist:
	1672	mindist = np.abs(inice10.*Ipotint - intvalue)
	1673	closestint = inice
	1674
	1675	Ibeg = int(minv / (closestint10.*Ipotint))
	1676
	1677	values = []
	1678	val = closestint(Ibeg)10.**(Ipotint)
	1679
	1680	# print 'closestint:',closestint,'Ibeg:',Ibeg,'val:',val
	1681
	1682	while val < maxv:
	1683	values.append(val)
	1684	val = val + closestint10.*Ipotint
	1685
	1686	return np.array(values, dtype=np.float)
	1687
	1688	def DegGradSec_deg(grad,deg,sec):
	1689	""" Function to transform from a coordinate in grad deg sec to degrees (decimal)
	1690	>>> DegGradSec_deg(39.,49.,26.)
	1691	39.8238888889
	1692	"""
	1693	fname = 'DegGradSec_deg'
	1694
	1695	if grad == 'h':
	1696	print fname + '_____________________________________________________________'
	1697	print DegGradSec_deg.__doc__
	1698	quit()
	1699
	1700	deg = grad + deg/60. + sec/3600.
	1701
	1702	return deg
	1703
	1704	def intT2dt(intT,tu):
	1705	""" Function to provide an 'timedelta' object from a given interval value
	1706	intT= interval value
	1707	tu= interval units, [tu]= 'd': day, 'w': week, 'h': hour, 'i': minute, 's': second,
	1708	'l': milisecond
	1709
	1710	>>> intT2dt(3.5,'s')
	1711	0:00:03.500000
	1712
	1713	>>> intT2dt(3.5,'w')
	1714	24 days, 12:00:00
	1715	"""
	1716	import datetime as dt
	1717
	1718	fname = 'intT2dt'
	1719
	1720	if tu == 'w':
	1721	dtv = dt.timedelta(weeks=np.float(intT))
	1722	elif tu == 'd':
	1723	dtv = dt.timedelta(days=np.float(intT))
	1724	elif tu == 'h':
	1725	dtv = dt.timedelta(hours=np.float(intT))
	1726	elif tu == 'i':
	1727	dtv = dt.timedelta(minutes=np.float(intT))
	1728	elif tu == 's':
	1729	dtv = dt.timedelta(seconds=np.float(intT))
	1730	elif tu == 'l':
	1731	dtv = dt.timedelta(milliseconds=np.float(intT))
	1732	else:
	1733	print errormsg
	1734	print ' ' + fname + ': time units "' + tu + '" not ready!!!!'
	1735	quit(-1)
	1736
	1737	return dtv
	1738
	1739	def lonlat_values(mapfile,lonvn,latvn):
	1740	""" Function to obtain the lon/lat matrices from a given netCDF file
	1741	lonlat_values(mapfile,lonvn,latvn)
	1742	[mapfile]= netCDF file name
	1743	[lonvn]= variable name with the longitudes
	1744	[latvn]= variable name with the latitudes
	1745	"""
	1746
	1747	fname = 'lonlat_values'
	1748
	1749	if mapfile == 'h':
	1750	print fname + '_____________________________________________________________'
	1751	print lonlat_values.__doc__
	1752	quit()
	1753
	1754	if not os.path.isfile(mapfile):
	1755	print errormsg
	1756	print ' ' + fname + ": map file '" + mapfile + "' does not exist !!"
	1757	quit(-1)
	1758
	1759	ncobj = NetCDFFile(mapfile, 'r')
	1760	lonobj = ncobj.variables[lonvn]
	1761	latobj = ncobj.variables[latvn]
	1762
	1763	if len(lonobj.shape) == 3:
	1764	lonv = lonobj[0,:,:]
	1765	latv = latobj[0,:,:]
	1766	elif len(lonobj.shape) == 2:
	1767	lonv = lonobj[:,:]
	1768	latv = latobj[:,:]
	1769	elif len(lonobj.shape) == 1:
	1770	lon0 = lonobj[:]
	1771	lat0 = latobj[:]
	1772	lonv = np.zeros( (len(lat0),len(lon0)), dtype=np.float )
	1773	latv = np.zeros( (len(lat0),len(lon0)), dtype=np.float )
	1774	for iy in range(len(lat0)):
	1775	lonv[iy,:] = lon0
	1776	for ix in range(len(lon0)):
	1777	latv[:,ix] = lat0
	1778	else:
	1779	print errormsg
	1780	print ' ' + fname + ': lon/lat variables shape:',lonobj.shape,'not ready!!'
	1781	quit(-1)
	1782
	1783	return lonv, latv
	1784
	1785	def date_CFtime(ind,refd,tunits):
	1786	""" Function to transform from a given date object a CF-convention time
	1787	ind= date object to transform
	1788	refd= reference date
	1789	tunits= units for time
	1790	>>> date_CFtime(dt.datetime(1976,02,17,08,30,00), dt.datetime(1949,12,01,00,00,00), 'seconds')
	1791	827224200.0
	1792	"""
	1793	import datetime as dt
	1794
	1795	fname = 'date_CFtime'
	1796
	1797	dt = ind - refd
	1798
	1799	if tunits == 'weeks':
	1800	value = dt.days/7. + dt.seconds/(3600.24.7.)
	1801	elif tunits == 'days':
	1802	value = dt.days + dt.seconds/(3600.*24.)
	1803	elif tunits == 'hours':
	1804	value = dt.days*24. + dt.seconds/(3600.)
	1805	elif tunits == 'minutes':
	1806	value = dt.days24.60. + dt.seconds/(60.)
	1807	elif tunits == 'seconds':
	1808	value = dt.days24.3600. + dt.seconds
	1809	elif tunits == 'milliseconds':
	1810	value = dt.days24.3600.1000. + dt.seconds1000.
	1811	else:
	1812	print errormsg
	1813	print ' ' + fname + ': reference time units "' + trefu + '" not ready!!!!'
	1814	quit(-1)
	1815
	1816	return value
	1817
	1818	def pot_values(values, uvals):
	1819	""" Function to modify a seies of values by their potency of 10
	1820	pot_values(values, uvals)
	1821	values= values to modify
	1822	uvals= units of the values
	1823	>>> vals = np.sin(np.arange(20)np.pi/5.+0.01)10.e-5
	1824	>>> pot_values(vals,'ms-1')
	1825	(array([ 0.00000000e+00, 5.87785252e-01, 9.51056516e-01,
	1826	9.51056516e-01, 5.87785252e-01, 1.22464680e-16,
	1827	-5.87785252e-01, -9.51056516e-01, -9.51056516e-01,
	1828	-5.87785252e-01, -2.44929360e-16, 5.87785252e-01,
	1829	9.51056516e-01, 9.51056516e-01, 5.87785252e-01,
	1830	3.67394040e-16, -5.87785252e-01, -9.51056516e-01,
	1831	-9.51056516e-01, -5.87785252e-01]), -4, 'x10e-4 ms-1', 'x10e-4')
	1832	"""
	1833
	1834	fname = 'pot_values'
	1835
	1836	if np.min(values) != 0.:
	1837	potmin = int( np.log10( np.abs(np.min(values)) ) )
	1838	else:
	1839	potmin = 0
	1840
	1841	if np.max(values) != 0.:
	1842	potmax = int( np.log10( np.abs(np.max(values)) ) )
	1843	else:
	1844	potmax = 0
	1845
	1846	if potmin * potmax > 9:
	1847	potval = -np.min([np.abs(potmin), np.abs(potmax)]) * np.abs(potmin) / potmin
	1848
	1849	newvalues = values10.*potval
	1850	potvalue = - potval
	1851	potS = 'x10e' + str(potvalue)
	1852	newunits = potS + ' ' + uvals
	1853	else:
	1854	newvalues = values
	1855	potvalue = None
	1856	potS = ''
	1857	newunits = uvals
	1858
	1859	return newvalues, potvalue, newunits, potS
	1860
	1861	def CFtimes_plot(timev,units,kind,tfmt):
	1862	""" Function to provide a list of string values from a CF time values in order
	1863	to use them in a plot, according to the series of characteristics.
	1864	String outputs will be suited to the 'human-like' output
	1865	timev= time values (real values)
	1866	units= units string according to CF conventions ([tunits] since
	1867	[YYYY]-[MM]-[DD] [[HH]:[MI]:[SS]])
	1868	kind= kind of output
	1869	'Nval': according to a given number of values as 'Nval',[Nval]
	1870	'exct': according to an exact time unit as 'exct',[tunit];
	1871	tunit= [Nunits],[tu]; [tu]= 'c': centuries, 'y': year, 'm': month,
	1872	'w': week, 'd': day, 'h': hour, 'i': minute, 's': second,
	1873	'l': milisecond
	1874	tfmt= desired format
	1875	>>> CFtimes_plot(np.arange(100)*1.,'hours since 1979-12-01 00:00:00', 'Nval,5',"%Y/%m/%d %H:%M:%S")
	1876	0.0 1979/12/01 00:00:00
	1877	24.75 1979/12/02 00:45:00
	1878	49.5 1979/12/03 01:30:00
	1879	74.25 1979/12/04 02:15:00
	1880	99.0 1979/12/05 03:00:00
	1881	>>> CFtimes_plot(np.arange(100)*1.,'hours since 1979-12-01 00:00:00', 'exct,2,d',"%Y/%m/%d %H:%M:%S")
	1882	0.0 1979/12/01 00:00:00
	1883	48.0 1979/12/03 00:00:00
	1884	96.0 1979/12/05 00:00:00
	1885	144.0 1979/12/07 00:00:00
	1886	"""
	1887	import datetime as dt
	1888
	1889	# Seconds between 0001 and 1901 Jan - 01
	1890	secs0001_1901=59958144000.
	1891
	1892	fname = 'CFtimes_plot'
	1893
	1894	if timev == 'h':
	1895	print fname + '_____________________________________________________________'
	1896	print CFtimes_plot.__doc__
	1897	quit()
	1898
[558]	1899	secsYear = 365.24.3600.
	1900	secsWeek = 7.24.3600.
	1901	secsDay = 24.*3600.
	1902	secsHour = 3600.
	1903	secsMinute = 60.
	1904	secsMilisecond = 1./1000.
	1905	secsMicrosecond = 1./1000000.
	1906
[192]	1907	# Does reference date contain a time value [YYYY]-[MM]-[DD] [HH]:[MI]:[SS]
	1908	##
	1909	trefT = units.find(':')
	1910	txtunits = units.split(' ')
	1911	Ntxtunits = len(txtunits)
	1912
	1913	if Ntxtunits == 3:
	1914	Srefdate = txtunits[Ntxtunits - 1]
	1915	else:
	1916	Srefdate = txtunits[Ntxtunits - 2]
	1917
	1918	if not trefT == -1:
	1919	# print ' ' + fname + ': refdate with time!'
	1920	if Ntxtunits == 3:
	1921	refdate = datetimeStr_datetime(Srefdate)
	1922	else:
	1923	refdate = datetimeStr_datetime(Srefdate + '_' + txtunits[Ntxtunits - 1])
	1924	else:
	1925	refdate = datetimeStr_datetime(Srefdate + '_00:00:00')
	1926
	1927	trefunits=units.split(' ')[0]
	1928	if trefunits == 'weeks':
	1929	trefu = 'w'
	1930	elif trefunits == 'days':
	1931	trefu = 'd'
	1932	elif trefunits == 'hours':
	1933	trefu = 'h'
	1934	elif trefunits == 'minutes':
	1935	trefu = 'm'
	1936	elif trefunits == 'seconds':
	1937	trefu = 's'
	1938	elif trefunits == 'milliseconds':
	1939	trefu = 'l'
	1940	else:
	1941	print errormsg
	1942	print ' ' + fname + ': reference time units "' + trefu + '" not ready!!!!'
	1943	quit(-1)
	1944
	1945	okind=kind.split(',')[0]
	1946	dtv = len(timev)
	1947
	1948	if refdate.year == 1:
	1949	print warnmsg
	1950	print ' ' + fname + ': changing reference date: ',refdate, \
	1951	'to 1901-01-01_00:00:00 !!!'
	1952	refdate = datetimeStr_datetime('1901-01-01_00:00:00')
	1953	if trefu == 'w': timev = timev - secs0001_1901/(7.24.3600.)
	1954	if trefu == 'd': timev = timev - secs0001_1901/(24.*3600.)
	1955	if trefu == 'h': timev = timev - secs0001_1901/(3600.)
	1956	if trefu == 'm': timev = timev - secs0001_1901/(60.)
	1957	if trefu == 's': timev = timev - secs0001_1901
	1958	if trefu == 'l': timev = timev - secs0001_1901*1000.
	1959
	1960	firstT = timev[0]
	1961	lastT = timev[dtv-1]
	1962
	1963	# First and last times as datetime objects
	1964	firstTdt = timeref_datetime(refdate, firstT, trefunits)
	1965	lastTdt = timeref_datetime(refdate, lastT, trefunits)
	1966
	1967	# First and last times as [year, mon, day, hour, minut, second] vectors
	1968	firstTvec = np.zeros((6), dtype= np.float)
	1969	lastTvec = np.zeros((6), dtype= np.float)
	1970	chTvec = np.zeros((6), dtype= bool)
	1971
	1972	firstTvec = np.array([firstTdt.year, firstTdt.month, firstTdt.day, firstTdt.hour,\
	1973	firstTdt.minute, firstTdt.second])
	1974	lastTvec = np.array([lastTdt.year, lastTdt.month, lastTdt.day, lastTdt.hour, \
	1975	lastTdt.minute, lastTdt.second])
	1976
	1977	chdate= lastTvec - firstTvec
	1978	chTvec = np.where (chdate != 0., True, False)
[558]	1979
	1980	TOTdt = lastTdt - firstTdt
	1981	TOTdtsecs = TOTdt.dayssecsDay + TOTdt.seconds + TOTdt.microsecondssecsMicrosecond
[192]	1982
	1983	timeout = []
	1984	if okind == 'Nval':
	1985	nvalues = int(kind.split(',')[1])
	1986	intervT = (lastT - firstT)/(nvalues-1)
	1987	dtintervT = intT2dt(intervT, trefu)
	1988
	1989	for it in range(nvalues):
	1990	timeout.append(firstTdt + dtintervT*it)
	1991	elif okind == 'exct':
	1992	Nunits = int(kind.split(',')[1])
	1993	tu = kind.split(',')[2]
	1994
	1995	# Generic incremental dt [seconds] according to all the possibilities ['c', 'y', 'm',
	1996	# 'w', 'd', 'h', 'i', 's', 'l'], some of them approximated (because they are not
	1997	# already necessary!)
	1998	basedt = np.zeros((9), dtype=np.float)
	1999	basedt[0] = (365.100. + 25.)24.*3600.
[558]	2000	basedt[1] = secsYear
[192]	2001	basedt[2] = 31.24.3600.
[558]	2002	basedt[3] = secsWeek
	2003	basedt[4] = secsDay
	2004	basedt[5] = secsHour
	2005	basedt[6] = secsMinute
[192]	2006	basedt[7] = 1.
[558]	2007	basedt[8] = secsMilisecond
[192]	2008
	2009	# Increment according to the units of the CF dates
	2010	if trefunits == 'weeks':
[558]	2011	basedt = basedt/(secsWeek)
[192]	2012	elif trefunits == 'days':
[558]	2013	basedt = basedt/(secsDay)
[192]	2014	elif trefunits == 'hours':
[558]	2015	basedt = basedt/(secsHour)
[192]	2016	elif trefunits == 'minutes':
[558]	2017	basedt = basedt/(secsMinute)
[192]	2018	elif trefunits == 'seconds':
	2019	basedt = basedt
	2020	elif trefunits == 'milliseconds':
[558]	2021	basedt = basedt*secsMilisecond
[192]	2022
	2023	if tu == 'c':
	2024	ti = firstTvec[0]
	2025	tf = lastTvec[0]
	2026	centi = firstTvec[0] / 100
	2027
[558]	2028	datev = firstTdt
	2029	while datev < lastTdt:
	2030	yr = datev.year + Nunits*100
	2031	mon = datev.month
	2032	datev = dt.datetime(yr, mon, 1, 0, 0, 0)
	2033	timeout.append(datev)
	2034
[192]	2035	elif tu == 'y':
	2036	ti = firstTvec[0]
	2037	tf = lastTvec[0]
	2038	yeari = firstTvec[0]
	2039
[558]	2040	TOTsteps = int(TOTdtsecs/(Nunits31secsDay)) + 1
	2041
	2042	datev = firstTdt
	2043	while datev < lastTdt:
	2044	yr = datev.year + Nunits
	2045	mon = datev.month
	2046	datev = dt.datetime(yr, mon, 1, 0, 0, 0)
	2047	timeout.append(datev)
	2048
[192]	2049	elif tu == 'm':
	2050	ti = firstTvec[1]
	2051	tf = lastTvec[1]
[558]	2052
[192]	2053	yr = firstTvec[0]
	2054	mon = firstTvec[1]
	2055
[558]	2056	TOTsteps = int(TOTdtsecs/(Nunits31secsDay)) + 1
	2057
	2058	datev = firstTdt
	2059	while datev < lastTdt:
	2060	mon = datev.month + Nunits
[192]	2061	if mon > 12:
	2062	yr = yr + 1
	2063	mon = 1
[558]	2064	datev = dt.datetime(yr, mon, 1, 0, 0, 0)
	2065	timeout.append(datev)
[192]	2066
	2067	elif tu == 'w':
	2068	datev=firstTdt
	2069	it=0
	2070	while datev <= lastTdt:
	2071	datev = firstTdt + dt.timedelta(days=7Nunitsit)
	2072	timeout.append(datev)
	2073	it = it + 1
	2074	elif tu == 'd':
	2075	# datev=firstTdt
	2076	yr = firstTvec[0]
	2077	mon = firstTvec[1]
	2078	day = firstTvec[2]
[645]	2079
[673]	2080	Iunits = np.mod(day,Nunits)
[192]	2081	if np.sum(firstTvec[2:5]) > 0:
	2082	firstTdt = dt.datetime(yr, mon, day+1, 0, 0, 0)
	2083	datev = dt.datetime(yr, mon, day+1, 0, 0, 0)
[645]	2084	elif Iunits != 0:
	2085	nNunits = int(day/Nunits)
	2086	firstTdt = dt.datetime(yr, mon, nNunits*Nunits, 0, 0, 0)
	2087	datev = dt.datetime(yr, mon, nNunits*Nunits, 0, 0, 0)
[192]	2088	else:
	2089	firstTdt = dt.datetime(yr, mon, day, 0, 0, 0)
	2090	datev = dt.datetime(yr, mon, day, 0, 0, 0)
	2091
	2092	it=0
	2093	while datev <= lastTdt:
	2094	datev = firstTdt + dt.timedelta(days=Nunits*it)
	2095	timeout.append(datev)
	2096	it = it + 1
[558]	2097
[192]	2098	elif tu == 'h':
	2099	datev=firstTdt
	2100	yr = firstTvec[0]
	2101	mon = firstTvec[1]
	2102	day = firstTvec[2]
	2103	hour = firstTvec[3]
	2104
[645]	2105	Iunits = np.mod(hour,Nunits)
	2106	if np.sum(firstTvec[4:5]) > 0 or Iunits != 0:
[192]	2107	tadvance = 2*Nunits
	2108	if tadvance >= 24:
	2109	firstTdt = dt.datetime(yr, mon, day+1, 0, 0, 0)
	2110	datev = dt.datetime(yr, mon, day+1, 0, 0, 0)
	2111	else:
[645]	2112	nNunits = int(hour/Nunits)
	2113	firstTdt = dt.datetime(yr, mon, day, nNunits*Nunits, 0, 0)
	2114	datev = dt.datetime(yr, mon, day, nNunits*Nunits, 0, 0)
[192]	2115	else:
	2116	firstTdt = dt.datetime(yr, mon, day, hour, 0, 0)
	2117	datev = dt.datetime(yr, mon, day, hour, 0, 0)
	2118
	2119	it=0
	2120	while datev <= lastTdt:
	2121	datev = firstTdt + dt.timedelta(seconds=Nunits3600it)
	2122	timeout.append(datev)
	2123	it = it + 1
	2124	elif tu == 'i':
	2125	datev=firstTdt
	2126	yr = firstTvec[0]
	2127	mon = firstTvec[1]
	2128	day = firstTvec[2]
	2129	hour = firstTvec[3]
	2130	minu = firstTvec[4]
	2131
[645]	2132	Iunits = np.mod(minu,Nunits)
	2133	if firstTvec[5] > 0 or Iunits != 0:
[192]	2134	tadvance = 2*Nunits
	2135	if tadvance >= 60:
	2136	firstTdt = dt.datetime(yr, mon, day, hour, 0, 0)
	2137	datev = dt.datetime(yr, mon, day, hour, 0, 0)
	2138	else:
[645]	2139	nNunits = int(minu/Nunits)
	2140	firstTdt = dt.datetime(yr, mon, day, hour, nNunits*Nunits, 0)
	2141	datev = dt.datetime(yr, mon, day, hour, nNunits*Nunits, 0)
[192]	2142	else:
	2143	firstTdt = dt.datetime(yr, mon, day, hour, minu, 0)
	2144	datev = dt.datetime(yr, mon, day, hour, minu, 0)
	2145	it=0
	2146	while datev <= lastTdt:
	2147	datev = firstTdt + dt.timedelta(seconds=Nunits60it)
	2148	timeout.append(datev)
	2149	it = it + 1
	2150	elif tu == 's':
	2151	datev=firstTdt
[645]	2152	yr = firstTvec[0]
	2153	mon = firstTvec[1]
	2154	day = firstTvec[2]
	2155	hour = firstTvec[3]
	2156	min = firstTvec[4]
	2157	secu = firstTvec[5]
	2158
	2159	Iunits = np.mod(secu,Nunits)
	2160	if firstTvec[5] > 0 or Iunits != 0:
	2161	tadvance = 2*Nunits
	2162	if tadvance >= 60:
	2163	firstTdt = dt.datetime(yr, mon, day, hour, min, 0)
	2164	datev = dt.datetime(yr, mon, day, hour, min, 0)
	2165	else:
	2166	nNunits = int(minu/Nunits)
	2167	firstTdt = dt.datetime(yr, mon, day, hour, min, nNunits*Nunits)
	2168	datev = dt.datetime(yr, mon, day, hour, min, nNunits*Nunits)
	2169	else:
	2170	firstTdt = dt.datetime(yr, mon, day, hour, min, secu)
	2171	datev = dt.datetime(yr, mon, day, hour, min, secu)
[192]	2172	it=0
	2173	while datev <= lastTdt:
[645]	2174	datev = firstTdt + dt.timedelta(seconds=Nunits*it)
[192]	2175	timeout.append(datev)
	2176	it = it + 1
	2177	elif tu == 'l':
	2178	datev=firstTdt
	2179	it=0
	2180	while datev <= lastTdt:
	2181	datev = firstTdt + dt.timedelta(seconds=Nunits*it/1000.)
	2182	timeout.append(datev)
	2183	it = it + 1
	2184	else:
	2185	print errormsg
	2186	print ' ' + fname + ': exact units "' + tu + '" not ready!!!!!'
	2187	quit(-1)
	2188
	2189	else:
	2190	print errormsg
	2191	print ' ' + fname + ': output kind "' + okind + '" not ready!!!!'
	2192	quit(-1)
	2193
	2194	dtout = len(timeout)
	2195
	2196	timeoutS = []
	2197	timeoutv = np.zeros((dtout), dtype=np.float)
	2198
	2199	for it in range(dtout):
	2200	timeoutS.append(timeout[it].strftime(tfmt))
	2201	timeoutv[it] = date_CFtime(timeout[it], refdate, trefunits)
	2202
	2203	# print it,':',timeoutv[it], timeoutS[it]
	2204
[347]	2205	if len(timeoutv) < 1 or len(timeoutS) < 1:
	2206	print errormsg
	2207	print ' ' + fname + ': no time values are generated!'
	2208	print ' values passed:',timev
	2209	print ' units:',units
	2210	print ' desired kind:',kind
	2211	print ' format:',tfmt
	2212	print ' function values ___ __ _'
	2213	print ' reference date:',refdate
	2214	print ' first date:',firstTdt
	2215	print ' last date:',lastTdt
	2216	print ' icrement:',basedt,trefunits
	2217
	2218	quit(-1)
	2219
[192]	2220	return timeoutv, timeoutS
	2221
	2222	def color_lines(Nlines):
	2223	""" Function to provide a color list to plot lines
	2224	color_lines(Nlines)
	2225	Nlines= number of lines
	2226	"""
	2227
	2228	fname = 'color_lines'
	2229
	2230	colors = ['r', 'b', 'g', 'p', 'g']
	2231
	2232	colorv = []
	2233
	2234	colorv.append('k')
	2235	for icol in range(Nlines):
	2236	colorv.append(colors[icol])
	2237
	2238
	2239	return colorv
	2240
	2241	def output_kind(kindf, namef, close):
	2242	""" Function to generate the output of the figure
	2243	kindf= kind of the output
	2244	null: show in screen
	2245	[jpg/pdf/png/ps]: standard output types
	2246	namef= name of the figure (without extension)
	2247	close= if the graph has to be close or not [True/False]
	2248	"""
	2249	fname = 'output_kind'
	2250
	2251	if kindf == 'h':
	2252	print fname + '_____________________________________________________________'
	2253	print output_kind.__doc__
	2254	quit()
	2255
	2256	if kindf == 'null':
	2257	print 'showing figure...'
	2258	plt.show()
	2259	elif kindf == 'gif':
	2260	plt.savefig(namef + ".gif")
	2261	if close: print "Successfully generation of figure '" + namef + ".jpg' !!!"
	2262	elif kindf == 'jpg':
	2263	plt.savefig(namef + ".jpg")
	2264	if close: print "Successfully generation of figure '" + namef + ".jpg' !!!"
	2265	elif kindf == 'pdf':
	2266	plt.savefig(namef + ".pdf")
	2267	if close: print "Successfully generation of figure '" + namef + ".pdf' !!!"
	2268	elif kindf == 'png':
	2269	plt.savefig(namef + ".png")
	2270	if close: print "Successfully generation of figure '" + namef + ".png' !!!"
	2271	elif kindf == 'ps':
	2272	plt.savefig(namef + ".ps")
	2273	if close: print "Successfully generation of figure '" + namef + ".ps' !!!"
	2274	else:
	2275	print errormsg
	2276	print ' ' + fname + ' output format: "' + kindf + '" not ready !!'
	2277	print errormsg
	2278	quit(-1)
	2279
	2280	if close:
	2281	plt.close()
	2282
	2283	return
	2284
[690]	2285	def check_arguments(funcname,args,expectargs,char):
[192]	2286	""" Function to check the number of arguments if they are coincident
	2287	check_arguments(funcname,Nargs,args,char)
	2288	funcname= name of the function/program to check
	2289	args= passed arguments
[690]	2290	expectargs= expected arguments
[192]	2291	char= character used to split the arguments
	2292	"""
	2293
	2294	fname = 'check_arguments'
	2295
	2296	Nvals = len(args.split(char))
[690]	2297	Nargs = len(expectargs.split(char))
	2298
[192]	2299	if Nvals != Nargs:
	2300	print errormsg
	2301	print ' ' + fname + ': wrong number of arguments:',Nvals," passed to '", \
	2302	funcname, "' which requires:",Nargs,'!!'
[690]	2303	print ' # given expected _______'
	2304	Nmax = np.max([Nvals, Nargs])
	2305	for ia in range(Nmax):
	2306	if ia > Nvals-1:
	2307	aval = ' '
	2308	else:
	2309	aval = args.split(char)[ia]
	2310	if ia > Nargs-1:
	2311	aexp = ' '
	2312	else:
	2313	aexp = expectargs.split(char)[ia]
	2314
	2315	print ' ', ia, aval, aexp
[192]	2316	quit(-1)
	2317
	2318	return
	2319
	2320	def Str_Bool(val):
	2321	""" Function to transform from a String value to a boolean one
	2322	>>> Str_Bool('True')
	2323	True
	2324	>>> Str_Bool('0')
	2325	False
	2326	>>> Str_Bool('no')
	2327	False
	2328	"""
	2329
	2330	fname = 'Str_Bool'
	2331
[647]	2332	if val == 'True' or val == 'true' or val == '1' or val == 'yes':
[192]	2333	boolv = True
[647]	2334	elif val == 'False' or val == 'false' or val == '0' or val== 'no':
[192]	2335	boolv = False
	2336	else:
	2337	print errormsg
	2338	print ' ' + fname + ": value '" + val + "' not ready!!"
	2339	quit(-1)
	2340
	2341	return boolv
	2342
[446]	2343	def coincident_CFtimes(tvalB, tunitA, tunitB):
	2344	""" Function to make coincident times for two different sets of CFtimes
	2345	tvalB= time values B
	2346	tunitA= time units times A to which we want to make coincidence
	2347	tunitB= time units times B
	2348	>>> coincident_CFtimes(np.arange(10),'seconds since 1949-12-01 00:00:00',
	2349	'hours since 1949-12-01 00:00:00')
	2350	[ 0. 3600. 7200. 10800. 14400. 18000. 21600. 25200. 28800. 32400.]
	2351	>>> coincident_CFtimes(np.arange(10),'seconds since 1949-12-01 00:00:00',
	2352	'hours since 1979-12-01 00:00:00')
	2353	[ 9.46684800e+08 9.46688400e+08 9.46692000e+08 9.46695600e+08
	2354	9.46699200e+08 9.46702800e+08 9.46706400e+08 9.46710000e+08
	2355	9.46713600e+08 9.46717200e+08]
	2356	"""
	2357	import datetime as dt
	2358	fname = 'coincident_CFtimes'
	2359
	2360	trefA = tunitA.split(' ')[2] + ' ' + tunitA.split(' ')[3]
	2361	trefB = tunitB.split(' ')[2] + ' ' + tunitB.split(' ')[3]
	2362	tuA = tunitA.split(' ')[0]
	2363	tuB = tunitB.split(' ')[0]
	2364
	2365	if tuA != tuB:
	2366	if tuA == 'microseconds':
	2367	if tuB == 'microseconds':
	2368	tB = tvalB*1.
	2369	elif tuB == 'seconds':
	2370	tB = tvalB*10.e6
	2371	elif tuB == 'minutes':
	2372	tB = tvalB60.10.e6
	2373	elif tuB == 'hours':
	2374	tB = tvalB3600.10.e6
	2375	elif tuB == 'days':
	2376	tB = tvalB3600.24.*10.e6
	2377	else:
	2378	print errormsg
	2379	print ' ' + fname + ": combination of time untis: '" + tuA + \
	2380	"' & '" + tuB + "' not ready !!"
	2381	quit(-1)
	2382	elif tuA == 'seconds':
	2383	if tuB == 'microseconds':
	2384	tB = tvalB/10.e6
	2385	elif tuB == 'seconds':
	2386	tB = tvalB*1.
	2387	elif tuB == 'minutes':
	2388	tB = tvalB*60.
	2389	elif tuB == 'hours':
	2390	tB = tvalB*3600.
	2391	elif tuB == 'days':
	2392	tB = tvalB3600.24.
	2393	else:
	2394	print errormsg
	2395	print ' ' + fname + ": combination of time untis: '" + tuA + \
	2396	"' & '" + tuB + "' not ready !!"
	2397	quit(-1)
	2398	elif tuA == 'minutes':
	2399	if tuB == 'microseconds':
	2400	tB = tvalB/(60.*10.e6)
	2401	elif tuB == 'seconds':
	2402	tB = tvalB/60.
	2403	elif tuB == 'minutes':
	2404	tB = tvalB*1.
	2405	elif tuB == 'hours':
	2406	tB = tvalB*60.
	2407	elif tuB == 'days':
	2408	tB = tvalB60.24.
	2409	else:
	2410	print errormsg
	2411	print ' ' + fname + ": combination of time untis: '" + tuA + \
	2412	"' & '" + tuB + "' not ready !!"
	2413	quit(-1)
	2414	elif tuA == 'hours':
	2415	if tuB == 'microseconds':
	2416	tB = tvalB/(3600.*10.e6)
	2417	elif tuB == 'seconds':
	2418	tB = tvalB/3600.
	2419	elif tuB == 'minutes':
	2420	tB = tvalB/60.
	2421	elif tuB == 'hours':
	2422	tB = tvalB*1.
	2423	elif tuB == 'days':
	2424	tB = tvalB*24.
	2425	else:
	2426	print errormsg
	2427	print ' ' + fname + ": combination of time untis: '" + tuA + \
	2428	"' & '" + tuB + "' not ready !!"
	2429	quit(-1)
	2430	elif tuA == 'days':
	2431	if tuB == 'microseconds':
	2432	tB = tvalB/(24.3600.10.e6)
	2433	elif tuB == 'seconds':
	2434	tB = tvalB/(24.*3600.)
	2435	elif tuB == 'minutes':
	2436	tB = tvalB/(24.*60.)
	2437	elif tuB == 'hours':
	2438	tB = tvalB/24.
	2439	elif tuB == 'days':
	2440	tB = tvalB*1.
	2441	else:
	2442	print errormsg
	2443	print ' ' + fname + ": combination of time untis: '" + tuA + \
	2444	"' & '" + tuB + "' not ready !!"
	2445	quit(-1)
	2446	else:
	2447	print errormsg
	2448	print ' ' + fname + ": time untis: '" + tuA + "' not ready !!"
	2449	quit(-1)
	2450	else:
	2451	tB = tvalB*1.
	2452
	2453	if trefA != trefB:
	2454	trefTA = dt.datetime.strptime(trefA, '%Y-%m-%d %H:%M:%S')
	2455	trefTB = dt.datetime.strptime(trefB, '%Y-%m-%d %H:%M:%S')
	2456
	2457	difft = trefTB - trefTA
	2458	diffv = difft.days24.3600.10.e6 + difft.seconds10.e6 + difft.microseconds
	2459	print ' ' + fname + ': different reference refA:',trefTA,'refB',trefTB
	2460	print ' difference:',difft,':',diffv,'microseconds'
	2461
	2462	if tuA == 'microseconds':
	2463	tB = tB + diffv
	2464	elif tuA == 'seconds':
	2465	tB = tB + diffv/10.e6
	2466	elif tuA == 'minutes':
	2467	tB = tB + diffv/(60.*10.e6)
	2468	elif tuA == 'hours':
	2469	tB = tB + diffv/(3600.*10.e6)
	2470	elif tuA == 'dayss':
	2471	tB = tB + diffv/(24.3600.10.e6)
	2472	else:
	2473	print errormsg
	2474	print ' ' + fname + ": time untis: '" + tuA + "' not ready !!"
	2475	quit(-1)
	2476
	2477	return tB
	2478
	2479	####### ###### ##### #### ### ## #
	2480
[192]	2481	def plot_TimeSeries(valtimes, vunits, tunits, hfileout, vtit, ttit, tkind, tformat, \
[678]	2482	tit, linesn, lloc, kfig,coll,ptl,ptf):
[192]	2483	""" Function to draw time-series
	2484	valtimes= list of arrays to plot [vals1[1values, 1times], [...,valsM[Mvals,Mtimes]])
	2485	vunits= units of the values
	2486	tunits= units of the times
	2487	hfileout= header of the output figure. Final name: [hfileout]_[vtit].[kfig]
	2488	vtit= variable title to be used in the graph
	2489	ttit= time title to be used in the graph
	2490	tkind= kind of time values to appear in the x-axis
	2491	'Nval': according to a given number of values as 'Nval',[Nval]
	2492	'exct': according to an exact time unit as 'exct',[tunit];
	2493	tunit= [Nunits],[tu]; [tu]= 'c': centuries, 'y': year, 'm': month,
	2494	'w': week, 'd': day, 'h': hour, 'i': minute, 's': second,
	2495	'l': milisecond
	2496	tformat= desired format of times
	2497	tit= title of the graph
	2498	linesn= list of values fot the legend
[655]	2499	lloc= location of the legend (0, autmoatic)
[192]	2500	1: 'upper right', 2: 'upper left', 3: 'lower left', 4: 'lower right',
	2501	5: 'right', 6: 'center left', 7: 'center right', 8: 'lower center',
	2502	9: 'upper center', 10: 'center'
	2503	kfig= type of figure: jpg, png, pds, ps
[655]	2504	coll= ',' list of colors for the lines, None for automatic, single
	2505	value all the same
	2506	ptl= ',' list of type of points for the lines, None for automatic, single
	2507	value all the same
[678]	2508	ptf= frequency of point plotting, 'all' for all time steps
[192]	2509	"""
	2510	fname = 'plot_TimeSeries'
	2511
	2512	if valtimes == 'h':
	2513	print fname + '_____________________________________________________________'
	2514	print plot_TimeSeries.__doc__
	2515	quit()
	2516
[673]	2517	Nlines = len(valtimes)
[192]	2518	# Canging line kinds every 7 lines (end of standard colors)
[678]	2519	Npts = len(pointkindsauto)
[655]	2520	linekinds = []
[678]	2521	pointkinds = []
[655]	2522	if ptl is None:
[678]	2523	if ptf is None:
	2524	for ptype in range(Npts):
	2525	for ip in range(7):
	2526	linekinds.append(pointkindsauto[ptype] + '-')
	2527	else:
	2528	for ptype in range(Npts):
	2529	for ip in range(7):
	2530	linekinds.append('-')
	2531	pointkinds.append(pointkindsauto[ptype])
[655]	2532	else:
[678]	2533	if ptf is None:
	2534	if len(ptl) > 1:
	2535	for pt in ptl:
	2536	linekinds.append(pt + '-')
	2537	else:
	2538	for il in range(Nlines):
	2539	linekinds.append(ptl+'-')
[655]	2540	else:
[678]	2541	if len(ptl) > 1:
	2542	for pt in ptl:
	2543	linekinds.append('-')
	2544	pointkinds.append(pt)
	2545	else:
	2546	for il in range(Nlines):
	2547	linekinds.append('-')
	2548	pointkinds = ptl
[192]	2549
	2550	Nvalues = []
	2551	Ntimes = []
	2552
	2553	for il in range(Nlines):
	2554	array = valtimes[il]
	2555
	2556	if Nlines == 1:
	2557	print warnmsg
	2558	print ' ' + fname + ': drawing only one line!'
	2559
	2560	Nvalues.append(array.shape[1])
	2561	Ntimes.append(array.shape[0])
	2562	tmin = np.min(array[1])
	2563	tmax = np.max(array[1])
	2564	vmin = np.min(array[0])
	2565	vmax = np.max(array[0])
	2566	else:
	2567	Nvalues.append(array.shape[1])
	2568	Ntimes.append(array.shape[0])
	2569	tmin = np.min(array[1,:])
	2570	tmax = np.max(array[1,:])
	2571	vmin = np.min(array[0,:])
	2572	vmax = np.max(array[0,:])
	2573
	2574	if il == 0:
	2575	xmin = tmin
	2576	xmax = tmax
	2577	ymin = vmin
	2578	ymax = vmax
	2579	else:
	2580	if tmin < xmin: xmin = tmin
	2581	if tmax > xmax: xmax = tmax
	2582	if vmin < ymin: ymin = vmin
	2583	if vmax > ymax: ymax = vmax
	2584
	2585	dx = np.max(Ntimes)
	2586	dy = np.min(Nvalues)
	2587
	2588	plt.rc('text', usetex=True)
	2589
	2590	print vtit
	2591	if vtit == 'ps':
	2592	plt.ylim(98000.,ymax)
	2593	else:
	2594	plt.ylim(ymin,ymax)
	2595
	2596	plt.xlim(xmin,xmax)
	2597	# print 'x lim:',xmin,xmax
	2598	# print 'y lim:',ymin,ymax
	2599
	2600	N7lines=0
	2601	for il in range(Nlines):
	2602	array = valtimes[il]
	2603	if vtit == 'ps':
	2604	array[0,:] = np.where(array[0,:] < 98000., None, array[0,:])
	2605
[678]	2606	if ptf is None:
	2607	if coll is None:
	2608	if ptf is None:
	2609	plt.plot(array[1,:],array[0,:], linekinds[il], label=linesn[il])
	2610	else:
	2611	plt.plot(array[1,:],array[0,:], linekinds[il], label=linesn[il])
	2612	plt.plot(array[1,::ptf],array[0,::ptf], pointkinds[il], \
	2613	label=linesn[il])
	2614	else:
	2615	if ptf is None:
	2616	plt.plot(array[1,:],array[0,:], linekinds[il], label=linesn[il], \
	2617	color=coll[il])
	2618	else:
	2619	plt.plot(array[1,:],array[0,:], linekinds[il], label=linesn[il], \
	2620	color=coll[il])
	2621	plt.plot(array[1,::ptf],array[0,::ptf], pointkinds[il], \
	2622	label=linesn[il], color=coll[il])
[655]	2623	else:
[678]	2624	if coll is None:
	2625	if ptf is None:
	2626	plt.plot(array[1,:],array[0,:], linekinds[il], label=linesn[il])
	2627	else:
	2628	plt.plot(array[1,:],array[0,:], linekinds[il], label=linesn[il])
	2629	plt.plot(array[1,::ptf],array[0,::ptf], pointkinds[il], \
	2630	label=linesn[il])
	2631	else:
	2632	if ptf is None:
	2633	plt.plot(array[1,:],array[0,:], linekinds[il], label=linesn[il], \
	2634	color=coll[il])
	2635	else:
	2636	plt.plot(array[1,:],array[0,:], linekinds[il], label=linesn[il], \
	2637	color=coll[il])
	2638	plt.plot(array[1,::ptf],array[0,::ptf], pointkinds[il], \
	2639	label=linesn[il], color=coll[il])
[655]	2640
[192]	2641	timevals = np.arange(xmin,xmax)*1.
	2642
	2643	tpos, tlabels = CFtimes_plot(timevals, tunits, tkind, tformat)
	2644
	2645	if len(tpos) > 10:
	2646	print warnmsg
	2647	print ' ' + fname + ': with "' + tkind + '" there are', len(tpos), 'xticks !'
	2648
	2649	plt.xticks(tpos, tlabels)
	2650	# plt.Axes.set_xticklabels(tlabels)
	2651
[673]	2652
[192]	2653	plt.legend(loc=lloc)
	2654	plt.xlabel(ttit)
	2655	plt.ylabel(vtit + " (" + vunits + ")")
[440]	2656	plt.title(tit.replace('_','\_').replace('&','\&'))
[192]	2657
	2658	figname = hfileout + '_' + vtit
	2659
	2660	output_kind(kfig, figname, True)
	2661
	2662	return
	2663
	2664	#Nt = 50
	2665	#Nlines = 3
	2666
	2667	#vtvalsv = []
	2668
	2669	#valsv = np.zeros((2,Nt), dtype=np.float)
	2670	## First
	2671	#valsv[0,:] = np.arange(Nt)
	2672	#valsv[1,:] = np.arange(Nt)*180.
	2673	#vtvalsv.append(valsv)
	2674	#del(valsv)
	2675
	2676	#valsv = np.zeros((2,Nt/2), dtype=np.float)
	2677	## Second
	2678	#valsv[0,:] = np.arange(Nt/2)
	2679	#valsv[1,:] = np.arange(Nt/2)180.2.
	2680	#vtvalsv.append(valsv)
	2681	#del(valsv)
	2682
	2683	#valsv = np.zeros((2,Nt/4), dtype=np.float)
	2684	## Third
	2685	#valsv[0,:] = np.arange(Nt/4)
	2686	#valsv[1,:] = np.arange(Nt/4)180.4.
	2687	#vtvalsv.append(valsv)
	2688	#del(valsv)
	2689
	2690	#varu='mm'
	2691	#timeu='seconds'
	2692
	2693	#title='test'
	2694	#linesname = ['line 1', 'line 2', 'line 3']
	2695
	2696	#plot_TimeSeries(vtvalsv, units_lunits(varu), timeu, 'test', 'vartest', 'time', title, linesname, 'png')
	2697	#quit()
	2698
[549]	2699	def plot_points(xval, yval, vlon, vlat, extravals, extrapar, vtit, mapv, figk, color,\
[545]	2700	labels, lloc, kfig, figname):
[192]	2701	""" plotting points
	2702	[x/yval]: x,y values to plot
[545]	2703	vlon= 2D-matrix with the longitudes
	2704	vlat= 2D-matrix with the latitudes
	2705	extravals= extra values to be added into the plot (None for nothing)
	2706	extrapar= [varname, min, max, cbar, varunits] of the extra variable
	2707	vtit= title of the graph ('\|' for spaces)
[192]	2708	mapv= map characteristics: [proj],[res]
	2709	see full documentation: http://matplotlib.org/basemap/
	2710	[proj]: projection
	2711	* 'cyl', cilindric
[545]	2712	* 'lcc', lambert-conformal
[192]	2713	[res]: resolution:
	2714	* 'c', crude
	2715	* 'l', low
	2716	* 'i', intermediate
	2717	* 'h', high
	2718	* 'f', full
[549]	2719	figK= kind of figure
	2720	'legend': only points in the map with the legend with the names
	2721	'labelled',[txtsize],[txtcol]: points with the names and size, color of text
[545]	2722	color= color for the points/labels ('auto', for "red")
	2723	labels= list of labels for the points (None, no labels)
	2724	lloc = localisation of the legend
	2725	kfig= kind of figure (jpg, pdf, png)
	2726	figname= name of the figure
	2727
[192]	2728	"""
	2729	fname = 'plot_points'
[545]	2730	# Canging line kinds every 7 pts (end of standard colors)
	2731	ptkinds=['.','x','o','*','+','8','>','D','h','p','s']
[192]	2732
[545]	2733	Npts = len(xval)
	2734	if Npts > len(ptkinds)*7:
	2735	print errormsg
	2736	print ' ' + fname + ': too many',Npts,'points!!'
	2737	print " enlarge 'ptkinds' list"
	2738	quit(-1)
[192]	2739
[545]	2740	N7pts = 0
	2741
	2742	if color == 'auto':
	2743	ptcol = "red"
	2744	else:
	2745	ptcol = color
	2746
	2747	dx=vlon.shape[1]
	2748	dy=vlat.shape[0]
	2749
[192]	2750	plt.rc('text', usetex=True)
	2751
	2752	if not mapv is None:
[605]	2753	# vlon = np.where(vlon[:] < 0., 360. + vlon[:], vlon[:])
	2754	# xvala = np.array(xval)
	2755	# xvala = np.where(xvala < 0., 360. + xvala, xvala)
	2756	# xval = list(xvala)
[192]	2757
	2758	map_proj=mapv.split(',')[0]
	2759	map_res=mapv.split(',')[1]
	2760
[545]	2761	nlon = np.min(vlon)
	2762	xlon = np.max(vlon)
	2763	nlat = np.min(vlat)
	2764	xlat = np.max(vlat)
[192]	2765
[545]	2766	lon2 = vlon[dy/2,dx/2]
	2767	lat2 = vlat[dy/2,dx/2]
[192]	2768
	2769	print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:', \
	2770	xlon, ',', xlat
	2771
	2772	if map_proj == 'cyl':
	2773	m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat, \
	2774	urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	2775	elif map_proj == 'lcc':
	2776	m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
	2777	llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
[585]	2778	else:
	2779	print errormsg
	2780	print ' ' + fname + ": map projecion '" + map_proj + "' not ready!!"
	2781	print ' available: cyl, lcc'
	2782	quit(-1)
[192]	2783
[545]	2784	# lons, lats = np.meshgrid(vlon, vlat)
	2785	# lons = np.where(lons < 0., lons + 360., lons)
[192]	2786
[545]	2787	x,y = m(vlon,vlat)
[192]	2788
	2789	m.drawcoastlines()
	2790
	2791	meridians = pretty_int(nlon,xlon,5)
	2792	m.drawmeridians(meridians,labels=[True,False,False,True])
	2793
	2794	parallels = pretty_int(nlat,xlat,5)
	2795	m.drawparallels(parallels,labels=[False,True,True,False])
[585]	2796	else:
	2797	x = vlon
	2798	y = vlat
[192]	2799	# plt.xlim(0,dx-1)
	2800	# plt.ylim(0,dy-1)
	2801
[545]	2802	# Extra values
	2803	if extravals is not None:
	2804	plt.pcolormesh(x, y, extravals, cmap=plt.get_cmap(extrapar[3]), \
	2805	vmin=extrapar[1], vmax=extrapar[2])
	2806	cbar = plt.colorbar()
	2807	cbar.set_label(extrapar[0].replace('_','\_') +'('+ units_lunits(extrapar[4])+\
	2808	')')
[192]	2809
[545]	2810	if labels is not None:
	2811	for iv in range(len(xval)):
	2812	if np.mod(iv,7) == 0: N7pts = N7pts + 1
	2813	# print iv,xval[iv],yval[iv],labels[iv],ptkinds[N7pts]
	2814	plt.plot(xval[iv],yval[iv], ptkinds[N7pts],label=labels[iv])
	2815
[549]	2816	if figk[0:8] == 'labelled':
	2817	txtsize=int(figk.split(',')[1])
	2818	txtcol=figk.split(',')[2]
	2819	for iv in range(len(xval)):
	2820	plt.annotate(labels[iv], xy=(xval[iv],yval[iv]), xycoords='data', \
	2821	fontsize=txtsize, color=txtcol)
	2822	elif figk == 'legend':
	2823	plt.legend(loc=lloc)
	2824
[545]	2825	else:
	2826	plt.plot(xval, yval, '.', color=ptcol)
	2827
[385]	2828	graphtit = vtit.replace('_','\_').replace('&','\&')
[192]	2829
[545]	2830	plt.title(graphtit.replace('\|', ' '))
[192]	2831
	2832	output_kind(kfig, figname, True)
	2833
	2834	return
	2835
[668]	2836	def plot_list_points(xval, yval, varxn, varyn, vtit, figk, color, ptk, pts, labels, lloc, kfig, figname):
[665]	2837	""" plotting points
	2838	[x/yval]: x,y values to plot
[668]	2839	var[x/y]n: names of the x,y variables
[665]	2840	vtit= title of the graph ('\|' for spaces)
	2841	figK= kind of figure
	2842	'legend': only points in the map with the legend with the names
	2843	'labelled',[txtsize],[txtcol]: points with the names and size, color of text
	2844	color= color for the points/labels ('auto', for "red")
	2845	ptk= kind of point
[668]	2846	pts= point size
[665]	2847	labels= list of labels for the points (None, no labels)
	2848	lloc = localisation of the legend
	2849	kfig= kind of figure (jpg, pdf, png)
	2850	figname= name of the figure
	2851
	2852	"""
	2853	fname = 'plot_points'
	2854	# Canging line kinds every 7 pts (end of standard colors)
	2855	ptkinds=['.','x','o','*','+','8','>','D','h','p','s']
	2856
	2857	if color == 'auto':
	2858	ptcol = "red"
	2859	else:
	2860	ptcol = color
	2861
	2862	plt.rc('text', usetex=True)
	2863
	2864	if labels is not None:
	2865	for iv in range(len(xval)):
	2866	# print iv,xval[iv],yval[iv],labels[iv],ptkinds[N7pts]
[668]	2867	plt.plot(xval[iv],yval[iv], ptk, markersize=pts, label=labels[iv])
[665]	2868
	2869	if figk[0:8] == 'labelled':
	2870	txtsize=int(figk.split(',')[1])
	2871	txtcol=figk.split(',')[2]
	2872	for iv in range(len(xval)):
	2873	plt.annotate(labels[iv], xy=(xval[iv],yval[iv]), xycoords='data', \
	2874	fontsize=txtsize, color=txtcol)
	2875	elif figk == 'legend':
	2876	plt.legend(loc=lloc)
	2877
	2878	else:
[668]	2879	plt.plot(xval, yval, ptk, markersize=pts, color=ptcol)
[665]	2880
[668]	2881	plt.xlabel(varxn)
	2882	plt.ylabel(varyn)
	2883
[665]	2884	graphtit = vtit.replace('_','\_').replace('&','\&')
	2885
	2886	plt.title(graphtit.replace('\|', ' '))
	2887
	2888	output_kind(kfig, figname, True)
	2889
	2890	return
	2891
[192]	2892	def plot_2Dfield(varv,dimn,colorbar,vn,vx,unit,olon,olat,ifile,vtit,zvalue,time,tk, \
	2893	tkt,tobj,tvals,tind,kfig,mapv,reva):
	2894	""" Adding labels and other staff to the graph
	2895	varv= 2D values to plot
	2896	dimn= dimension names to plot
	2897	colorbar= name of the color bar to use
	2898	vn,vm= minmum and maximum values to plot
	2899	unit= units of the variable
	2900	olon,olat= longitude, latitude objects
	2901	ifile= name of the input file
	2902	vtit= title of the variable
	2903	zvalue= value on the z axis
	2904	time= value on the time axis
	2905	tk= kind of time (WRF)
	2906	tkt= kind of time taken
	2907	tobj= tim object
	2908	tvals= values of the time variable
	2909	tind= time index
	2910	kfig= kind of figure (jpg, pdf, png)
	2911	mapv= map characteristics: [proj],[res]
	2912	see full documentation: http://matplotlib.org/basemap/
	2913	[proj]: projection
	2914	* 'cyl', cilindric
	2915	[res]: resolution:
	2916	* 'c', crude
	2917	* 'l', low
	2918	* 'i', intermediate
	2919	* 'h', high
	2920	* 'f', full
	2921	reva= reverse the axes (x-->y, y-->x)
	2922	"""
	2923	## import matplotlib as mpl
	2924	## mpl.use('Agg')
	2925	## import matplotlib.pyplot as plt
	2926
	2927	if reva:
	2928	print ' reversing the axes of the figure (x-->y, y-->x)!!'
	2929	varv = np.transpose(varv)
	2930	dimn0 = []
	2931	dimn0.append(dimn[1] + '')
	2932	dimn0.append(dimn[0] + '')
	2933	dimn = dimn0
	2934
	2935	fname = 'plot_2Dfield'
	2936	dx=varv.shape[1]
	2937	dy=varv.shape[0]
	2938
	2939	plt.rc('text', usetex=True)
	2940	# plt.rc('font', family='serif')
	2941
	2942	if not mapv is None:
	2943	if len(olon[:].shape) == 3:
	2944	lon0 = np.where(olon[0,] < 0., 360. + olon[0,], olon[0,])
	2945	lat0 = olat[0,]
	2946	elif len(olon[:].shape) == 2:
	2947	lon0 = np.where(olon[:] < 0., 360. + olon[:], olon[:])
	2948	lat0 = olat[:]
	2949	elif len(olon[:].shape) == 1:
	2950	lon00 = np.where(olon[:] < 0., 360. + olon[:], olon[:])
	2951	lat00 = olat[:]
	2952	lon0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
	2953	lat0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
	2954
	2955	for iy in range(len(lat00)):
	2956	lon0[iy,:] = lon00
	2957	for ix in range(len(lon00)):
	2958	lat0[:,ix] = lat00
	2959
	2960	map_proj=mapv.split(',')[0]
	2961	map_res=mapv.split(',')[1]
	2962
	2963	nlon = lon0[0,0]
	2964	xlon = lon0[dy-1,dx-1]
	2965	nlat = lat0[0,0]
	2966	xlat = lat0[dy-1,dx-1]
	2967
	2968	lon2 = lon0[dy/2,dx/2]
	2969	lat2 = lat0[dy/2,dx/2]
	2970
	2971	print ' lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:', \
	2972	xlon, ',', xlat
	2973
	2974	if map_proj == 'cyl':
	2975	m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat, \
	2976	urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	2977	elif map_proj == 'lcc':
	2978	m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
	2979	llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	2980
	2981	if len(olon[:].shape) == 1:
	2982	lons, lats = np.meshgrid(olon[:], olat[:])
	2983	else:
	2984	lons = olon[0,:]
	2985	lats = olat[:,0]
	2986
	2987	lons = np.where(lons < 0., lons + 360., lons)
	2988
	2989	x,y = m(lons,lats)
	2990	plt.pcolormesh(x,y,varv, cmap=plt.get_cmap(colorbar), vmin=vn, vmax=vx)
	2991	cbar = plt.colorbar()
	2992
	2993	m.drawcoastlines()
	2994	# if (nlon > 180. or xlon > 180.):
	2995	# nlon0 = nlon
	2996	# xlon0 = xlon
	2997	# if (nlon > 180.): nlon0 = nlon - 360.
	2998	# if (xlon > 180.): xlon0 = xlon - 360.
	2999	# meridians = pretty_int(nlon0,xlon0,5)
	3000	# meridians = np.where(meridians < 0., meridians + 360., meridians)
	3001	# else:
	3002	# meridians = pretty_int(nlon,xlon,5)
	3003
	3004	meridians = pretty_int(nlon,xlon,5)
	3005
	3006	m.drawmeridians(meridians,labels=[True,False,False,True])
	3007	parallels = pretty_int(nlat,xlat,5)
	3008	m.drawparallels(parallels,labels=[False,True,True,False])
	3009
	3010	else:
	3011	plt.xlim(0,dx-1)
	3012	plt.ylim(0,dy-1)
	3013
	3014	plt.pcolormesh(varv, cmap=plt.get_cmap(colorbar), vmin=vn, vmax=vx)
	3015	cbar = plt.colorbar()
	3016
	3017	plt.xlabel(dimn[1].replace('_','\_'))
	3018	plt.ylabel(dimn[0].replace('_','\_'))
	3019
	3020	# set the limits of the plot to the limits of the data
	3021	# plt.axis([x.min(), x.max(), y.min(), y.max()])
	3022
	3023	# plt.plot(varv)
	3024	cbar.set_label(unit)
	3025
	3026	figname = ifile.replace('.','_') + '_' + vtit
[385]	3027	graphtit = vtit.replace('_','\_').replace('&','\&')
[192]	3028
	3029	if zvalue != 'null':
	3030	graphtit = graphtit + ' at z= ' + zvalue
	3031	figname = figname + '_z' + zvalue
	3032	if tkt == 'tstep':
	3033	graphtit = graphtit + ' at time-step= ' + time.split(',')[1]
	3034	figname = figname + '_t' + time.split(',')[1].zfill(4)
	3035	elif tkt == 'CFdate':
	3036	graphtit = graphtit + ' at ' + tobj.strfmt("%Y%m%d%H%M%S")
	3037	figname = figname + '_t' + tobj.strfmt("%Y%m%d%H%M%S")
	3038
	3039	if tk == 'WRF':
	3040	# datev = str(timevals[timeind][0:9])
	3041	datev = tvals[tind][0] + tvals[tind][1] + tvals[tind][2] + \
	3042	timevals[timeind][3] + timevals[timeind][4] + timevals[timeind][5] + \
	3043	timevals[timeind][6] + timevals[timeind][7] + timevals[timeind][8] + \
	3044	timevals[timeind][9]
	3045	# timev = str(timevals[timeind][11:18])
	3046	timev = timevals[timeind][11] + timevals[timeind][12] + \
	3047	timevals[timeind][13] + timevals[timeind][14] + timevals[timeind][15] + \
	3048	timevals[timeind][16] + timevals[timeind][17] + timevals[timeind][18]
	3049	graphtit = vtit.replace('_','\_') + ' (' + datev + ' ' + timev + ')'
	3050
	3051	plt.title(graphtit)
	3052
	3053	output_kind(kfig, figname, True)
	3054
	3055	return
	3056
	3057	def plot_2Dfield_easy(varv,dimxv,dimyv,dimn,colorbar,vn,vx,unit,ifile,vtit,kfig,reva):
	3058	""" Adding labels and other staff to the graph
	3059	varv= 2D values to plot
	3060	dim[x/y]v = values at the axes of x and y
	3061	dimn= dimension names to plot
	3062	colorbar= name of the color bar to use
	3063	vn,vm= minmum and maximum values to plot
	3064	unit= units of the variable
	3065	ifile= name of the input file
	3066	vtit= title of the variable
	3067	kfig= kind of figure (jpg, pdf, png)
	3068	reva= reverse the axes (x-->y, y-->x)
	3069	"""
	3070	## import matplotlib as mpl
	3071	## mpl.use('Agg')
	3072	## import matplotlib.pyplot as plt
	3073	fname = 'plot_2Dfield'
	3074
	3075	if reva:
	3076	print ' reversing the axes of the figure (x-->y, y-->x)!!'
	3077	varv = np.transpose(varv)
	3078	dimn0 = []
	3079	dimn0.append(dimn[1] + '')
	3080	dimn0.append(dimn[0] + '')
	3081	dimn = dimn0
	3082	if len(dimyv.shape) == 2:
	3083	x = np.transpose(dimyv)
	3084	else:
	3085	if len(dimxv.shape) == 2:
	3086	ddx = len(dimyv)
	3087	ddy = dimxv.shape[1]
	3088	else:
	3089	ddx = len(dimyv)
	3090	ddy = len(dimxv)
	3091
	3092	x = np.zeros((ddy,ddx), dtype=np.float)
	3093	for j in range(ddy):
	3094	x[j,:] = dimyv
	3095
	3096	if len(dimxv.shape) == 2:
	3097	y = np.transpose(dimxv)
	3098	else:
	3099	if len(dimyv.shape) == 2:
	3100	ddx = dimyv.shape[0]
	3101	ddy = len(dimxv)
	3102	else:
	3103	ddx = len(dimyv)
	3104	ddy = len(dimxv)
	3105
	3106	y = np.zeros((ddy,ddx), dtype=np.float)
	3107	for i in range(ddx):
	3108	y[:,i] = dimxv
	3109	else:
	3110	if len(dimxv.shape) == 2:
	3111	x = dimxv
	3112	else:
	3113	x = np.zeros((len(dimyv),len(dimxv)), dtype=np.float)
	3114	for j in range(len(dimyv)):
	3115	x[j,:] = dimxv
	3116
	3117	if len(dimyv.shape) == 2:
	3118	y = dimyv
	3119	else:
	3120	y = np.zeros((len(dimyv),len(dimxv)), dtype=np.float)
	3121	for i in range(len(dimxv)):
	3122	x[:,i] = dimyv
	3123
	3124	dx=varv.shape[1]
	3125	dy=varv.shape[0]
	3126
	3127	plt.rc('text', usetex=True)
	3128	plt.xlim(0,dx-1)
	3129	plt.ylim(0,dy-1)
	3130
	3131	plt.pcolormesh(x, y, varv, cmap=plt.get_cmap(colorbar), vmin=vn, vmax=vx)
	3132	# plt.pcolormesh(varv, cmap=plt.get_cmap(colorbar), vmin=vn, vmax=vx)
	3133	cbar = plt.colorbar()
	3134
	3135	plt.xlabel(dimn[1].replace('_','\_'))
	3136	plt.ylabel(dimn[0].replace('_','\_'))
	3137
	3138	# set the limits of the plot to the limits of the data
	3139	plt.axis([x.min(), x.max(), y.min(), y.max()])
	3140	# if varv.shape[1] / varv.shape[0] > 10:
	3141	# plt.axes().set_aspect(0.001)
	3142	# else:
	3143	# plt.axes().set_aspect(np.float(varv.shape[0])/np.float(varv.shape[1]))
	3144
	3145	cbar.set_label(unit)
	3146
	3147	figname = ifile.replace('.','_') + '_' + vtit
[385]	3148	graphtit = vtit.replace('_','\_').replace('&','\&')
[192]	3149
	3150	plt.title(graphtit)
	3151
	3152	output_kind(kfig, figname, True)
	3153
	3154	return
	3155
	3156	def plot_Trajectories(lonval, latval, linesn, olon, olat, lonlatLims, gtit, kfig, \
	3157	mapv, obsname):
[665]	3158	""" plotting Trajectories
[192]	3159	[lon/latval]= lon,lat values to plot (as list of vectors)
	3160	linesn: name of the lines
	3161	o[lon/lat]= object with the longitudes and the latitudes of the map to plot
	3162	lonlatLims: limits of longitudes and latitudes [lonmin, latmin, lonmax, latmax]
	3163	gtit= title of the graph
	3164	kfig= kind of figure (jpg, pdf, png)
	3165	mapv= map characteristics: [proj],[res]
	3166	see full documentation: http://matplotlib.org/basemap/
	3167	[proj]: projection
	3168	* 'cyl', cilindric
	3169	* 'lcc', lambert conformal
	3170	[res]: resolution:
	3171	* 'c', crude
	3172	* 'l', low
	3173	* 'i', intermediate
	3174	* 'h', high
	3175	* 'f', full
	3176	obsname= name of the observations in graph (can be None for without).
	3177	Observational trajectory would be the last one
	3178	"""
	3179	fname = 'plot_Trajectories'
	3180
	3181	if lonval == 'h':
	3182	print fname + '_____________________________________________________________'
	3183	print plot_Trajectories.__doc__
	3184	quit()
	3185
	3186	# Canging line kinds every 7 lines (end of standard colors)
	3187	linekinds=['.-','x-','o-']
	3188
	3189	Ntraj = len(lonval)
	3190
	3191	if obsname is not None:
	3192	Ntraj = Ntraj - 1
	3193
	3194	N7lines = 0
	3195
	3196	plt.rc('text', usetex=True)
	3197
	3198	if not mapv is None:
	3199	if len(olon[:].shape) == 3:
	3200	# lon0 = np.where(olon[0,] < 0., 360. + olon[0,], olon[0,])
	3201	lon0 = olon[0,]
	3202	lat0 = olat[0,]
	3203	elif len(olon[:].shape) == 2:
	3204	# lon0 = np.where(olon[:] < 0., 360. + olon[:], olon[:])
	3205	lon0 = olon[:]
	3206	lat0 = olat[:]
	3207	elif len(olon[:].shape) == 1:
	3208	# lon00 = np.where(olon[:] < 0., 360. + olon[:], olon[:])
	3209	lon00 = olon[:]
	3210	lat00 = olat[:]
	3211	lon0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
	3212	lat0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
	3213
	3214	for iy in range(len(lat00)):
	3215	lon0[iy,:] = lon00
	3216	for ix in range(len(lon00)):
	3217	lat0[:,ix] = lat00
	3218
	3219	map_proj=mapv.split(',')[0]
	3220	map_res=mapv.split(',')[1]
	3221
	3222	dx = lon0.shape[1]
	3223	dy = lon0.shape[0]
	3224
	3225	nlon = lon0[0,0]
	3226	xlon = lon0[dy-1,dx-1]
	3227	nlat = lat0[0,0]
	3228	xlat = lat0[dy-1,dx-1]
	3229
	3230	lon2 = lon0[dy/2,dx/2]
	3231	lat2 = lat0[dy/2,dx/2]
	3232
	3233	if lonlatLims is not None:
	3234	plt.xlim(lonlatLims[0], lonlatLims[2])
	3235	plt.ylim(lonlatLims[1], lonlatLims[3])
	3236	if map_proj == 'cyl':
	3237	nlon = lonlatLims[0]
	3238	nlat = lonlatLims[1]
	3239	xlon = lonlatLims[2]
	3240	xlat = lonlatLims[3]
	3241
	3242	print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:', \
	3243	xlon, ',', xlat
	3244
	3245	if map_proj == 'cyl':
	3246	m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat, \
	3247	urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	3248	elif map_proj == 'lcc':
	3249	m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
	3250	llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	3251
	3252	if len(olon.shape) == 3:
	3253	# lons, lats = np.meshgrid(olon[0,:,:], olat[0,:,:])
	3254	lons = olon[0,:,:]
	3255	lats = olat[0,:,:]
	3256
	3257	elif len(olon.shape) == 2:
	3258	# lons, lats = np.meshgrid(olon[:,:], olat[:,:])
	3259	lons = olon[:,:]
	3260	lats = olat[:,:]
	3261	else:
[422]	3262	dx = olon.shape
	3263	dy = olat.shape
	3264	# print errormsg
	3265	# print ' ' + fname + ': shapes of lon/lat objects', olon.shape, \
	3266	# 'not ready!!!'
[192]	3267
	3268	for il in range(Ntraj):
	3269	plt.plot(lonval[il], latval[il], linekinds[N7lines], label= linesn[il])
	3270	if il == 6: N7lines = N7lines + 1
	3271
	3272	m.drawcoastlines()
	3273
	3274	meridians = pretty_int(nlon,xlon,5)
	3275	m.drawmeridians(meridians,labels=[True,False,False,True])
	3276
	3277	parallels = pretty_int(nlat,xlat,5)
	3278	m.drawparallels(parallels,labels=[False,True,True,False])
	3279
	3280	plt.xlabel('W-E')
	3281	plt.ylabel('S-N')
	3282
	3283	else:
	3284	if len(olon.shape) == 3:
	3285	dx = olon.shape[2]
	3286	dy = olon.shape[1]
	3287	elif len(olon.shape) == 2:
	3288	dx = olon.shape[1]
	3289	dy = olon.shape[0]
	3290	else:
[422]	3291	dx = olon.shape
	3292	dy = olat.shape
	3293	# print errormsg
	3294	# print ' ' + fname + ': shapes of lon/lat objects', olon.shape, \
	3295	# 'not ready!!!'
[192]	3296
	3297	if lonlatLims is not None:
	3298	plt.xlim(lonlatLims[0], lonlatLims[2])
	3299	plt.ylim(lonlatLims[1], lonlatLims[3])
	3300	else:
	3301	plt.xlim(np.min(olon[:]),np.max(olon[:]))
	3302	plt.ylim(np.min(olat[:]),np.max(olat[:]))
	3303
	3304	for il in range(Ntraj):
	3305	plt.plot(lonval[il], latval[il], linekinds[N7lines], label= linesn[il])
	3306	if il == 6: N7lines = N7lines + 1
	3307
	3308	plt.xlabel('x-axis')
	3309	plt.ylabel('y-axis')
	3310
	3311	figname = 'trajectories'
	3312	graphtit = gtit
	3313
	3314	if obsname is not None:
	3315	plt.plot(lonval[Ntraj], latval[Ntraj], linestyle='-', color='k', \
	3316	linewidth=3, label= obsname)
	3317
[398]	3318	plt.title(graphtit.replace('_','\_').replace('&','\&'))
[192]	3319	plt.legend()
	3320
	3321	output_kind(kfig, figname, True)
	3322
	3323	return
	3324
	3325	def plot_topo_geogrid(varv, olon, olat, mint, maxt, lonlatLims, gtit, kfig, mapv, \
	3326	closeif):
	3327	""" plotting geo_em.d[nn].nc topography from WPS files
	3328	plot_topo_geogrid(domf, mint, maxt, gtit, kfig, mapv)
	3329	varv= topography values
	3330	o[lon/lat]= longitude and latitude objects
	3331	[min/max]t: minimum and maximum values of topography to draw
	3332	lonlatLims: limits of longitudes and latitudes [lonmin, latmin, lonmax, latmax]
	3333	gtit= title of the graph
	3334	kfig= kind of figure (jpg, pdf, png)
	3335	mapv= map characteristics: [proj],[res]
	3336	see full documentation: http://matplotlib.org/basemap/
	3337	[proj]: projection
	3338	* 'cyl', cilindric
	3339	* 'lcc', lamvbert conformal
	3340	[res]: resolution:
	3341	* 'c', crude
	3342	* 'l', low
	3343	* 'i', intermediate
	3344	* 'h', high
	3345	* 'f', full
	3346	closeif= Boolean value if the figure has to be closed
	3347	"""
	3348	fname = 'plot_topo_geogrid'
	3349
	3350	if varv == 'h':
	3351	print fname + '_____________________________________________________________'
	3352	print plot_topo_geogrid.__doc__
	3353	quit()
	3354
	3355	dx=varv.shape[1]
	3356	dy=varv.shape[0]
	3357
	3358	plt.rc('text', usetex=True)
	3359	# plt.rc('font', family='serif')
	3360
	3361	if not mapv is None:
	3362	if len(olon[:].shape) == 3:
	3363	lon0 = olon[0,]
	3364	lat0 = olat[0,]
	3365	elif len(olon[:].shape) == 2:
	3366	lon0 = olon[:]
	3367	lat0 = olat[:]
	3368	elif len(olon[:].shape) == 1:
	3369	lon00 = olon[:]
	3370	lat00 = olat[:]
	3371	lon0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
	3372	lat0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
	3373
	3374	for iy in range(len(lat00)):
	3375	lon0[iy,:] = lon00
	3376	for ix in range(len(lon00)):
	3377	lat0[:,ix] = lat00
	3378
	3379	map_proj=mapv.split(',')[0]
	3380	map_res=mapv.split(',')[1]
	3381	dx = lon0.shape[1]
	3382	dy = lon0.shape[0]
	3383
	3384	if lonlatLims is not None:
	3385	print ' ' + fname + ': cutting the domain to plot !!!!'
	3386	print ' limits: W-E', lonlatLims[0], lonlatLims[2]
	3387	print ' limits: N-S', lonlatLims[1], lonlatLims[3]
	3388	nlon = lonlatLims[0]
	3389	xlon = lonlatLims[2]
	3390	nlat = lonlatLims[1]
	3391	xlat = lonlatLims[3]
	3392
	3393	if map_proj == 'lcc':
	3394	lon2 = (lonlatLims[0] + lonlatLims[2])/2.
	3395	lat2 = (lonlatLims[1] + lonlatLims[3])/2.
	3396	else:
	3397	nlon = lon0[0,0]
	3398	xlon = lon0[dy-1,dx-1]
	3399	nlat = lat0[0,0]
	3400	xlat = lat0[dy-1,dx-1]
	3401	lon2 = lon0[dy/2,dx/2]
	3402	lat2 = lat0[dy/2,dx/2]
	3403
	3404	plt.xlim(nlon, xlon)
	3405	plt.ylim(nlat, xlat)
	3406	print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:', \
	3407	xlon, ',', xlat
	3408
	3409	if map_proj == 'cyl':
	3410	m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat, \
	3411	urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	3412	elif map_proj == 'lcc':
	3413	m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
	3414	llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	3415	else:
	3416	print errormsg
	3417	print ' ' + fname + ": map projection '" + map_proj + "' not ready !!"
	3418	quit(-1)
	3419
	3420	if len(olon[:].shape) == 1:
	3421	lons, lats = np.meshgrid(olon[:], olat[:])
	3422	else:
	3423	if len(olon[:].shape) == 3:
	3424	lons = olon[0,:,:]
	3425	lats = olat[0,:,:]
	3426	else:
	3427	lons = olon[:]
	3428	lats = olat[:]
	3429
	3430	x,y = m(lons,lats)
	3431
	3432	plt.pcolormesh(x,y,varv, cmap=plt.get_cmap('terrain'), vmin=mint, vmax=maxt)
	3433	cbar = plt.colorbar()
	3434
	3435	m.drawcoastlines()
	3436
	3437	meridians = pretty_int(nlon,xlon,5)
	3438	m.drawmeridians(meridians,labels=[True,False,False,True])
	3439
	3440	parallels = pretty_int(nlat,xlat,5)
	3441	m.drawparallels(parallels,labels=[False,True,True,False])
	3442
	3443	plt.xlabel('W-E')
	3444	plt.ylabel('S-N')
	3445	else:
	3446	print emsg
	3447	print ' ' + fname + ': A projection parameter is needed None given !!'
	3448	quit(-1)
	3449
	3450	figname = 'domain'
	3451	graphtit = gtit.replace('_','\_')
	3452	cbar.set_label('height ($m$)')
	3453
[398]	3454	plt.title(graphtit.replace('_','\_').replace('&','\&'))
[192]	3455
	3456	output_kind(kfig, figname, closeif)
	3457
	3458	return
	3459
	3460	def plot_topo_geogrid_boxes(varv, boxesX, boxesY, boxlabels, olon, olat, mint, maxt, \
[655]	3461	lonlatLims, gtit, kfig, mapv, gloc, closeif):
[192]	3462	""" plotting geo_em.d[nn].nc topography from WPS files
	3463	plot_topo_geogrid(domf, mint, maxt, gtit, kfig, mapv)
	3464	varv= topography values
	3465	boxesX/Y= 4-line sets to draw the boxes
	3466	boxlabels= labels for the legend of the boxes
	3467	o[lon/lat]= longitude and latitude objects
	3468	[min/max]t: minimum and maximum values of topography to draw
	3469	lonlatLims: limits of longitudes and latitudes [lonmin, latmin, lonmax, latmax]
	3470	gtit= title of the graph
	3471	kfig= kind of figure (jpg, pdf, png)
	3472	mapv= map characteristics: [proj],[res]
	3473	see full documentation: http://matplotlib.org/basemap/
	3474	[proj]: projection
	3475	* 'cyl', cilindric
	3476	* 'lcc', lamvbert conformal
	3477	[res]: resolution:
	3478	* 'c', crude
	3479	* 'l', low
	3480	* 'i', intermediate
	3481	* 'h', high
	3482	* 'f', full
[655]	3483	gloc= location of the legend (0, autmoatic)
	3484	1: 'upper right', 2: 'upper left', 3: 'lower left', 4: 'lower right',
	3485	5: 'right', 6: 'center left', 7: 'center right', 8: 'lower center',
	3486	9: 'upper center', 10: 'center'
[192]	3487	closeif= Boolean value if the figure has to be closed
	3488	"""
	3489	fname = 'plot_topo_geogrid'
	3490
	3491	if varv == 'h':
	3492	print fname + '_____________________________________________________________'
	3493	print plot_topo_geogrid.__doc__
	3494	quit()
	3495
	3496	cols = color_lines(len(boxlabels))
	3497
	3498	dx=varv.shape[1]
	3499	dy=varv.shape[0]
	3500
	3501	plt.rc('text', usetex=True)
	3502	# plt.rc('font', family='serif')
	3503
	3504	if not mapv is None:
	3505	if len(olon[:].shape) == 3:
	3506	lon0 = olon[0,]
	3507	lat0 = olat[0,]
	3508	elif len(olon[:].shape) == 2:
	3509	lon0 = olon[:]
	3510	lat0 = olat[:]
	3511	elif len(olon[:].shape) == 1:
	3512	lon00 = olon[:]
	3513	lat00 = olat[:]
	3514	lon0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
	3515	lat0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
	3516
	3517	for iy in range(len(lat00)):
	3518	lon0[iy,:] = lon00
	3519	for ix in range(len(lon00)):
	3520	lat0[:,ix] = lat00
	3521
	3522	map_proj=mapv.split(',')[0]
	3523	map_res=mapv.split(',')[1]
	3524	dx = lon0.shape[1]
	3525	dy = lon0.shape[0]
	3526
	3527	if lonlatLims is not None:
	3528	print ' ' + fname + ': cutting the domain to plot !!!!'
	3529	print ' limits: W-E', lonlatLims[0], lonlatLims[2]
	3530	print ' limits: N-S', lonlatLims[1], lonlatLims[3]
	3531	nlon = lonlatLims[0]
	3532	xlon = lonlatLims[2]
	3533	nlat = lonlatLims[1]
	3534	xlat = lonlatLims[3]
	3535
	3536	if map_proj == 'lcc':
	3537	lon2 = (lonlatLims[0] + lonlatLims[2])/2.
	3538	lat2 = (lonlatLims[1] + lonlatLims[3])/2.
	3539	else:
	3540	nlon = np.min(lon0)
	3541	xlon = np.max(lon0)
	3542	nlat = np.min(lat0)
	3543	xlat = np.max(lat0)
	3544	lon2 = lon0[dy/2,dx/2]
	3545	lat2 = lat0[dy/2,dx/2]
	3546
	3547	plt.xlim(nlon, xlon)
	3548	plt.ylim(nlat, xlat)
	3549	print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:', \
	3550	xlon, ',', xlat
	3551
	3552	if map_proj == 'cyl':
	3553	m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat, \
	3554	urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	3555	elif map_proj == 'lcc':
	3556	m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
	3557	llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
[522]	3558	else:
	3559	print errormsg
	3560	print ' ' + fname + ": projection '" + map_proj + "' does not exist!!"
	3561	print ' existing ones: cyl, lcc'
	3562	quit(-1)
[192]	3563
	3564	if len(olon[:].shape) == 1:
	3565	lons, lats = np.meshgrid(olon[:], olat[:])
	3566	else:
	3567	if len(olon[:].shape) == 3:
	3568	lons = olon[0,:,:]
	3569	lats = olat[0,:,:]
	3570	else:
	3571	lons = olon[:]
	3572	lats = olat[:]
	3573
	3574	x,y = m(lons,lats)
	3575
	3576	plt.pcolormesh(x,y,varv, cmap=plt.get_cmap('terrain'), vmin=mint, vmax=maxt)
	3577	cbar = plt.colorbar()
	3578
	3579	Nboxes = len(boxesX)/4
	3580	for ibox in range(Nboxes):
	3581	plt.plot(boxesX[ibox4], boxesY[ibox4], linestyle='-', linewidth=3, \
	3582	label=boxlabels[ibox], color=cols[ibox])
	3583	plt.plot(boxesX[ibox4+1], boxesY[ibox4+1], linestyle='-', linewidth=3, \
	3584	color=cols[ibox])
	3585	plt.plot(boxesX[ibox4+2], boxesY[ibox4+2], linestyle='-', linewidth=3, \
	3586	color=cols[ibox])
	3587	plt.plot(boxesX[ibox4+3], boxesY[ibox4+3], linestyle='-', linewidth=3, \
	3588	color=cols[ibox])
	3589
	3590	m.drawcoastlines()
	3591
	3592	meridians = pretty_int(nlon,xlon,5)
	3593	m.drawmeridians(meridians,labels=[True,False,False,True])
	3594
	3595	parallels = pretty_int(nlat,xlat,5)
	3596	m.drawparallels(parallels,labels=[False,True,True,False])
	3597
	3598	plt.xlabel('W-E')
	3599	plt.ylabel('S-N')
	3600	else:
	3601	print emsg
	3602	print ' ' + fname + ': A projection parameter is needed None given !!'
	3603	quit(-1)
	3604
	3605	figname = 'domain_boxes'
[385]	3606	graphtit = gtit.replace('_','\_').replace('&','\&')
[192]	3607	cbar.set_label('height ($m$)')
	3608
	3609	plt.title(graphtit)
[655]	3610	plt.legend(loc=gloc)
[192]	3611
	3612	output_kind(kfig, figname, closeif)
	3613
	3614	return
	3615
	3616	def plot_2D_shadow(varsv,vnames,dimxv,dimyv,dimxu,dimyu,dimn, \
	3617	colorbar,vs,uts,vtit,kfig,reva,mapv,ifclose):
	3618	""" Adding labels and other staff to the graph
	3619	varsv= 2D values to plot with shading
	3620	vnames= variable names for the figure
	3621	dim[x/y]v = values at the axes of x and y
	3622	dim[x/y]u = units at the axes of x and y
	3623	dimn= dimension names to plot
	3624	colorbar= name of the color bar to use
	3625	vs= minmum and maximum values to plot in shadow or:
	3626	'Srange': for full range
	3627	'Saroundmean@val': for mean-xtrm,mean+xtrm where xtrm = np.min(mean-min@val,max@val-mean)
	3628	'Saroundminmax@val': for minval,maxval
	3629	'Saroundpercentile@val': for median-xtrm,median+xtrm where xtrm = np.min(median-percentile_(val),
	3630	percentile_(100-val)-median)
	3631	'Smean@val': for -xtrm,xtrm where xtrm = np.min(mean-min@val,max@val-mean)
	3632	'Smedian@val': for -xtrm,xtrm where xtrm = np.min(median-min@val,max@val-median)
	3633	'Spercentile@val': for -xtrm,xtrm where xtrm = np.min(median-percentile_(val),
	3634	percentile_(100-val)-median)
	3635	uts= units of the variable to shadow
	3636	vtit= title of the variable
	3637	kfig= kind of figure (jpg, pdf, png)
	3638	reva= ('\|' for combination)
	3639	* 'transpose': reverse the axes (x-->y, y-->x)
	3640	* 'flip'@[x/y]: flip the axis x or y
	3641	mapv= map characteristics: [proj],[res]
	3642	see full documentation: http://matplotlib.org/basemap/
	3643	[proj]: projection
	3644	* 'cyl', cilindric
	3645	* 'lcc', lambert conformal
	3646	[res]: resolution:
	3647	* 'c', crude
	3648	* 'l', low
	3649	* 'i', intermediate
	3650	* 'h', high
	3651	* 'f', full
	3652	ifclose= boolean value whether figure should be close (finish) or not
	3653	"""
	3654	## import matplotlib as mpl
	3655	## mpl.use('Agg')
	3656	## import matplotlib.pyplot as plt
	3657	fname = 'plot_2D_shadow'
	3658
	3659	# print dimyv[73,21]
	3660	# dimyv[73,21] = -dimyv[73,21]
	3661	# print 'Lluis dimsv: ',np.min(dimxv), np.max(dimxv), ':', np.min(dimyv), np.max(dimyv)
	3662
	3663	if varsv == 'h':
	3664	print fname + '_____________________________________________________________'
	3665	print plot_2D_shadow.__doc__
	3666	quit()
	3667
	3668	if len(varsv.shape) != 2:
	3669	print errormsg
[652]	3670	print ' ' + fname + ': wrong variable shape:',varsv.shape,'is has to be 2D!!'
[192]	3671	quit(-1)
	3672
	3673	reva0 = ''
	3674	if reva.find('\|') != 0:
	3675	revas = reva.split('\|')
	3676	else:
	3677	revas = [reva]
	3678	reva0 = reva
	3679
	3680	for rev in revas:
	3681	if reva[0:4] == 'flip':
	3682	reva0 = 'flip'
	3683	if len(reva.split('@')) != 2:
	3684	print errormsg
	3685	print ' ' + fname + ': flip is given', reva, 'but not axis!'
	3686	quit(-1)
	3687
	3688	if rev == 'transpose':
	3689	print ' reversing the axes of the figure (x-->y, y-->x)!!'
	3690	varsv = np.transpose(varsv)
	3691	dxv = dimyv
	3692	dyv = dimxv
	3693	dimxv = dxv
	3694	dimyv = dyv
	3695
	3696	if len(dimxv[:].shape) == 3:
	3697	xdims = '1,2'
	3698	elif len(dimxv[:].shape) == 2:
	3699	xdims = '0,1'
	3700	elif len(dimxv[:].shape) == 1:
	3701	xdims = '0'
	3702
	3703	if len(dimyv[:].shape) == 3:
	3704	ydims = '1,2'
	3705	elif len(dimyv[:].shape) == 2:
	3706	ydims = '0,1'
	3707	elif len(dimyv[:].shape) == 1:
	3708	ydims = '0'
	3709
[652]	3710	# lon0 = dimxv
	3711	# lat0 = dimyv
	3712	lon0, lat0 = dxdy_lonlat(dimxv,dimyv, xdims, ydims)
[192]	3713
	3714	if not mapv is None:
	3715	map_proj=mapv.split(',')[0]
	3716	map_res=mapv.split(',')[1]
	3717
	3718	dx = lon0.shape[1]
	3719	dy = lat0.shape[0]
	3720
	3721	nlon = lon0[0,0]
	3722	xlon = lon0[dy-1,dx-1]
	3723	nlat = lat0[0,0]
	3724	xlat = lat0[dy-1,dx-1]
	3725
	3726	# Thats too much! :)
	3727	# if lonlatLims is not None:
	3728	# print ' ' + fname + ': cutting the domain to plot !!!!'
	3729	# plt.xlim(lonlatLims[0], lonlatLims[2])
	3730	# plt.ylim(lonlatLims[1], lonlatLims[3])
	3731	# print ' limits: W-E', lonlatLims[0], lonlatLims[2]
	3732	# print ' limits: N-S', lonlatLims[1], lonlatLims[3]
	3733
	3734	# if map_proj == 'cyl':
	3735	# nlon = lonlatLims[0]
	3736	# nlat = lonlatLims[1]
	3737	# xlon = lonlatLims[2]
	3738	# xlat = lonlatLims[3]
	3739	# elif map_proj == 'lcc':
	3740	# lon2 = (lonlatLims[0] + lonlatLims[2])/2.
	3741	# lat2 = (lonlatLims[1] + lonlatLims[3])/2.
	3742	# nlon = lonlatLims[0]
	3743	# xlon = lonlatLims[2]
	3744	# nlat = lonlatLims[1]
	3745	# xlat = lonlatLims[3]
	3746
	3747	lon2 = lon0[dy/2,dx/2]
	3748	lat2 = lat0[dy/2,dx/2]
	3749
	3750	print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:', \
	3751	xlon, ',', xlat
	3752
	3753	if map_proj == 'cyl':
	3754	m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat, \
	3755	urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	3756	elif map_proj == 'lcc':
	3757	m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
	3758	llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	3759	else:
	3760	print errormsg
	3761	print ' ' + fname + ": map projection '" + map_proj + "' not defined!!!"
	3762	print ' available: cyl, lcc'
	3763	quit(-1)
	3764
	3765	x,y = m(lon0,lat0)
	3766
	3767	else:
	3768	x = lon0
	3769	y = lat0
	3770
	3771	vsend = np.zeros((2), dtype=np.float)
	3772	# Changing limits of the colors
	3773	if type(vs[0]) != type(np.float(1.)):
	3774	if vs[0] == 'Srange':
	3775	vsend[0] = np.min(varsv)
	3776	elif vs[0][0:11] == 'Saroundmean':
	3777	meanv = np.mean(varsv)
	3778	permean = np.float(vs[0].split('@')[1])
	3779	minv = np.min(varsv)*permean
	3780	maxv = np.max(varsv)*permean
	3781	minextrm = np.min([np.abs(meanv-minv), np.abs(maxv-meanv)])
	3782	vsend[0] = meanv-minextrm
	3783	vsend[1] = meanv+minextrm
	3784	elif vs[0][0:13] == 'Saroundminmax':
	3785	permean = np.float(vs[0].split('@')[1])
	3786	minv = np.min(varsv)*permean
	3787	maxv = np.max(varsv)*permean
	3788	vsend[0] = minv
	3789	vsend[1] = maxv
	3790	elif vs[0][0:17] == 'Saroundpercentile':
	3791	medianv = np.median(varsv)
	3792	valper = np.float(vs[0].split('@')[1])
	3793	minv = np.percentile(varsv, valper)
	3794	maxv = np.percentile(varsv, 100.-valper)
	3795	minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
	3796	vsend[0] = medianv-minextrm
	3797	vsend[1] = medianv+minextrm
	3798	elif vs[0][0:5] == 'Smean':
	3799	meanv = np.mean(varsv)
	3800	permean = np.float(vs[0].split('@')[1])
	3801	minv = np.min(varsv)*permean
	3802	maxv = np.max(varsv)*permean
	3803	minextrm = np.min([np.abs(meanv-minv), np.abs(maxv-meanv)])
	3804	vsend[0] = -minextrm
	3805	vsend[1] = minextrm
	3806	elif vs[0][0:7] == 'Smedian':
	3807	medianv = np.median(varsv)
	3808	permedian = np.float(vs[0].split('@')[1])
	3809	minv = np.min(varsv)*permedian
	3810	maxv = np.max(varsv)*permedian
	3811	minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
	3812	vsend[0] = -minextrm
	3813	vsend[1] = minextrm
	3814	elif vs[0][0:11] == 'Spercentile':
	3815	medianv = np.median(varsv)
	3816	valper = np.float(vs[0].split('@')[1])
	3817	minv = np.percentile(varsv, valper)
	3818	maxv = np.percentile(varsv, 100.-valper)
	3819	minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
	3820	vsend[0] = -minextrm
	3821	vsend[1] = minextrm
	3822	else:
	3823	print errormsg
	3824	print ' ' + fname + ": range '" + vs[0] + "' not ready!!!"
	3825	quit(-1)
	3826	print ' ' + fname + ': modified shadow min,max:',vsend
	3827	else:
	3828	vsend[0] = vs[0]
	3829
	3830	if type(vs[0]) != type(np.float(1.)):
	3831	if vs[1] == 'range':
	3832	vsend[1] = np.max(varsv)
	3833	else:
	3834	vsend[1] = vs[1]
	3835
	3836	plt.rc('text', usetex=True)
	3837
	3838	plt.pcolormesh(x, y, varsv, cmap=plt.get_cmap(colorbar), vmin=vsend[0], vmax=vsend[1])
	3839	cbar = plt.colorbar()
	3840
	3841	if not mapv is None:
[530]	3842	if colorbar == 'gist_gray':
	3843	m.drawcoastlines(color="red")
	3844	else:
	3845	m.drawcoastlines()
[192]	3846
	3847	meridians = pretty_int(nlon,xlon,5)
	3848	m.drawmeridians(meridians,labels=[True,False,False,True])
	3849	parallels = pretty_int(nlat,xlat,5)
	3850	m.drawparallels(parallels,labels=[False,True,True,False])
	3851
	3852	plt.xlabel('W-E')
	3853	plt.ylabel('S-N')
	3854	else:
	3855	plt.xlabel(variables_values(dimn[1])[0].replace('_','\_') + ' (' + \
	3856	units_lunits(dimxu) + ')')
	3857	plt.ylabel(variables_values(dimn[0])[0].replace('_','\_') + ' (' + \
	3858	units_lunits(dimyu) + ')')
	3859
	3860	txpos = pretty_int(x.min(),x.max(),5)
	3861	typos = pretty_int(y.min(),y.max(),5)
	3862	txlabels = list(txpos)
	3863	for i in range(len(txlabels)): txlabels[i] = str(txlabels[i])
	3864	tylabels = list(typos)
	3865	for i in range(len(tylabels)): tylabels[i] = str(tylabels[i])
	3866
	3867	# set the limits of the plot to the limits of the data
	3868
	3869	if searchInlist(revas,'transpose'):
	3870	x0 = y
	3871	y0 = x
	3872	x = x0
	3873	y = y0
	3874	# print 'Lluis reva0:',reva0,'x min,max:',x.min(),x.max(),' y min,max:',y.min(),y.max()
	3875
	3876	if reva0 == 'flip':
	3877	if reva.split('@')[1] == 'x':
	3878	plt.axis([x.max(), x.min(), y.min(), y.max()])
	3879	elif reva.split('@')[1] == 'y':
	3880	plt.axis([x.min(), x.max(), y.max(), y.min()])
	3881	else:
	3882	plt.axis([x.max(), x.min(), y.max(), y.min()])
	3883	else:
	3884	plt.axis([x.min(), x.max(), y.min(), y.max()])
	3885
	3886	if mapv is None:
	3887	plt.xticks(txpos, txlabels)
	3888	plt.yticks(typos, tylabels)
	3889
	3890	# units labels
	3891	cbar.set_label(vnames.replace('_','\_') + ' (' + units_lunits(uts) + ')')
	3892
	3893	figname = '2Dfields_shadow'
	3894	graphtit = vtit.replace('_','\_').replace('&','\&')
	3895
	3896	plt.title(graphtit)
	3897
	3898	output_kind(kfig, figname, ifclose)
	3899
	3900	return
	3901
	3902	#Nvals=50
	3903	#vals1 = np.zeros((Nvals,Nvals), dtype= np.float)
	3904	#for j in range(Nvals):
	3905	# for i in range(Nvals):
	3906	# vals1[j,i]=np.sqrt((j-Nvals/2)2. + (i-Nvals/2)2.)
	3907
	3908	#plot_2D_shadow(vals1, 'var1', np.arange(50)1., np.arange(50)1., 'ms-1', \
	3909	# 'm', ['lat','lon'], 'rainbow', [0, Nvals], 'ms-1', 'test var1', 'pdf', 'None', \
	3910	# None, True)
	3911	#quit()
	3912
[638]	3913	def transform(vals, dxv, dyv, dxt, dyt, dxl, dyl, dxtit, dytit, trans):
	3914	""" Function to transform the values and the axes
	3915	vals= values to transform
	3916	d[x/y]v= original values for the [x/y]-axis
	3917	d[x/y]t= original ticks for the [x/y]-axis
	3918	d[x/y]l= original tick-labels for the [x/y]-axis
	3919	d[x/y]tit= original titels for the [x/y]-axis
	3920	trans= '\|' separated list of operations of transformation
	3921	'transpose': Transpose matrix of values (x-->y, y-->x)
	3922	'flip@[x/y]': Flip the given axis
	3923	"""
	3924	fname = 'transform'
	3925
	3926	return newvals, newdxv, newdyv
	3927
[192]	3928	def plot_2D_shadow_time(varsv,vnames,dimxv,dimyv,dimxu,dimyu,dimn,colorbar,vs,uts, \
	3929	vtit,kfig,reva,taxis,tpos,tlabs,ifclose):
	3930	""" Plotting a 2D field with one of the axes being time
	3931	varsv= 2D values to plot with shading
	3932	vnames= shading variable name for the figure
	3933	dim[x/y]v= values at the axes of x and y
	3934	dim[x/y]u= units at the axes of x and y
	3935	dimn= dimension names to plot
	3936	colorbar= name of the color bar to use
	3937	vs= minmum and maximum values to plot in shadow or:
	3938	'Srange': for full range
	3939	'Saroundmean@val': for mean-xtrm,mean+xtrm where xtrm = np.min(mean-min@val,max@val-mean)
	3940	'Saroundminmax@val': for minval,maxval
	3941	'Saroundpercentile@val': for median-xtrm,median+xtrm where xtrm = np.min(median-percentile_(val),
	3942	percentile_(100-val)-median)
	3943	'Smean@val': for -xtrm,xtrm where xtrm = np.min(mean-min@val,max@val-mean)
	3944	'Smedian@val': for -xtrm,xtrm where xtrm = np.min(median-min@val,max@val-median)
	3945	'Spercentile@val': for -xtrm,xtrm where xtrm = np.min(median-percentile_(val),
	3946	percentile_(100-val)-median)
	3947	uts= units of the variable to shadow
	3948	vtit= title of the variable
	3949	kfig= kind of figure (jpg, pdf, png)
	3950	reva=
	3951	* 'transpose': reverse the axes (x-->y, y-->x)
	3952	* 'flip'@[x/y]: flip the axis x or y
	3953	taxis= Which is the time-axis
	3954	tpos= positions of the time ticks
	3955	tlabs= labels of the time ticks
	3956	ifclose= boolean value whether figure should be close (finish) or not
	3957	"""
	3958	fname = 'plot_2D_shadow_time'
	3959
	3960	if varsv == 'h':
	3961	print fname + '_____________________________________________________________'
	3962	print plot_2D_shadow_time.__doc__
	3963	quit()
	3964
	3965	# Definning ticks labels
	3966	if taxis == 'x':
	3967	txpos = tpos
	3968	txlabels = tlabs
	3969	plxlabel = dimxu
	3970	typos = pretty_int(np.min(dimyv),np.max(dimyv),10)
	3971	tylabels = list(typos)
	3972	for i in range(len(tylabels)): tylabels[i] = str(tylabels[i])
	3973	plylabel = variables_values(dimn[0])[0].replace('_','\_') + ' (' + \
	3974	units_lunits(dimyu) + ')'
	3975	else:
	3976	txpos = pretty_int(np.min(dimxv),np.max(dimxv),10)
	3977	txlabels = list(txpos)
	3978	plxlabel = variables_values(dimn[1])[0].replace('_','\_') + ' (' + \
	3979	units_lunits(dimxu) + ')'
	3980	typos = tpos
	3981	tylabels = tlabs
	3982	plylabel = dimyu
	3983
	3984	# Transposing/flipping axis
	3985	if reva.find('\|') != 0:
	3986	revas = reva.split('\|')
	3987	reva0 = ''
	3988	else:
	3989	revas = [reva]
	3990	reva0 = reva
	3991
	3992	for rev in revas:
	3993	if rev[0:4] == 'flip':
	3994	reva0 = 'flip'
	3995	if len(reva.split('@')) != 2:
	3996	print errormsg
	3997	print ' ' + fname + ': flip is given', reva, 'but not axis!'
	3998	quit(-1)
	3999	else:
	4000	print " flipping '" + rev.split('@')[1] + "' axis !"
	4001
	4002	if rev == 'transpose':
	4003	print ' reversing the axes of the figure (x-->y, y-->x)!!'
	4004	# Flipping values of variable
	4005	varsv = np.transpose(varsv)
	4006	dxv = dimyv
	4007	dyv = dimxv
	4008	dimxv = dxv
	4009	dimyv = dyv
	4010
	4011	if len(dimxv.shape) == 3:
	4012	dxget='1,2'
	4013	elif len(dimxv.shape) == 2:
	4014	dxget='0,1'
	4015	elif len(dimxv.shape) == 1:
	4016	dxget='0'
	4017	else:
	4018	print errormsg
	4019	print ' ' + fname + ': shape of x-values:',dimxv.shape,'not ready!!'
	4020	quit(-1)
	4021
	4022	if len(dimyv.shape) == 3:
	4023	dyget='1,2'
	4024	elif len(dimyv.shape) == 2:
	4025	dyget='0,1'
	4026	elif len(dimyv.shape) == 1:
	4027	dyget='0'
	4028	else:
	4029	print errormsg
	4030	print ' ' + fname + ': shape of y-values:',dimyv.shape,'not ready!!'
	4031	quit(-1)
	4032
	4033	x,y = dxdy_lonlat(dimxv,dimyv,dxget,dyget)
	4034
	4035	plt.rc('text', usetex=True)
	4036
	4037	vsend = np.zeros((2), dtype=np.float)
	4038	# Changing limits of the colors
	4039	if type(vs[0]) != type(np.float(1.)):
	4040	if vs[0] == 'Srange':
	4041	vsend[0] = np.min(varsv)
	4042	elif vs[0][0:11] == 'Saroundmean':
	4043	meanv = np.mean(varsv)
	4044	permean = np.float(vs[0].split('@')[1])
	4045	minv = np.min(varsv)*permean
	4046	maxv = np.max(varsv)*permean
	4047	minextrm = np.min([np.abs(meanv-minv), np.abs(maxv-meanv)])
	4048	vsend[0] = meanv-minextrm
	4049	vsend[1] = meanv+minextrm
	4050	elif vs[0][0:13] == 'Saroundminmax':
	4051	permean = np.float(vs[0].split('@')[1])
	4052	minv = np.min(varsv)*permean
	4053	maxv = np.max(varsv)*permean
	4054	vsend[0] = minv
	4055	vsend[1] = maxv
	4056	elif vs[0][0:17] == 'Saroundpercentile':
	4057	medianv = np.median(varsv)
	4058	valper = np.float(vs[0].split('@')[1])
	4059	minv = np.percentile(varsv, valper)
	4060	maxv = np.percentile(varsv, 100.-valper)
	4061	minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
	4062	vsend[0] = medianv-minextrm
	4063	vsend[1] = medianv+minextrm
	4064	elif vs[0][0:5] == 'Smean':
	4065	meanv = np.mean(varsv)
	4066	permean = np.float(vs[0].split('@')[1])
	4067	minv = np.min(varsv)*permean
	4068	maxv = np.max(varsv)*permean
	4069	minextrm = np.min([np.abs(meanv-minv), np.abs(maxv-meanv)])
	4070	vsend[0] = -minextrm
	4071	vsend[1] = minextrm
	4072	elif vs[0][0:7] == 'Smedian':
	4073	medianv = np.median(varsv)
	4074	permedian = np.float(vs[0].split('@')[1])
	4075	minv = np.min(varsv)*permedian
	4076	maxv = np.max(varsv)*permedian
	4077	minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
	4078	vsend[0] = -minextrm
	4079	vsend[1] = minextrm
	4080	elif vs[0][0:11] == 'Spercentile':
	4081	medianv = np.median(varsv)
	4082	valper = np.float(vs[0].split('@')[1])
	4083	minv = np.percentile(varsv, valper)
	4084	maxv = np.percentile(varsv, 100.-valper)
	4085	minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
	4086	vsend[0] = -minextrm
	4087	vsend[1] = minextrm
	4088	else:
	4089	print errormsg
	4090	print ' ' + fname + ": range '" + vs[0] + "' not ready!!!"
	4091	quit(-1)
	4092	print ' ' + fname + ': modified shadow min,max:',vsend
	4093	else:
	4094	vsend[0] = vs[0]
	4095
	4096	if type(vs[0]) != type(np.float(1.)):
	4097	if vs[1] == 'range':
	4098	vsend[1] = np.max(varsv)
	4099	else:
	4100	vsend[1] = vs[1]
	4101
	4102	plt.pcolormesh(x, y, varsv, cmap=plt.get_cmap(colorbar), vmin=vsend[0], vmax=vsend[1])
	4103	cbar = plt.colorbar()
	4104
	4105	# print 'Lluis reva0:',reva0,'x min,max:',x.min(),x.max(),' y min,max:',y.min(),y.max()
	4106
	4107	# set the limits of the plot to the limits of the data
	4108	if reva0 == 'flip':
	4109	if reva.split('@')[1] == 'x':
	4110	plt.axis([x.max(), x.min(), y.min(), y.max()])
	4111	elif reva.split('@')[1] == 'y':
	4112	plt.axis([x.min(), x.max(), y.max(), y.min()])
	4113	else:
	4114	plt.axis([x.max(), x.min(), y.max(), y.min()])
	4115	else:
	4116	plt.axis([x.min(), x.max(), y.min(), y.max()])
	4117
	4118	if searchInlist(revas, 'transpose'):
	4119	plt.xticks(typos, tylabels)
	4120	plt.yticks(txpos, txlabels)
	4121	plt.xlabel(plylabel)
	4122	plt.ylabel(plxlabel)
	4123	else:
	4124	plt.xticks(txpos, txlabels)
	4125	plt.yticks(typos, tylabels)
	4126	plt.xlabel(plxlabel)
	4127	plt.ylabel(plylabel)
	4128
	4129	# units labels
	4130	cbar.set_label(vnames.replace('_','\_') + ' (' + units_lunits(uts) + ')')
	4131
	4132	figname = '2Dfields_shadow_time'
	4133	graphtit = vtit.replace('_','\_').replace('&','\&')
	4134
	4135	plt.title(graphtit)
	4136
	4137	output_kind(kfig, figname, ifclose)
	4138
	4139	return
	4140
	4141	def plot_2D_shadow_contour(varsv,varcv,vnames,dimxv,dimyv,dimxu,dimyu,dimn, \
	4142	colorbar,ckind,clabfmt,vs,vc,uts,vtit,kfig,reva,mapv):
	4143	""" Adding labels and other staff to the graph
	4144	varsv= 2D values to plot with shading
	4145	varcv= 2D values to plot with contours
	4146	vnames= variable names for the figure
	4147	dim[x/y]v = values at the axes of x and y
	4148	dim[x/y]u = units at the axes of x and y
	4149	dimn= dimension names to plot
	4150	colorbar= name of the color bar to use
	4151	ckind= contour kind
	4152	'cmap': as it gets from colorbar
	4153	'fixc,[colname]': fixed color [colname], all stright lines
	4154	'fixsigc,[colname]': fixed color [colname], >0 stright, <0 dashed line
	4155	clabfmt= format of the labels in the contour plot (None, no labels)
	4156	vs= minmum and maximum values to plot in shadow
	4157	vc= vector with the levels for the contour
	4158	uts= units of the variable [u-shadow, u-contour]
	4159	vtit= title of the variable
	4160	kfig= kind of figure (jpg, pdf, png)
	4161	reva=
	4162	* 'transpose': reverse the axes (x-->y, y-->x)
	4163	* 'flip'@[x/y]: flip the axis x or y
	4164	mapv= map characteristics: [proj],[res]
	4165	see full documentation: http://matplotlib.org/basemap/
	4166	[proj]: projection
	4167	* 'cyl', cilindric
	4168	* 'lcc', lamvbert conformal
	4169	[res]: resolution:
	4170	* 'c', crude
	4171	* 'l', low
	4172	* 'i', intermediate
	4173	* 'h', high
	4174	* 'f', full
	4175	"""
	4176	## import matplotlib as mpl
	4177	## mpl.use('Agg')
	4178	## import matplotlib.pyplot as plt
	4179	fname = 'plot_2D_shadow_contour'
	4180
	4181	if varsv == 'h':
	4182	print fname + '_____________________________________________________________'
	4183	print plot_2D_shadow_contour.__doc__
	4184	quit()
	4185
	4186	if reva[0:4] == 'flip':
	4187	reva0 = 'flip'
	4188	if len(reva.split('@')) != 2:
	4189	print errormsg
	4190	print ' ' + fname + ': flip is given', reva, 'but not axis!'
	4191	quit(-1)
	4192	else:
	4193	reva0 = reva
	4194
	4195	if reva0 == 'transpose':
	4196	print ' reversing the axes of the figure (x-->y, y-->x)!!'
	4197	varsv = np.transpose(varsv)
	4198	varcv = np.transpose(varcv)
	4199	dxv = dimyv
	4200	dyv = dimxv
	4201	dimxv = dxv
	4202	dimyv = dyv
	4203
	4204	if not mapv is None:
	4205	if len(dimxv[:].shape) == 3:
	4206	lon0 = dimxv[0,]
	4207	lat0 = dimyv[0,]
	4208	elif len(dimxv[:].shape) == 2:
	4209	lon0 = dimxv[:]
	4210	lat0 = dimyv[:]
	4211	elif len(dimxv[:].shape) == 1:
	4212	lon00 = dimxv[:]
	4213	lat00 = dimyv[:]
	4214	lon0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
	4215	lat0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
	4216
	4217	for iy in range(len(lat00)):
	4218	lon0[iy,:] = lon00
	4219	for ix in range(len(lon00)):
	4220	lat0[:,ix] = lat00
	4221
	4222	map_proj=mapv.split(',')[0]
	4223	map_res=mapv.split(',')[1]
	4224
	4225	dx = lon0.shape[1]
	4226	dy = lon0.shape[0]
	4227
	4228	nlon = lon0[0,0]
	4229	xlon = lon0[dy-1,dx-1]
	4230	nlat = lat0[0,0]
	4231	xlat = lat0[dy-1,dx-1]
	4232
	4233	# Thats too much! :)
	4234	# if lonlatLims is not None:
	4235	# print ' ' + fname + ': cutting the domain to plot !!!!'
	4236	# plt.xlim(lonlatLims[0], lonlatLims[2])
	4237	# plt.ylim(lonlatLims[1], lonlatLims[3])
	4238	# print ' limits: W-E', lonlatLims[0], lonlatLims[2]
	4239	# print ' limits: N-S', lonlatLims[1], lonlatLims[3]
	4240
	4241	# if map_proj == 'cyl':
	4242	# nlon = lonlatLims[0]
	4243	# nlat = lonlatLims[1]
	4244	# xlon = lonlatLims[2]
	4245	# xlat = lonlatLims[3]
	4246	# elif map_proj == 'lcc':
	4247	# lon2 = (lonlatLims[0] + lonlatLims[2])/2.
	4248	# lat2 = (lonlatLims[1] + lonlatLims[3])/2.
	4249	# nlon = lonlatLims[0]
	4250	# xlon = lonlatLims[2]
	4251	# nlat = lonlatLims[1]
	4252	# xlat = lonlatLims[3]
	4253
	4254	lon2 = lon0[dy/2,dx/2]
	4255	lat2 = lat0[dy/2,dx/2]
	4256
	4257	print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:', \
	4258	xlon, ',', xlat
	4259
	4260	if map_proj == 'cyl':
	4261	m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat, \
	4262	urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	4263	elif map_proj == 'lcc':
	4264	m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
	4265	llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	4266
	4267	if len(dimxv.shape) == 1:
	4268	lons, lats = np.meshgrid(dimxv, dimyv)
	4269	else:
	4270	if len(dimxv.shape) == 3:
	4271	lons = dimxv[0,:,:]
	4272	lats = dimyv[0,:,:]
	4273	else:
	4274	lons = dimxv[:]
	4275	lats = dimyv[:]
	4276
	4277	x,y = m(lons,lats)
	4278
	4279	else:
	4280	if len(dimxv.shape) == 2:
	4281	x = dimxv
	4282	else:
	4283	if len(dimyv.shape) == 1:
	4284	x = np.zeros((len(dimyv),len(dimxv)), dtype=np.float)
	4285	for j in range(len(dimyv)):
	4286	x[j,:] = dimxv
	4287	else:
	4288	x = np.zeros((dimyv.shape), dtype=np.float)
	4289	if x.shape[0] == dimxv.shape[0]:
	4290	for j in range(x.shape[1]):
	4291	x[:,j] = dimxv
	4292	else:
	4293	for j in range(x.shape[0]):
	4294	x[j,:] = dimxv
	4295
	4296	if len(dimyv.shape) == 2:
	4297	y = dimyv
	4298	else:
	4299	if len(dimxv.shape) == 1:
	4300	y = np.zeros((len(dimyv),len(dimxv)), dtype=np.float)
	4301	for i in range(len(dimxv)):
	4302	y[:,i] = dimyv
	4303	else:
	4304	y = np.zeros((dimxv.shape), dtype=np.float)
[379]	4305
[192]	4306	if y.shape[0] == dimyv.shape[0]:
	4307	for i in range(y.shape[1]):
[376]	4308	y[i,:] = dimyv
[192]	4309	else:
	4310	for i in range(y.shape[0]):
[378]	4311	y[i,:] = dimyv
[192]	4312
[385]	4313	plt.rc('text', usetex=True)
[192]	4314
	4315	plt.pcolormesh(x, y, varsv, cmap=plt.get_cmap(colorbar), vmin=vs[0], vmax=vs[1])
	4316	cbar = plt.colorbar()
	4317
	4318	# contour
	4319	##
	4320	contkind = ckind.split(',')[0]
	4321	if contkind == 'cmap':
	4322	cplot = plt.contour(x, y, varcv, levels=vc)
	4323	elif contkind == 'fixc':
	4324	plt.rcParams['contour.negative_linestyle'] = 'solid'
	4325	coln = ckind.split(',')[1]
	4326	cplot = plt.contour(x, y, varcv, levels=vc, colors=coln)
	4327	elif contkind == 'fixsigc':
	4328	coln = ckind.split(',')[1]
	4329	cplot = plt.contour(x, y, varcv, levels=vc, colors=coln)
	4330	else:
	4331	print errormsg
	4332	print ' ' + fname + ': contour kind "' + contkind + '" not defined !!!!!'
	4333	quit(-1)
	4334
	4335	if clabfmt is not None:
	4336	plt.clabel(cplot, fmt=clabfmt)
	4337	mincntS = format(vc[0], clabfmt[1:len(clabfmt)])
	4338	maxcntS = format(vc[len(vc)-1], clabfmt[1:len(clabfmt)])
	4339	else:
	4340	mincntS = '{:g}'.format(vc[0])
	4341	maxcntS = '{:g}'.format(vc[len(vc)-1])
	4342
	4343	if not mapv is None:
	4344	m.drawcoastlines()
	4345
	4346	meridians = pretty_int(nlon,xlon,5)
	4347	m.drawmeridians(meridians,labels=[True,False,False,True])
	4348	parallels = pretty_int(nlat,xlat,5)
	4349	m.drawparallels(parallels,labels=[False,True,True,False])
	4350
	4351	plt.xlabel('W-E')
	4352	plt.ylabel('S-N')
	4353	else:
	4354	plt.xlabel(variables_values(dimn[1])[0] + ' (' + units_lunits(dimxu) + ')')
	4355	plt.ylabel(variables_values(dimn[0])[0] + ' (' + units_lunits(dimyu) + ')')
	4356
[544]	4357	txpos = pretty_int(x.min(),x.max(),5)
	4358	typos = pretty_int(y.min(),y.max(),5)
	4359	txlabels = list(txpos)
	4360	for i in range(len(txlabels)): txlabels[i] = '{:.1f}'.format(txlabels[i])
	4361	tylabels = list(typos)
	4362	for i in range(len(tylabels)): tylabels[i] = '{:.1f}'.format(tylabels[i])
	4363	plt.xticks(txpos, txlabels)
	4364	plt.yticks(typos, tylabels)
[192]	4365
	4366	# set the limits of the plot to the limits of the data
	4367	if reva0 == 'flip':
	4368	if reva.split('@')[1] == 'x':
	4369	plt.axis([x.max(), x.min(), y.min(), y.max()])
	4370	else:
	4371	plt.axis([x.min(), x.max(), y.max(), y.min()])
	4372	else:
	4373	plt.axis([x.min(), x.max(), y.min(), y.max()])
	4374
	4375
	4376	# units labels
	4377	cbar.set_label(vnames[0].replace('_','\_') + ' (' + units_lunits(uts[0]) + ')')
	4378	plt.annotate(vnames[1].replace('_','\_') +' (' + units_lunits(uts[1]) + ') [' + \
	4379	mincntS + ', ' + maxcntS + ']', xy=(0.55,0.04), xycoords='figure fraction', \
	4380	color=coln)
	4381
	4382	figname = '2Dfields_shadow-contour'
	4383	graphtit = vtit.replace('_','\_').replace('&','\&')
	4384
	4385	plt.title(graphtit)
	4386
	4387	output_kind(kfig, figname, True)
	4388
	4389	return
	4390
	4391	#Nvals=50
	4392	#vals1 = np.zeros((Nvals,Nvals), dtype= np.float)
	4393	#vals2 = np.zeros((Nvals,Nvals), dtype= np.float)
	4394	#for j in range(Nvals):
	4395	# for i in range(Nvals):
	4396	# vals1[j,i]=np.sqrt((j-Nvals/2)2. + (i-Nvals/2)2.)
	4397	# vals2[j,i]=np.sqrt((j-Nvals/2)2. + (i-Nvals/2)2.) - Nvals/2
	4398
	4399	#prettylev=pretty_int(-Nvals/2,Nvals/2,10)
	4400
	4401	#plot_2D_shadow_contour(vals1, vals2, ['var1', 'var2'], np.arange(50)*1., \
	4402	# np.arange(50)*1., ['x-axis','y-axis'], 'rainbow', 'fixc,b', "%.2f", [0, Nvals], \
	4403	# prettylev, ['$ms^{-1}$','$kJm^{-1}s^{-1}$'], 'test var1 & var2', 'pdf', False)
	4404
	4405	def plot_2D_shadow_contour_time(varsv,varcv,vnames,valv,timv,timpos,timlab,valu, \
	4406	timeu,axist,dimn,colorbar,ckind,clabfmt,vs,vc,uts,vtit,kfig,reva,mapv):
	4407	""" Adding labels and other staff to the graph
	4408	varsv= 2D values to plot with shading
	4409	varcv= 2D values to plot with contours
	4410	vnames= variable names for the figure
	4411	valv = values at the axes which is not time
	4412	timv = values for the axis time
	4413	timpos = positions at the axis time
	4414	timlab = labes at the axis time
	4415	valu = units at the axes which is not time
	4416	timeu = units at the axes which is not time
	4417	axist = which is the axis time
	4418	dimn= dimension names to plot
	4419	colorbar= name of the color bar to use
	4420	ckind= contour kind
	4421	'cmap': as it gets from colorbar
	4422	'fixc,[colname]': fixed color [colname], all stright lines
	4423	'fixsigc,[colname]': fixed color [colname], >0 stright, <0 dashed line
	4424	clabfmt= format of the labels in the contour plot (None, no labels)
	4425	vs= minmum and maximum values to plot in shadow
	4426	vc= vector with the levels for the contour
	4427	uts= units of the variable [u-shadow, u-contour]
	4428	vtit= title of the variable
	4429	kfig= kind of figure (jpg, pdf, png)
	4430	reva=
	4431	* 'transpose': reverse the axes (x-->y, y-->x)
	4432	* 'flip'@[x/y]: flip the axis x or y
	4433	mapv= map characteristics: [proj],[res]
	4434	see full documentation: http://matplotlib.org/basemap/
	4435	[proj]: projection
	4436	* 'cyl', cilindric
	4437	* 'lcc', lamvbert conformal
	4438	[res]: resolution:
	4439	* 'c', crude
	4440	* 'l', low
	4441	* 'i', intermediate
	4442	* 'h', high
	4443	* 'f', full
	4444	"""
	4445	## import matplotlib as mpl
	4446	## mpl.use('Agg')
	4447	## import matplotlib.pyplot as plt
	4448	fname = 'plot_2D_shadow_contour'
	4449
	4450	if varsv == 'h':
	4451	print fname + '_____________________________________________________________'
	4452	print plot_2D_shadow_contour.__doc__
	4453	quit()
	4454
	4455	if axist == 'x':
	4456	dimxv = timv.copy()
	4457	dimyv = valv.copy()
	4458	else:
	4459	dimxv = valv.copy()
	4460	dimyv = timv.copy()
	4461
	4462	if reva[0:4] == 'flip':
	4463	reva0 = 'flip'
	4464	if len(reva.split('@')) != 2:
	4465	print errormsg
	4466	print ' ' + fname + ': flip is given', reva, 'but not axis!'
	4467	quit(-1)
	4468	else:
	4469	reva0 = reva
	4470
	4471	if reva0 == 'transpose':
	4472	if axist == 'x':
	4473	axist = 'y'
	4474	else:
	4475	axist = 'x'
	4476
	4477	if not mapv is None:
	4478	if len(dimxv[:].shape) == 3:
	4479	lon0 = dimxv[0,]
	4480	lat0 = dimyv[0,]
	4481	elif len(dimxv[:].shape) == 2:
	4482	lon0 = dimxv[:]
	4483	lat0 = dimyv[:]
	4484	elif len(dimxv[:].shape) == 1:
	4485	lon00 = dimxv[:]
	4486	lat00 = dimyv[:]
	4487	lon0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
	4488	lat0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
	4489
	4490	for iy in range(len(lat00)):
	4491	lon0[iy,:] = lon00
	4492	for ix in range(len(lon00)):
	4493	lat0[:,ix] = lat00
	4494	if reva0 == 'transpose':
	4495	print ' reversing the axes of the figure (x-->y, y-->x)!!'
	4496	varsv = np.transpose(varsv)
	4497	varcv = np.transpose(varcv)
	4498	lon0 = np.transpose(lon0)
	4499	lat0 = np.transpose(lat0)
	4500
	4501	map_proj=mapv.split(',')[0]
	4502	map_res=mapv.split(',')[1]
	4503
	4504	dx = lon0.shape[1]
	4505	dy = lon0.shape[0]
	4506
	4507	nlon = lon0[0,0]
	4508	xlon = lon0[dy-1,dx-1]
	4509	nlat = lat0[0,0]
	4510	xlat = lat0[dy-1,dx-1]
	4511
	4512	# Thats too much! :)
	4513	# if lonlatLims is not None:
	4514	# print ' ' + fname + ': cutting the domain to plot !!!!'
	4515	# plt.xlim(lonlatLims[0], lonlatLims[2])
	4516	# plt.ylim(lonlatLims[1], lonlatLims[3])
	4517	# print ' limits: W-E', lonlatLims[0], lonlatLims[2]
	4518	# print ' limits: N-S', lonlatLims[1], lonlatLims[3]
	4519
	4520	# if map_proj == 'cyl':
	4521	# nlon = lonlatLims[0]
	4522	# nlat = lonlatLims[1]
	4523	# xlon = lonlatLims[2]
	4524	# xlat = lonlatLims[3]
	4525	# elif map_proj == 'lcc':
	4526	# lon2 = (lonlatLims[0] + lonlatLims[2])/2.
	4527	# lat2 = (lonlatLims[1] + lonlatLims[3])/2.
	4528	# nlon = lonlatLims[0]
	4529	# xlon = lonlatLims[2]
	4530	# nlat = lonlatLims[1]
	4531	# xlat = lonlatLims[3]
	4532
	4533	lon2 = lon0[dy/2,dx/2]
	4534	lat2 = lat0[dy/2,dx/2]
	4535
	4536	print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:', \
	4537	xlon, ',', xlat
	4538
	4539	if map_proj == 'cyl':
	4540	m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat, \
	4541	urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	4542	elif map_proj == 'lcc':
	4543	m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
	4544	llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	4545
	4546	if len(dimxv.shape) == 1:
	4547	lons, lats = np.meshgrid(dimxv, dimyv)
	4548	else:
	4549	if len(dimxv.shape) == 3:
	4550	lons = dimxv[0,:,:]
	4551	lats = dimyv[0,:,:]
	4552	else:
	4553	lons = dimxv[:]
	4554	lats = dimyv[:]
	4555
	4556	x,y = m(lons,lats)
	4557
	4558	else:
	4559	if reva0 == 'transpose':
	4560	print ' reversing the axes of the figure (x-->y, y-->x)!!'
	4561	varsv = np.transpose(varsv)
	4562	varcv = np.transpose(varcv)
	4563	dimn0 = []
	4564	dimn0.append(dimn[1] + '')
	4565	dimn0.append(dimn[0] + '')
	4566	dimn = dimn0
	4567	if len(dimyv.shape) == 2:
	4568	x = np.transpose(dimyv)
	4569	else:
	4570	if len(dimxv.shape) == 2:
	4571	ddx = len(dimyv)
	4572	ddy = dimxv.shape[1]
	4573	else:
	4574	ddx = len(dimyv)
	4575	ddy = len(dimxv)
	4576
	4577	x = np.zeros((ddy,ddx), dtype=np.float)
	4578	for j in range(ddy):
	4579	x[j,:] = dimyv
	4580
	4581	if len(dimxv.shape) == 2:
	4582	y = np.transpose(dimxv)
	4583	else:
	4584	if len(dimyv.shape) == 2:
	4585	ddx = dimyv.shape[0]
	4586	ddy = len(dimxv)
	4587	else:
	4588	ddx = len(dimyv)
	4589	ddy = len(dimxv)
	4590
	4591	y = np.zeros((ddy,ddx), dtype=np.float)
	4592	for i in range(ddx):
	4593	y[:,i] = dimxv
	4594	else:
	4595	if len(dimxv.shape) == 2:
	4596	x = dimxv
	4597	else:
	4598	if len(dimyv.shape) == 1:
	4599	x = np.zeros((len(dimyv),len(dimxv)), dtype=np.float)
	4600	for j in range(len(dimyv)):
	4601	x[j,:] = dimxv
	4602	else:
	4603	x = np.zeros((dimyv.shape), dtype=np.float)
	4604	if x.shape[0] == dimxv.shape[0]:
	4605	for j in range(x.shape[1]):
	4606	x[:,j] = dimxv
	4607	else:
	4608	for j in range(x.shape[0]):
	4609	x[j,:] = dimxv
	4610
	4611	if len(dimyv.shape) == 2:
	4612	y = dimyv
	4613	else:
	4614	if len(dimxv.shape) == 1:
	4615	y = np.zeros((len(dimyv),len(dimxv)), dtype=np.float)
	4616	for i in range(len(dimxv)):
	4617	y[:,i] = dimyv
	4618	else:
	4619	y = np.zeros((dimxv.shape), dtype=np.float)
	4620	if y.shape[0] == dimyv.shape[0]:
	4621	for i in range(y.shape[1]):
	4622	y[:,i] = dimyv
	4623	else:
	4624	for i in range(y.shape[0]):
	4625	y[i,:] = dimyv
	4626
	4627	dx=varsv.shape[1]
	4628	dy=varsv.shape[0]
	4629
	4630	plt.rc('text', usetex=True)
	4631
	4632	if axist == 'x':
	4633	valpos = pretty_int(y.min(),y.max(),10)
	4634	vallabels = list(valpos)
	4635	for i in range(len(vallabels)): vallabels[i] = str(vallabels[i])
	4636	else:
	4637	valpos = pretty_int(x.min(),x.max(),10)
	4638	vallabels = list(valpos)
	4639	for i in range(len(vallabels)): vallabels[i] = str(vallabels[i])
	4640
	4641	if reva0 == 'flip':
	4642	if reva.split('@')[1] == 'x':
	4643	varsv[:,0:dx-1] = varsv[:,dx-1:0:-1]
	4644	varcv[:,0:dx-1] = varcv[:,dx-1:0:-1]
	4645	plt.xticks(valpos, vallabels[::-1])
	4646	else:
	4647	varsv[0:dy-1,:] = varsv[dy-1:0:-1,:]
	4648	varcv[0:dy-1,:] = varcv[dy-1:0:-1,:]
	4649	plt.yticks(valpos, vallabels[::-1])
	4650	else:
	4651	plt.xlim(0,dx-1)
	4652	plt.ylim(0,dy-1)
	4653
	4654	plt.pcolormesh(x, y, varsv, cmap=plt.get_cmap(colorbar), vmin=vs[0], vmax=vs[1])
	4655	cbar = plt.colorbar()
	4656
	4657	# contour
	4658	##
	4659	contkind = ckind.split(',')[0]
	4660	if contkind == 'cmap':
	4661	cplot = plt.contour(x, y, varcv, levels=vc)
	4662	elif contkind == 'fixc':
	4663	plt.rcParams['contour.negative_linestyle'] = 'solid'
	4664	coln = ckind.split(',')[1]
	4665	cplot = plt.contour(x, y, varcv, levels=vc, colors=coln)
	4666	elif contkind == 'fixsigc':
	4667	coln = ckind.split(',')[1]
	4668	cplot = plt.contour(x, y, varcv, levels=vc, colors=coln)
	4669	else:
	4670	print errormsg
	4671	print ' ' + fname + ': contour kind "' + contkind + '" not defined !!!!!'
	4672	quit(-1)
	4673
	4674	if clabfmt is not None:
	4675	plt.clabel(cplot, fmt=clabfmt)
	4676	mincntS = format(vc[0], clabfmt[1:len(clabfmt)])
	4677	maxcntS = format(vc[len(vc)-1], clabfmt[1:len(clabfmt)])
	4678	else:
	4679	mincntS = '{:g}'.format(vc[0])
	4680	maxcntS = '{:g}'.format(vc[len(vc)-1])
	4681
	4682	if not mapv is None:
	4683	m.drawcoastlines()
	4684
	4685	meridians = pretty_int(nlon,xlon,5)
	4686	m.drawmeridians(meridians,labels=[True,False,False,True])
	4687	parallels = pretty_int(nlat,xlat,5)
	4688	m.drawparallels(parallels,labels=[False,True,True,False])
	4689
	4690	plt.xlabel('W-E')
	4691	plt.ylabel('S-N')
	4692	else:
	4693	if axist == 'x':
	4694	plt.xlabel(timeu)
	4695	plt.xticks(timpos, timlab)
	4696	plt.ylabel(variables_values(dimn[0])[0] + ' (' + units_lunits(valu) + ')')
	4697	plt.yticks(valpos, vallabels)
	4698	else:
	4699	plt.xlabel(variables_values(dimn[1])[0] + ' (' + units_lunits(valu) + ')')
	4700	plt.xticks(valpos, vallabels)
	4701	plt.ylabel(timeu)
	4702	plt.yticks(timpos, timlab)
	4703
	4704	# set the limits of the plot to the limits of the data
	4705	plt.axis([x.min(), x.max(), y.min(), y.max()])
	4706
	4707	# units labels
	4708	cbar.set_label(vnames[0].replace('_','\_') + ' (' + units_lunits(uts[0]) + ')')
	4709	plt.annotate(vnames[1].replace('_','\_') +' (' + units_lunits(uts[1]) + ') [' + \
	4710	mincntS + ', ' + maxcntS + ']', xy=(0.55,0.04), xycoords='figure fraction', \
	4711	color=coln)
	4712
	4713	figname = '2Dfields_shadow-contour'
	4714	graphtit = vtit.replace('_','\_').replace('&','\&')
	4715
	4716	plt.title(graphtit)
	4717
	4718	output_kind(kfig, figname, True)
	4719
	4720	return
	4721
	4722	def dxdy_lonlat(dxv,dyv,ddx,ddy):
	4723	""" Function to provide lon/lat 2D lilke-matrices from any sort of dx,dy values
	4724	dxdy_lonlat(dxv,dyv,Lv,lv)
	4725	dx: values for the x
	4726	dy: values for the y
	4727	ddx: ',' list of which dimensions to use from values along x
	4728	ddy: ',' list of which dimensions to use from values along y
	4729	"""
	4730
	4731	fname = 'dxdy_lonlat'
	4732
	4733	if ddx.find(',') > -1:
	4734	dxk = 2
	4735	ddxv = ddx.split(',')
	4736	ddxy = int(ddxv[0])
	4737	ddxx = int(ddxv[1])
	4738	else:
	4739	dxk = 1
	4740	ddxy = int(ddx)
	4741	ddxx = int(ddx)
	4742
	4743	if ddy.find(',') > -1:
	4744	dyk = 2
	4745	ddyv = ddy.split(',')
	4746	ddyy = int(ddyv[0])
	4747	ddyx = int(ddyv[1])
	4748	else:
	4749	dyk = 1
	4750	ddyy = int(ddy)
	4751	ddyx = int(ddy)
	4752
	4753	ddxxv = dxv.shape[ddxx]
	4754	ddxyv = dxv.shape[ddxy]
	4755	ddyxv = dyv.shape[ddyx]
	4756	ddyyv = dyv.shape[ddyy]
	4757
	4758	slicex = []
	4759	if len(dxv.shape) > 1:
	4760	for idim in range(len(dxv.shape)):
	4761	if idim == ddxx or idim == ddxy:
	4762	slicex.append(slice(0,dxv.shape[idim]))
	4763	else:
	4764	slicex.append(0)
	4765	else:
	4766	slicex.append(slice(0,len(dxv)))
	4767
	4768	slicey = []
	4769	if len(dyv.shape) > 1:
	4770	for idim in range(len(dyv.shape)):
	4771	if idim == ddyx or idim == ddyy:
	4772	slicey.append(slice(0,dyv.shape[idim]))
	4773	else:
	4774	slicey.append(0)
	4775	else:
	4776	slicey.append(slice(0,len(dyv)))
	4777
	4778	if dxk == 2 and dyk == 2:
	4779	if ddxxv != ddyxv:
	4780	print errormsg
	4781	print ' ' + fname + ': wrong dx dimensions! ddxx=',ddxxv,'ddyx=',ddyxv
	4782	print ' choose another for x:',dxv.shape,'or y:',dyv.shape
	4783	quit(-1)
	4784	if ddxyv != ddyyv:
	4785	print errormsg
	4786	print ' ' + fname + ': wrong dy dimensions! ddxy=',ddxyv,'ddyy=',ddyv
	4787	print ' choose another for x:',dxv.shape,'or y:',dyv.shape
	4788	quit(-1)
	4789	dx = ddxxv
	4790	dy = ddxyv
	4791
	4792	print ' ' + fname + ': final dimension 2D lon/lat-like matrices:',dy,',',dx
	4793	lonv = np.zeros((dy,dx), dtype=np.float)
	4794	latv = np.zeros((dy,dx), dtype=np.float)
	4795
	4796
	4797	lonv = dxv[tuple(slicex)]
	4798	latv = dyv[tuple(slicey)]
	4799
	4800	elif dxk == 2 and dyk == 1:
	4801	if not ddxxv == ddyxv and not ddxyv == ddyyv:
	4802	print errormsg
	4803	print ' ' + fname + ': wrong dimensions! ddxx=',ddxxv,'ddyx=',ddyxv, \
	4804	'ddyx=',ddyxv,'ddyy=',ddyyv
	4805	print ' choose another for x:',dxv.shape,'or y:',dyv.shape
	4806	quit(-1)
	4807	dx = ddxvv
	4808	dy = ddxyv
	4809
	4810	print ' ' + fname + ': final dimension 2D lon/lat-like matrices:',dy,',',dx
	4811	lonv = np.zeros((dy,dx), dtype=np.float)
	4812	latv = np.zeros((dy,dx), dtype=np.float)
	4813	lonv = dxv[tuple(slicex)]
	4814
	4815	if ddxxv == ddyxv:
	4816	for iy in range(dy):
	4817	latv[iy,:] = dyv[tuple(slicey)]
	4818	else:
	4819	for ix in range(dx):
	4820	latv[:,ix] = dyv[tuple(slicey)]
	4821
	4822	elif dxk == 1 and dyk == 2:
	4823	if not ddxxv == ddyxv and not ddxyv == ddyyv:
	4824	print errormsg
	4825	print ' ' + fname + ': wrong dimensions! ddxx=',ddxxv,'ddyx=',ddyxv, \
	4826	'ddyx=',ddyxv,'ddyy=',ddyyv
	4827	print ' choose another for x:',dxv.shape,'or y:',dyv.shape
	4828	quit(-1)
	4829	dx = ddyxv
	4830	dy = ddyyv
	4831
	4832	print ' ' + fname + ': final dimension 2D lon/lat-like matrices:',dy,',',dx
	4833	lonv = np.zeros((dy,dx), dtype=np.float)
	4834	latv = np.zeros((dy,dx), dtype=np.float)
	4835
	4836	latv = dyv[tuple(slicey)]
	4837
	4838	if ddyxv == ddxxv:
	4839	for iy in range(dy):
	4840	lonv[iy,:] = dxv[tuple(slicex)]
	4841	else:
	4842	for ix in range(dx):
	4843	lonv[:,ix] = dxv[tuple(slicex)]
	4844
	4845
	4846	elif dxk == 1 and dyk == 1:
	4847	dx = ddxxv
	4848	dy = ddyyv
	4849
	4850	# print 'dx:',dx,'dy:',dy
	4851
	4852	lonv = np.zeros((dy,dx), dtype=np.float)
	4853	latv = np.zeros((dy,dx), dtype=np.float)
	4854
	4855	for iy in range(dy):
	4856	lonv[iy,:] = dxv[tuple(slicex)]
	4857	for ix in range(dx):
	4858	latv[:,ix] = dyv[tuple(slicey)]
	4859
	4860	return lonv,latv
	4861
[476]	4862	def dxdy_lonlatDIMS(dxv,dyv,dnx,dny,dd):
	4863	""" Function to provide lon/lat 2D lilke-matrices from any sort of dx,dy values for a given
	4864	list of values
	4865	dxdy_lonlat(dxv,dyv,Lv,lv)
	4866	dxv: values for the x
	4867	dyv: values for the y
	4868	dnx: mnames of the dimensions for values on x
	4869	dny: mnames of the dimensions for values on y
	4870	dd: list of [dimname]\|[val] for the dimensions use
	4871	[dimname]: name of the dimension
	4872	[val]: value (-1 for all the range)
	4873	"""
	4874	fname = 'dxdy_lonlatDIMS'
	4875
	4876	slicex = []
	4877	ipos=0
	4878	for dn in dnx:
	4879	for idd in range(len(dd)):
	4880	dname = dd[idd].split('\|')[0]
[652]	4881	dvalue = dd[idd].split('\|')[1]
[476]	4882	if dn == dname:
[652]	4883	if dvalue.find('@') != -1:
	4884	slicex.append(slice(int(dvalue.split('@')[0]), \
	4885	int(dvalue.split('@')[1])))
[476]	4886	else:
[652]	4887	if int(dvalue) == -1:
	4888	slicex.append(slice(0,dxv.shape[ipos]))
	4889	elif int(dvalue) == -9:
	4890	slicex.append(dxv.shape[ipos]-1)
	4891	else:
	4892	slicex.append(int(dvalue))
	4893	break
[476]	4894	ipos = ipos + 1
	4895
	4896	slicey = []
	4897	ipos=0
	4898	for dn in dny:
	4899	for idd in range(len(dd)):
	4900	dname = dd[idd].split('\|')[0]
[652]	4901	dvalue = dd[idd].split('\|')[1]
[476]	4902	if dn == dname:
[652]	4903	if dvalue.find('@') != -1:
	4904	slicey.append(slice(int(dvalue.split('@')[0]), \
	4905	int(dvalue.split('@')[1])))
[476]	4906	else:
[652]	4907	if int(dvalue) == -1:
	4908	slicey.append(slice(0,dyv.shape[ipos]))
	4909	elif int(dvalue) == -9:
	4910	slicey.append(dyv.shape[ipos]-1)
	4911	else:
	4912	slicey.append(int(dvalue))
	4913	break
[476]	4914	ipos = ipos + 1
	4915
	4916	lonv = dxv[tuple(slicex)]
	4917	latv = dyv[tuple(slicey)]
	4918
	4919	if len(lonv.shape) != len(latv.shape):
	4920	print ' ' + fname + ': dimension size on x:', len(lonv.shape), 'and on y:', \
	4921	len(latv.shape),'do not coincide!!'
	4922	quit(-1)
	4923
	4924	return lonv,latv
	4925
[192]	4926	def plot_2D_shadow_line(varsv,varlv,vnames,vnamel,dimxv,dimyv,dimxu,dimyu,dimn, \
	4927	colorbar,colln,vs,uts,utl,vtit,kfig,reva,mapv,ifclose):
	4928	""" Plotting a 2D field with shadows and another one with a line
	4929	varsv= 2D values to plot with shading
	4930	varlv= 1D values to plot with line
	4931	vnames= variable names for the shadow variable in the figure
	4932	vnamel= variable names for the line varibale in the figure
	4933	dim[x/y]v = values at the axes of x and y
	4934	dim[x/y]u = units at the axes of x and y
	4935	dimn= dimension names to plot
	4936	colorbar= name of the color bar to use
	4937	colln= color for the line
	4938	vs= minmum and maximum values to plot in shadow
	4939	uts= units of the variable to shadow
	4940	utl= units of the variable to line
	4941	vtit= title of the variable
	4942	kfig= kind of figure (jpg, pdf, png)
	4943	reva=
	4944	* 'transpose': reverse the axes (x-->y, y-->x)
	4945	* 'flip'@[x/y]: flip the axis x or y
	4946	mapv= map characteristics: [proj],[res]
	4947	see full documentation: http://matplotlib.org/basemap/
	4948	[proj]: projection
	4949	* 'cyl', cilindric
	4950	* 'lcc', lambert conformal
	4951	[res]: resolution:
	4952	* 'c', crude
	4953	* 'l', low
	4954	* 'i', intermediate
	4955	* 'h', high
	4956	* 'f', full
	4957	ifclose= boolean value whether figure should be close (finish) or not
	4958	"""
	4959	## import matplotlib as mpl
	4960	## mpl.use('Agg')
	4961	## import matplotlib.pyplot as plt
	4962	fname = 'plot_2D_shadow_line'
	4963
	4964	if varsv == 'h':
	4965	print fname + '_____________________________________________________________'
	4966	print plot_2D_shadow_line.__doc__
	4967	quit()
	4968
	4969	if reva[0:4] == 'flip':
	4970	reva0 = 'flip'
	4971	if len(reva.split('@')) != 2:
	4972	print errormsg
	4973	print ' ' + fname + ': flip is given', reva, 'but not axis!'
	4974	quit(-1)
	4975	else:
	4976	reva0 = reva
	4977
	4978	if reva0 == 'transpose':
	4979	print ' reversing the axes of the figure (x-->y, y-->x)!!'
	4980	varsv = np.transpose(varsv)
	4981	dxv = dimyv
	4982	dyv = dimxv
	4983	dimxv = dxv
	4984	dimyv = dyv
	4985
	4986	if len(dimxv[:].shape) == 3:
	4987	lon0 = dimxv[0,]
	4988	elif len(dimxv[:].shape) == 2:
	4989	lon0 = dimxv[:]
	4990
	4991	if len(dimyv[:].shape) == 3:
	4992	lat0 = dimyv[0,]
	4993	elif len(dimyv[:].shape) == 2:
	4994	lat0 = dimyv[:]
	4995
	4996	if len(dimxv[:].shape) == 1 and len(dimyv[:].shape) == 1:
	4997	lon00 = dimxv[:]
	4998	lon0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
	4999
	5000	for iy in range(len(lat00)):
	5001	lon0[iy,:] = lon00
	5002	for ix in range(len(lon00)):
	5003	lat0[:,ix] = lat00
	5004
	5005	if not mapv is None:
	5006	map_proj=mapv.split(',')[0]
	5007	map_res=mapv.split(',')[1]
	5008
	5009	dx = lon0.shape[1]
	5010	dy = lat0.shape[0]
	5011
	5012	nlon = lon0[0,0]
	5013	xlon = lon0[dy-1,dx-1]
	5014	nlat = lat0[0,0]
	5015	xlat = lat0[dy-1,dx-1]
	5016
	5017	# Thats too much! :)
	5018	# if lonlatLims is not None:
	5019	# print ' ' + fname + ': cutting the domain to plot !!!!'
	5020	# plt.xlim(lonlatLims[0], lonlatLims[2])
	5021	# plt.ylim(lonlatLims[1], lonlatLims[3])
	5022	# print ' limits: W-E', lonlatLims[0], lonlatLims[2]
	5023	# print ' limits: N-S', lonlatLims[1], lonlatLims[3]
	5024
	5025	# if map_proj == 'cyl':
	5026	# nlon = lonlatLims[0]
	5027	# nlat = lonlatLims[1]
	5028	# xlon = lonlatLims[2]
	5029	# xlat = lonlatLims[3]
	5030	# elif map_proj == 'lcc':
	5031	# lon2 = (lonlatLims[0] + lonlatLims[2])/2.
	5032	# lat2 = (lonlatLims[1] + lonlatLims[3])/2.
	5033	# nlon = lonlatLims[0]
	5034	# xlon = lonlatLims[2]
	5035	# nlat = lonlatLims[1]
	5036	# xlat = lonlatLims[3]
	5037
	5038	lon2 = lon0[dy/2,dx/2]
	5039	lat2 = lat0[dy/2,dx/2]
	5040
	5041	print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:', \
	5042	xlon, ',', xlat
	5043
	5044	if map_proj == 'cyl':
	5045	m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat, \
	5046	urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	5047	elif map_proj == 'lcc':
	5048	m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
	5049	llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	5050	else:
	5051	print errormsg
	5052	print ' ' + fname + ": map projection '" + map_proj + "' not defined!!!"
	5053	print ' available: cyl, lcc'
	5054	quit(-1)
	5055
	5056	if len(dimxv.shape) == 1:
	5057	lons, lats = np.meshgrid(dimxv, dimyv)
	5058	else:
	5059	if len(dimxv.shape) == 3:
	5060	lons = dimxv[0,:,:]
	5061	else:
	5062	lons = dimxv[:]
	5063
	5064	if len(dimyv.shape) == 3:
	5065	lats = dimyv[0,:,:]
	5066	else:
	5067	lats = dimyv[:]
	5068
	5069	x,y = m(lons,lats)
	5070
	5071	else:
	5072	if len(dimxv.shape) == 3:
	5073	x = dimxv[0,:,:]
	5074	elif len(dimxv.shape) == 2:
	5075	x = dimxv
	5076	else:
	5077	# Attempt of simplier way...
	5078	# x = np.zeros((lon0.shape), dtype=np.float)
	5079	# for j in range(lon0.shape[0]):
	5080	# x[j,:] = dimxv
	5081
	5082	## This way is too complicated and maybe not necessary ? (assuming dimxv.shape == dimyv.shape)
	5083	if len(dimyv.shape) == 1:
	5084	x = np.zeros((len(dimyv),len(dimxv)), dtype=np.float)
	5085	for j in range(len(dimxv)):
	5086	x[j,:] = dimxv
	5087	else:
	5088	x = np.zeros((dimyv.shape), dtype=np.float)
	5089	if x.shape[0] == dimxv.shape[0]:
	5090	for j in range(x.shape[1]):
	5091	x[:,j] = dimxv
	5092	else:
	5093	for j in range(x.shape[0]):
	5094	x[j,:] = dimxv
	5095
	5096	if len(dimyv.shape) == 3:
	5097	y = dimyv[0,:,:]
	5098	elif len(dimyv.shape) == 2:
	5099	y = dimyv
	5100	else:
	5101	# y = np.zeros((lat0.shape), dtype=np.float)
	5102	# for i in range(lat0.shape[1]):
	5103	# x[:,i] = dimyv
	5104
	5105	# Idem
	5106	if len(dimxv.shape) == 1:
	5107	y = np.zeros((len(dimyv),len(dimxv)), dtype=np.float)
	5108	for i in range(len(dimxv)):
	5109	y[:,i] = dimyv
	5110	else:
	5111	y = np.zeros((dimxv.shape), dtype=np.float)
	5112	if y.shape[0] == dimyv.shape[0]:
	5113	for i in range(y.shape[1]):
	5114	y[:,i] = dimyv
	5115	else:
	5116	for j in range(y.shape[0]):
	5117	y[j,:] = dimyv
	5118
	5119	plt.rc('text', usetex=True)
	5120
	5121	plt.pcolormesh(x, y, varsv, cmap=plt.get_cmap(colorbar), vmin=vs[0], vmax=vs[1])
	5122	cbar = plt.colorbar()
	5123
	5124	if not mapv is None:
	5125	m.drawcoastlines()
	5126
	5127	meridians = pretty_int(nlon,xlon,5)
	5128	m.drawmeridians(meridians,labels=[True,False,False,True])
	5129	parallels = pretty_int(nlat,xlat,5)
	5130	m.drawparallels(parallels,labels=[False,True,True,False])
	5131
	5132	plt.xlabel('W-E')
	5133	plt.ylabel('S-N')
	5134	else:
	5135	plt.xlabel(variables_values(dimn[1])[0] + ' (' + units_lunits(dimxu) + ')')
	5136	plt.ylabel(variables_values(dimn[0])[0] + ' (' + units_lunits(dimyu) + ')')
	5137
	5138	# Line
	5139	##
	5140
	5141	if reva0 == 'flip' and reva.split('@')[1] == 'y':
	5142	b=-np.max(y[0,:])/np.max(varlv)
	5143	a=np.max(y[0,:])
	5144	else:
	5145	b=np.max(y[0,:])/np.max(varlv)
	5146	a=0.
	5147
	5148	newlinv = varlv*b+a
	5149	if reva0 == 'transpose':
	5150	plt.plot(newlinv, x[0,:], '-', color=colln, linewidth=2)
	5151	else:
	5152	plt.plot(x[0,:], newlinv, '-', color=colln, linewidth=2)
	5153
	5154	txpos = pretty_int(x.min(),x.max(),10)
	5155	typos = pretty_int(y.min(),y.max(),10)
	5156	txlabels = list(txpos)
	5157	for i in range(len(txlabels)): txlabels[i] = str(txlabels[i])
	5158	tylabels = list(typos)
	5159	for i in range(len(tylabels)): tylabels[i] = str(tylabels[i])
	5160
	5161	tllabels = pretty_int(np.min(varlv),np.max(varlv),len(txlabels))
	5162	for it in range(len(tllabels)):
	5163	yval = (tllabels[it]*b+a)
	5164	plt.plot([x.max()*0.97, x.max()], [yval, yval], '-', color='k')
	5165	plt.annotate(tllabels[it], xy=(1.01,tllabels[it]/np.max(varlv)), \
	5166	xycoords='axes fraction')
	5167
	5168	# set the limits of the plot to the limits of the data
	5169	if reva0 == 'flip':
	5170	if reva.split('@')[1] == 'x':
	5171	plt.axis([x.max(), x.min(), y.min(), y.max()])
	5172	else:
	5173	plt.axis([x.min(), x.max(), y.max(), y.min()])
	5174	else:
	5175	plt.axis([x.min(), x.max(), y.min(), y.max()])
	5176
	5177	plt.tick_params(axis='y',right='off')
	5178	if mapv is None:
	5179	plt.xticks(txpos, txlabels)
	5180	plt.yticks(typos, tylabels)
	5181
	5182	tllabels = pretty_int(np.min(varlv),np.max(varlv),len(txlabels))
	5183	for it in range(len(tllabels)):
	5184	plt.annotate(tllabels[it], xy=(1.01,tllabels[it]/np.max(varlv)), xycoords='axes fraction')
	5185
	5186	# units labels
	5187	cbar.set_label(vnames.replace('_','\_') + ' (' + units_lunits(uts) + ')')
	5188
	5189	plt.annotate(vnamel +' (' + units_lunits(utl) + ')', xy=(0.75,0.04),
	5190	xycoords='figure fraction', color=colln)
	5191	figname = '2Dfields_shadow_line'
	5192	graphtit = vtit.replace('_','\_').replace('&','\&')
	5193
	5194	plt.title(graphtit)
	5195
	5196	output_kind(kfig, figname, ifclose)
	5197
	5198	return
	5199
	5200	def plot_Neighbourghood_evol(varsv, dxv, dyv, vnames, ttits, tpos, tlabels, colorbar, \
	5201	Nng, vs, uts, gtit, kfig, ifclose):
	5202	""" Plotting neighbourghood evolution
	5203	varsv= 2D values to plot with shading
	5204	vnames= shading variable name for the figure
	5205	d[x/y]v= values at the axes of x and y
	5206	ttits= titles of both time axis
	5207	tpos= positions of the time ticks
	5208	tlabels= labels of the time ticks
	5209	colorbar= name of the color bar to use
	5210	Nng= Number of grid points of the full side of the box (odd value)
	5211	vs= minmum and maximum values to plot in shadow or:
	5212	'Srange': for full range
	5213	'Saroundmean@val': for mean-xtrm,mean+xtrm where xtrm = np.min(mean-min@val,max@val-mean)
	5214	'Saroundminmax@val': for minval,maxval
	5215	'Saroundpercentile@val': for median-xtrm,median+xtrm where xtrm = np.min(median-percentile_(val),
	5216	percentile_(100-val)-median)
	5217	'Smean@val': for -xtrm,xtrm where xtrm = np.min(mean-min@val,max@val-mean)
	5218	'Smedian@val': for -xtrm,xtrm where xtrm = np.min(median-min@val,max@val-median)
	5219	'Spercentile@val': for -xtrm,xtrm where xtrm = np.min(median-percentile_(val),
	5220	percentile_(100-val)-median)
	5221	uts= units of the variable to shadow
	5222	gtit= title of the graph
	5223	kfig= kind of figure (jpg, pdf, png)
	5224	ifclose= boolean value whether figure should be close (finish) or not
	5225	"""
	5226	import numpy.ma as ma
	5227
	5228	fname = 'plot_Neighbourghood_evol'
	5229
	5230	if varsv == 'h':
	5231	print fname + '_____________________________________________________________'
	5232	print plot_Neighbourghood_evol.__doc__
	5233	quit()
	5234
	5235	if len(varsv.shape) != 2:
	5236	print errormsg
	5237	print ' ' + fname + ': wrong number of dimensions of the values: ', \
	5238	varsv.shape
	5239	quit(-1)
	5240
	5241	varsvmask = ma.masked_equal(varsv,fillValue)
	5242
	5243	vsend = np.zeros((2), dtype=np.float)
	5244	# Changing limits of the colors
	5245	if type(vs[0]) != type(np.float(1.)):
	5246	if vs[0] == 'Srange':
	5247	vsend[0] = np.min(varsvmask)
	5248	elif vs[0][0:11] == 'Saroundmean':
	5249	meanv = np.mean(varsvmask)
	5250	permean = np.float(vs[0].split('@')[1])
	5251	minv = np.min(varsvmask)*permean
	5252	maxv = np.max(varsvmask)*permean
	5253	minextrm = np.min([np.abs(meanv-minv), np.abs(maxv-meanv)])
	5254	vsend[0] = meanv-minextrm
	5255	vsend[1] = meanv+minextrm
	5256	elif vs[0][0:13] == 'Saroundminmax':
	5257	permean = np.float(vs[0].split('@')[1])
	5258	minv = np.min(varsvmask)*permean
	5259	maxv = np.max(varsvmask)*permean
	5260	vsend[0] = minv
	5261	vsend[1] = maxv
	5262	elif vs[0][0:17] == 'Saroundpercentile':
	5263	medianv = np.median(varsvmask)
	5264	valper = np.float(vs[0].split('@')[1])
	5265	minv = np.percentile(varsvmask, valper)
	5266	maxv = np.percentile(varsvmask, 100.-valper)
	5267	minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
	5268	vsend[0] = medianv-minextrm
	5269	vsend[1] = medianv+minextrm
	5270	elif vs[0][0:5] == 'Smean':
	5271	meanv = np.mean(varsvmask)
	5272	permean = np.float(vs[0].split('@')[1])
	5273	minv = np.min(varsvmask)*permean
	5274	maxv = np.max(varsvmask)*permean
	5275	minextrm = np.min([np.abs(meanv-minv), np.abs(maxv-meanv)])
	5276	vsend[0] = -minextrm
	5277	vsend[1] = minextrm
	5278	elif vs[0][0:7] == 'Smedian':
	5279	medianv = np.median(varsvmask)
	5280	permedian = np.float(vs[0].split('@')[1])
	5281	minv = np.min(varsvmask)*permedian
	5282	maxv = np.max(varsvmask)*permedian
	5283	minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
	5284	vsend[0] = -minextrm
	5285	vsend[1] = minextrm
	5286	elif vs[0][0:11] == 'Spercentile':
	5287	medianv = np.median(varsvmask)
	5288	valper = np.float(vs[0].split('@')[1])
	5289	minv = np.percentile(varsvmask, valper)
	5290	maxv = np.percentile(varsvmask, 100.-valper)
	5291	minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
	5292	vsend[0] = -minextrm
	5293	vsend[1] = minextrm
	5294	else:
	5295	print errormsg
	5296	print ' ' + fname + ": range '" + vs[0] + "' not ready!!!"
	5297	quit(-1)
	5298	print ' ' + fname + ': modified shadow min,max:',vsend
	5299	else:
	5300	vsend[0] = vs[0]
	5301
	5302	if type(vs[0]) != type(np.float(1.)):
	5303	if vs[1] == 'range':
	5304	vsend[1] = np.max(varsv)
	5305	else:
	5306	vsend[1] = vs[1]
	5307
	5308	plt.rc('text', usetex=True)
	5309
	5310	# plt.pcolormesh(dxv, dyv, varsv, cmap=plt.get_cmap(colorbar), vmin=vsend[0], vmax=vsend[1])
	5311	plt.pcolormesh(varsvmask, cmap=plt.get_cmap(colorbar), vmin=vsend[0], vmax=vsend[1])
	5312	cbar = plt.colorbar()
	5313
	5314	newtposx = (tpos[0][:] - np.min(dxv)) * len(dxv) * Nng / (np.max(dxv) - np.min(dxv))
	5315	newtposy = (tpos[1][:] - np.min(dyv)) * len(dyv) * Nng / (np.max(dyv) - np.min(dyv))
	5316
	5317	plt.xticks(newtposx, tlabels[0])
	5318	plt.yticks(newtposy, tlabels[1])
	5319	plt.xlabel(ttits[0])
	5320	plt.ylabel(ttits[1])
	5321
	5322	plt.axes().set_aspect('equal')
	5323	# From: http://stackoverflow.com/questions/14406214/moving-x-axis-to-the-top-of-a-plot-in-matplotlib
	5324	plt.axes().xaxis.tick_top
	5325	plt.axes().xaxis.set_ticks_position('top')
	5326
	5327	# units labels
	5328	cbar.set_label(vnames.replace('_','\_') + ' (' + units_lunits(uts) + ')')
	5329
	5330	figname = 'Neighbourghood_evol'
	5331	graphtit = gtit.replace('_','\_').replace('&','\&')
	5332
	5333	plt.title(graphtit, position=(0.5,1.05))
	5334
	5335	output_kind(kfig, figname, ifclose)
	5336
	5337	return
	5338
[218]	5339	def plot_lines(vardv, varvv, vaxis, dtit, linesn, vtit, vunit, gtit, gloc, kfig):
[192]	5340	""" Function to plot a collection of lines
	5341	vardv= list of set of dimension values
	5342	varvv= list of set of values
	5343	vaxis= which axis will be used for the values ('x', or 'y')
	5344	dtit= title for the common dimension
	5345	linesn= names for the legend
	5346	vtit= title for the vaxis
	5347	vunit= units of the vaxis
	5348	gtit= main title
[655]	5349	gloc= location of the legend (0, autmoatic)
[218]	5350	1: 'upper right', 2: 'upper left', 3: 'lower left', 4: 'lower right',
	5351	5: 'right', 6: 'center left', 7: 'center right', 8: 'lower center',
	5352	9: 'upper center', 10: 'center'
[192]	5353	kfig= kind of figure
	5354	plot_lines([np.arange(10)], [np.sin(np.arange(10)*np.pi/2.5)], 'y', 'time (s)', \
	5355	['2.5'], 'sin', '-', 'sinus frequency dependency', 'pdf')
	5356	"""
	5357	fname = 'plot_lines'
	5358
	5359	if vardv == 'h':
	5360	print fname + '_____________________________________________________________'
	5361	print plot_lines.__doc__
	5362	quit()
	5363
	5364	# Canging line kinds every 7 lines (end of standard colors)
	5365	linekinds=['.-','x-','o-']
[679]	5366	pointkindsauto=['.', ',', 'x', 'o', '*', '+', '<', '\|', '_', '>', '1', '8', 's', \
	5367	'p', 'h', 'D']
[192]	5368
	5369	Ntraj = len(vardv)
	5370
	5371	N7lines = 0
	5372
[473]	5373	xmin = 100000.
	5374	xmax = -100000.
	5375	ymin = 100000.
	5376	ymax = -100000.
	5377	for il in range(Ntraj):
	5378	minv = np.min(varvv[il])
	5379	maxv = np.max(varvv[il])
	5380	mind = np.min(vardv[il])
	5381	maxd = np.max(vardv[il])
	5382
	5383	if minv < xmin: xmin = minv
	5384	if maxv > xmax: xmax = maxv
	5385	if mind < ymin: ymin = mind
	5386	if maxd > ymax: ymax = maxd
	5387
[474]	5388	print 'x:',xmin,',',xmax,'y:',ymin,ymax
	5389
[192]	5390	plt.rc('text', usetex=True)
	5391
	5392	if vaxis == 'x':
	5393	for il in range(Ntraj):
	5394	plt.plot(varvv[il], vardv[il], linekinds[N7lines], label= linesn[il])
	5395	if il == 6: N7lines = N7lines + 1
	5396
	5397	plt.xlabel(vtit + ' (' + vunit + ')')
	5398	plt.ylabel(dtit)
[474]	5399	plt.xlim(xmin,xmax)
	5400	plt.ylim(ymin,ymax)
[192]	5401
	5402	else:
	5403	for il in range(Ntraj):
	5404	plt.plot(vardv[il], varvv[il], linekinds[N7lines], label= linesn[il])
	5405	if il == 6: N7lines = N7lines + 1
	5406
	5407	plt.xlabel(dtit)
	5408	plt.ylabel(vtit + ' (' + vunit + ')')
[473]	5409
[474]	5410	plt.xlim(ymin,ymax)
	5411	plt.ylim(xmin,xmax)
[192]	5412
	5413	figname = 'lines'
[385]	5414	graphtit = gtit.replace('_','\_').replace('&','\&')
[192]	5415
	5416	plt.title(graphtit)
[218]	5417	plt.legend(loc=gloc)
[192]	5418
	5419	output_kind(kfig, figname, True)
	5420
	5421	return
[194]	5422
[687]	5423	def ColorsLinesPointsStyles(Nstyles, colors, lines, points, lwidths, psizes, ptfreq):
	5424	""" Function to provide the colors, lines & points styles
	5425	Nstyles= total number of styles
	5426	colors= list of colors, None for no value
	5427	lines= list of lines, None for no value
	5428	points= list of points, None for no value
	5429	lwidths= list of line widths, None for no value
	5430	psizes= list of point sizes, None for no value
	5431	ptfreq= frequency for the points, None for all values
	5432	>>> Nstyles = 3
	5433	>>> colors = ['blue']
	5434	>>> lines = ['-']
	5435	>>> points = ['x', '*', 'o']
	5436	>>> lwidths = ['1']
	5437	>>> psizes = ['2']
	5438	>>> ptfreq = 2
	5439	>>> colors, lines, points = ColorsLinesPointsStyles(Nstyles, colors, lines, points, lwidths, psizes, ptfreq)
	5440	['blue', 'blue', 'blue']
	5441	['-', '-', '-']
	5442	['x', '*', 'o']
	5443	['2', '2', '2']
	5444	['1', '1', '1']
	5445	"""
	5446	fname = 'ColorsLinesPointsStyles'
	5447
	5448	usecolors = []
	5449	uselines = []
	5450	usepoints = []
	5451	usewlines = []
	5452	usespoints = []
	5453
	5454	# Colors
	5455	if colors is None:
	5456	Ncols = len(colorsauto)
	5457	for ic in range(Nstyles):
	5458	iic = np.mod(ic,Ncols) - 1
	5459	if iic == 0: iic = Ncols - 1
	5460	usecolors.append(colorsauto[iic])
	5461	else:
	5462	Ncols = len(colors)
	5463	if Ncols == 1:
	5464	for ic in range(Nstyles):
	5465	usecolors.append(colors[0])
	5466	else:
	5467	if Ncols != Nstyles:
	5468	print errormsg
	5469	print ' ' + fname + ': number of provided colors:', Ncols, \
	5470	'and required:', Nstyles,'differ !!'
	5471	quit(-1)
	5472	usecolors = colors
	5473
	5474	# Lines
	5475	if lines is None:
	5476	Nklns = len(linekindsauto)
	5477	for il in range(Nstyles):
	5478	iil = np.mod(il,Nklns) - 1
	5479	if iil == 0: iil = Nklns - 1
	5480	uselines.append(linekindsauto[iil])
	5481	else:
	5482	Nklns = len(lines)
	5483	if Nklns == 1:
	5484	for il in range(Nstyles):
	5485	uselines.append(lines[0])
	5486	else:
	5487	if Nklns != Nstyles:
	5488	print errormsg
	5489	print ' ' + fname + ': number of provided lines:', Nklns, \
	5490	'and required:', Nstyles,'differ !!'
	5491	quit(-1)
	5492	uselines = lines
	5493
	5494	# Points
	5495	if points is None:
	5496	Nkpts = len(pointkindsauto)
	5497	for ip in range(Nstyles):
	5498	iip = np.mod(ip,Nkpts) - 1
	5499	if iip == 0: iip = Nkpts - 1
	5500	usepoints.append(pointkindsauto[iip])
	5501	else:
	5502	Nkpts = len(points)
	5503	if Nkpts == 1:
	5504	for ip in range(Nstyles):
	5505	usepoints.append(points[0])
	5506	else:
	5507	if Nkpts != Nstyles:
	5508	print errormsg
	5509	print ' ' + fname + ': number of provided points:', Nkpts, \
	5510	'and required:', Nstyles,'differ !!'
	5511	quit(-1)
	5512	usepoints = points
	5513
	5514	# Line widths
	5515	if lwidths is None:
	5516	Nwlns = len(linewidthsauto)
	5517	for il in range(Nstyles):
	5518	iil = np.mod(il,Nwlns) - 1
	5519	if iil == 0: iil = Nwlns - 1
	5520	usewlines.append(linewidthsauto[iil])
	5521	else:
	5522	Nwlns = len(lwidths)
	5523	if Nwlns == 1:
	5524	for il in range(Nstyles):
	5525	usewlines.append(lwidths[0])
	5526	else:
	5527	if Nwlns != Nstyles:
	5528	print errormsg
	5529	print ' ' + fname + ': number of provided line widthss:', Nwlns, \
	5530	'and required:', Nstyles, 'differ !!'
	5531	quit(-1)
	5532	usewlines = lwidths
	5533
	5534	# Point sizes
	5535	if psizes is None:
	5536	Nspts = len(pointsizesauto)
	5537	for ip in range(Nstyles):
	5538	iip = np.mod(ip,Nspts) - 1
	5539	if iip == 0: iip = Nspts - 1
	5540	usespoints.append(pointsizesauto[iip])
	5541	else:
	5542	Nspts = len(psizes)
	5543	if Nspts == 1:
	5544	for ip in range(Nstyles):
	5545	usespoints.append(psizes[0])
	5546	else:
	5547	if Nspts != Nstyles:
	5548	print errormsg
	5549	print ' ' + fname + ': number of provided point sizes:', Nspts, \
	5550	'and required:', Nstyles, 'differ !!'
	5551	quit(-1)
	5552	usespoints = psizes
	5553
	5554	Ncols = len(usecolors)
	5555	Nlins = len(uselines)
	5556	Npnts = len(usepoints)
	5557
	5558	lkinds = []
	5559	pkinds = []
	5560
	5561	lcolors = usecolors
	5562
	5563	# Old way
	5564	# if ptfreq is not None:
	5565	# lkinds = uselines
	5566	# pkinds = usepoints
	5567	# else:
	5568	# pkinds = usepoints
	5569	# lkinds = uselines
	5570	# for ilp in range(Nstyles):
	5571	# lkinds.append(usepoints[ilp] + uselines[ilp])
	5572
	5573	return lcolors, uselines, usepoints, usewlines, usespoints
	5574
	5575	#Nstyles = 3
	5576	#colors = ['blue']
	5577	#lines = ['-']
	5578	#points = ['x', '*', 'o']
	5579	#lwidths = ['2']
	5580	#psizes = ['1']
	5581	#ptfreq = 2
	5582	#print ColorsLinesPointsStyles(Nstyles, colors, lines, points, lwidths, psizes, ptfreq)
	5583
[684]	5584	def LinesPointsStyles(Nstyles, lines, points, ptfreq):
	5585	""" Function to provide the lines & points styles
	5586	Nstyles= total number of styles
	5587	lines= list of lines, None for no value
	5588	points= list of points, None for no value
	5589	ptfreq= frequency for the points, None for all values
	5590	>>> Nstyles = 3
	5591	>>> lines = ['-']
	5592	>>> points = ['x', '*', 'o']
	5593	>>> ptfreq = 2
	5594	>>> lines, points = LinesPointsStyles(Nstyles, lines, points, ptfreq)
	5595	['-', '-', '-']
	5596	['x', '*', 'o']
	5597	"""
	5598	fname = 'LinesPointsStyles'
	5599
	5600	# Canging line kinds every 7 lines (end of standard colors)
	5601	uselines = []
	5602	usepoints = []
	5603	if lines is None:
	5604	Nklns = len(linekindsauto)
	5605	for il in range(Nstyles):
	5606	iil = np.mod(il,Nklns)
	5607	uselines.append(linekindsauto[iil])
	5608	else:
	5609	Nklns = len(lines)
	5610	if Nklns == 1:
	5611	for il in range(Nstyles):
	5612	uselines.append(lines[0])
	5613	else:
	5614	if Nklns != Nstyles:
	5615	print errormsg
	5616	print ' ' + fname + ': number of provided lines:', Nklns, \
	5617	'and required:', Nstyles,'differ !!'
	5618	quit(-1)
	5619	uselines = lines
	5620
	5621	if points is None:
	5622	Nkpts = len(pointkindsauto)
	5623	for ip in range(Nstyles):
	5624	iip = np.mod(ip,Nkpts)
	5625	usepoints.append(pointkindsauto[iip])
	5626	else:
	5627	Nkpts = len(points)
	5628	if Nkpts == 1:
	5629	for ip in range(Nstyles):
	5630	usepoints.append(points[0])
	5631	else:
	5632	if Nkpts != Nstyles:
	5633	print errormsg
	5634	print ' ' + fname + ': number of provided points:', Nkpts, \
	5635	'and required:', Nstyles,'differ !!'
	5636	quit(-1)
	5637	usepoints = points
	5638
	5639	Nlins = len(uselines)
	5640	Npnts = len(usepoints)
	5641
	5642	lkinds = []
	5643	pkinds = []
	5644	if ptfreq is not None:
	5645	lkinds = uselines
	5646	pkinds = usepoints
	5647	else:
[687]	5648	pkinds = usepoints
[684]	5649	for ilp in range(Nstyles):
	5650	lkinds.append(usepoints[ilp] + uselines[ilp])
	5651
	5652	return lkinds, pkinds
	5653
[562]	5654	def plot_lines_time(vardv, varvv, vaxis, dtit, linesn0, vtit, vunit, tpos, tlabs, \
[687]	5655	gtit, gloc, kfig, lsl, coll, ptl, lwidth, psize, ptf):
[194]	5656	""" Function to plot a collection of lines with a time axis
	5657	vardv= list of set of dimension values
	5658	varvv= list of set of values
	5659	vaxis= which axis will be used for the time values ('x', or 'y')
	5660	dtit= title for the common dimension
[562]	5661	linesn= names for the legend (None, no legend)
[194]	5662	vtit= title for the vaxis
	5663	vunit= units of the vaxis
	5664	tpos= positions of the time ticks
	5665	tlabs= labels of the time ticks
	5666	gtit= main title
[655]	5667	gloc= location of the legend (0, autmoatic)
[204]	5668	1: 'upper right', 2: 'upper left', 3: 'lower left', 4: 'lower right',
	5669	5: 'right', 6: 'center left', 7: 'center right', 8: 'lower center',
	5670	9: 'upper center', 10: 'center'
[194]	5671	kfig= kind of figure
[683]	5672	lsl= ',' list of line styles
[620]	5673	coll= ',' list of colors for the lines, None for automatic, single
	5674	value all the same
	5675	ptl= ',' list of type of points for the lines, None for automatic, single
	5676	value all the same
[687]	5677	lwidth= ',' list of line widths
	5678	psize= ',' list of point sizes
[679]	5679	ptf= frequency of point plotting, 'all' for all time steps
[687]	5680
[194]	5681	plot_lines([np.arange(10)], [np.sin(np.arange(10)*np.pi/2.5)], 'y', 'time (s)', \
	5682	['2.5'], 'sin', '-', 'sinus frequency dependency', 'pdf')
	5683	"""
[679]	5684	fname = 'plot_lines_time'
[194]	5685
	5686	if vardv == 'h':
	5687	print fname + '_____________________________________________________________'
	5688	print plot_lines.__doc__
	5689	quit()
	5690
	5691	Ntraj = len(vardv)
	5692
[687]	5693	colvalues, linekinds, pointkinds, lwidths, psizes = ColorsLinesPointsStyles( \
	5694	Ntraj, coll, lsl, ptl, lwidth, psize, ptf)
[194]	5695
	5696	plt.rc('text', usetex=True)
[560]	5697	xtrmvv = [fillValueF,-fillValueF]
	5698	xtrmdv = [fillValueF,-fillValueF]
[194]	5699
[562]	5700	# Do we have legend?
	5701	##
	5702	if linesn0 is None:
	5703	linesn = []
	5704	for itrj in range(Ntraj):
[563]	5705	linesn.append(str(itrj))
[562]	5706	else:
	5707	linesn = linesn0
	5708
[194]	5709	if vaxis == 'x':
	5710	for il in range(Ntraj):
[687]	5711	plt.plot(varvv[il], vardv[il], linekinds[il], marker=pointkinds[il], \
	5712	label=linesn[il], color=colvalues[il], linewidth=lwidths[il], \
	5713	markersize=psizes[il], markevery=ptf)
[531]	5714
[687]	5715	# Old way
	5716	# if ptf is None:
	5717	# plt.plot(varvv[il], vardv[il], linekinds[il], label= linesn[il], \
	5718	# color=colvalues[il], linewidth=lwidths[il], markersize=psizes[il])
	5719	# else:
	5720	# plt.plot(varvv[il], vardv[il], linekinds[il], color=colvalues[il], \
	5721	# linewidth=lwidths[il])
	5722	# plt.plot(varvv[il][::ptf], vardv[il][::ptf], pointkinds[il], \
	5723	# label= linesn[il], color=colvalues[il], linewidth=lwidths[il], \
	5724	# markersize=psizes[il])
	5725
[560]	5726	minvv = np.min(varvv[il])
	5727	maxvv = np.max(varvv[il])
	5728	mindv = np.min(vardv[il])
	5729	maxdv = np.max(vardv[il])
	5730
	5731	if minvv < xtrmvv[0]: xtrmvv[0] = minvv
	5732	if maxvv > xtrmvv[1]: xtrmvv[1] = maxvv
	5733	if mindv < xtrmdv[0]: xtrmdv[0] = mindv
	5734	if maxdv > xtrmdv[1]: xtrmdv[1] = maxdv
	5735
[194]	5736	plt.xlabel(vtit + ' (' + vunit + ')')
	5737	plt.ylabel(dtit)
[560]	5738	# plt.xlim(np.min(varTvv),np.max(varTvv))
	5739	# plt.ylim(np.min(varTdv),np.max(varTdv))
	5740	plt.xlim(xtrmvv[0],xtrmvv[1])
	5741	plt.ylim(xtrmdv[0],xtrmdv[1])
	5742
[194]	5743	plt.yticks(tpos, tlabs)
	5744	else:
	5745	for il in range(Ntraj):
[687]	5746	plt.plot(vardv[il], varvv[il], linekinds[il], marker=pointkinds[il], \
	5747	label=linesn[il], color=colvalues[il], linewidth=lwidths[il], \
	5748	markersize=psizes[il], markevery=ptf)
[531]	5749
[687]	5750	# Old way
	5751	# if ptf is None:
	5752	# plt.plot(vardv[il], varvv[il], linekinds[il], label= linesn[il], \
	5753	# color=colvalues[il], linewidth=lwidths[il], markersize=psizes[il], markevery=ptf)
	5754	# else:
	5755	# plt.plot(vardv[il], varvv[il], linekinds[il], color=coll[il], \
	5756	# linewidth=lwidths[il])
	5757	# plt.plot(vardv[il][::ptf], varvv[il][::ptf], pointkinds[il], \
	5758	# label= linesn[il], color=colvalues[il], linewidth=lwidths[il], \
	5759	# markersize=psizes[il])
	5760
[560]	5761	minvv = np.min(varvv[il])
	5762	maxvv = np.max(varvv[il])
	5763	mindv = np.min(vardv[il])
	5764	maxdv = np.max(vardv[il])
	5765
	5766	if minvv < xtrmvv[0]: xtrmvv[0] = minvv
	5767	if maxvv > xtrmvv[1]: xtrmvv[1] = maxvv
	5768	if mindv < xtrmdv[0]: xtrmdv[0] = mindv
	5769	if maxdv > xtrmdv[1]: xtrmdv[1] = maxdv
	5770
[194]	5771	plt.xlabel(dtit)
	5772	plt.ylabel(vtit + ' (' + vunit + ')')
[197]	5773
[560]	5774	plt.xlim(xtrmdv[0],xtrmdv[1])
	5775	plt.ylim(xtrmvv[0],xtrmvv[1])
	5776
	5777	# plt.xlim(np.min(varTdv),np.max(varTdv))
	5778	# plt.ylim(np.min(varTvv),np.max(varTvv))
[194]	5779	plt.xticks(tpos, tlabs)
	5780
	5781	figname = 'lines_time'
[385]	5782	graphtit = gtit.replace('_','\_').replace('&','\&')
[194]	5783
	5784	plt.title(graphtit)
[562]	5785	if linesn0 is not None:
[681]	5786	if Ntraj < 10:
	5787	plt.legend(loc=gloc)
	5788	elif 10 < Ntraj < 20:
	5789	plt.legend(loc=gloc, prop={'size':10})
	5790	else:
	5791	plt.legend(loc=gloc, prop={'size':8})
[560]	5792
	5793	print plt.xlim(),':', plt.ylim()
[194]	5794
	5795	output_kind(kfig, figname, True)
	5796
	5797	return
[539]	5798
[540]	5799	def plot_barbs(xvals,yvals,uvals,vvals,vecfreq,veccolor,veclength,windn,wuts,mapv,graphtit,kfig,figname):
[539]	5800	""" Function to plot wind barbs
[698]	5801	xvals= x position of the values
	5802	yvals= y position of the values
	5803	uvals= values for the x-wind
	5804	uvals= values for the y-wind
[539]	5805	vecfreq= [xfreq],[yfreq] frequency of values allong each axis (None, all grid points;
	5806	'auto', computed automatically to have 20 vectors along each axis)
	5807	veccolor= color of the vectors (None, for 'red')
	5808	veclength= length of the wind barbs (None, for 9)
	5809	windn= name of the wind variable in the graph
	5810	wuts= units of the wind variable in the graph
	5811	mapv= map characteristics: [proj],[res]
	5812	see full documentation: http://matplotlib.org/basemap/
	5813	[proj]: projection
	5814	* 'cyl', cilindric
	5815	* 'lcc', lambert conformal
	5816	[res]: resolution:
	5817	* 'c', crude
	5818	* 'l', low
	5819	* 'i', intermediate
	5820	* 'h', high
	5821	* 'f', full
	5822	graphtit= title of the graph ('\|', for spaces)
	5823	kfig= kind of figure
	5824	figname= name of the figure
	5825	"""
	5826	fname = 'plot_barbs'
	5827
	5828	dx=xvals.shape[1]
	5829	dy=xvals.shape[0]
	5830
	5831	# Frequency of vectors
	5832	if vecfreq is None:
	5833	xfreq = 1
	5834	yfreq = 1
	5835	elif vecfreq == 'auto':
	5836	xfreq = dx/20
	5837	yfreq = dy/20
	5838	else:
	5839	xfreq=int(vecfreq.split('@')[0])
	5840	yfreq=int(vecfreq.split('@')[1])
	5841
[540]	5842	if veccolor == 'auto':
[539]	5843	vcolor = "red"
	5844	else:
	5845	vcolor = veccolor
	5846
[540]	5847	if veclength == 'auto':
[539]	5848	vlength = 9
	5849	else:
	5850	vlength = veclength
	5851
	5852	plt.rc('text', usetex=True)
	5853
	5854	if not mapv is None:
	5855	lon00 = np.where(xvals[:] < 0., 360. + xvals[:], xvals[:])
	5856	lat00 = yvals[:]
	5857
	5858	map_proj=mapv.split(',')[0]
	5859	map_res=mapv.split(',')[1]
	5860
	5861	nlon = np.min(xvals[::yfreq,::xfreq])
	5862	xlon = np.max(xvals[::yfreq,::xfreq])
	5863	nlat = np.min(yvals[::yfreq,::xfreq])
	5864	xlat = np.max(yvals[::yfreq,::xfreq])
	5865
	5866	lon2 = xvals[dy/2,dx/2]
	5867	lat2 = yvals[dy/2,dx/2]
	5868
	5869	print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:', \
	5870	xlon, ',', xlat
	5871
	5872	if map_proj == 'cyl':
	5873	m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat, \
	5874	urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	5875	elif map_proj == 'lcc':
	5876	m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
	5877	llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	5878	else:
	5879	print errormsg
	5880	print ' ' + fname + ": projection '" + map_proj + "' not ready!!"
	5881	print ' projections available: cyl, lcc'
	5882	quit(-1)
	5883
	5884	m.drawcoastlines()
	5885
	5886	meridians = pretty_int(nlon,xlon,5)
	5887	m.drawmeridians(meridians,labels=[True,False,False,True],color="black")
	5888
	5889	parallels = pretty_int(nlat,xlat,5)
	5890	m.drawparallels(parallels,labels=[False,True,True,False],color="black")
	5891
	5892	plt.xlabel('W-E')
	5893	plt.ylabel('S-N')
	5894
[540]	5895	plt.barbs(xvals[::yfreq,::xfreq], yvals[::yfreq,::xfreq], uvals[::yfreq,::xfreq],\
	5896	vvals[::yfreq,::xfreq], color=vcolor, pivot='tip')
[539]	5897
	5898	plt.annotate(windn.replace('_','\_') +' (' + units_lunits(wuts) + ')', \
	5899	xy=(0.85,-0.10), xycoords='axes fraction', color=vcolor)
	5900
	5901	plt.title(graphtit.replace('\|',' ').replace('&','\&'))
	5902
	5903	## NOT WORKING ##
	5904
	5905	# No legend so it is imposed
	5906	## windlabel=windn.replace('_','\_') +' (' + units_lunits(wuts[1]) + ')'
	5907	## vecpatch = mpatches.Patch(color=vcolor, label=windlabel)
	5908
	5909	## plt.legend(handles=[vecpatch])
	5910
	5911	## vecline = mlines.Line2D([], [], color=vcolor, marker='.', markersize=10, label=windlabel)
	5912	## plt.legend(handles=[vecline], loc=1)
	5913
	5914	output_kind(kfig, figname, True)
	5915
	5916	return
[625]	5917
[652]	5918	def plot_ptZvals(vname,vunits,points,ptype,ptsize,graphlims,minmax,figtitle,cbar, \
	5919	mapv,kfig):
	5920	""" Function to plot a given list of points and values
	5921	vname= name of the variable in the graph
	5922	vunits= units of the variable
	5923	points= [lon,lat,val] matrix of values
	5924	ptype= type of the point
	5925	ptsize= size of the point
	5926	graphlims= minLON,minLAT,maxLON,maxLAT limits of the graph, None for the full size
	5927	minmax= minimum and maximum type
	5928	'auto': values taken from the extrems of the data
	5929	[min],[max]: given minimum and maximum values
	5930	figtitle= title of the figure
	5931	cbar= color bar
	5932	mapv= map characteristics: [proj],[res]
	5933	see full documentation: http://matplotlib.org/basemap/
	5934	[proj]: projection
	5935	* 'cyl', cilindric
	5936	* 'lcc', lambert-conformal
	5937	[res]: resolution:
	5938	* 'c', crude
	5939	* 'l', low
	5940	* 'i', intermediate
	5941	* 'h', high
	5942	* 'f', full
	5943	kfig= kind of figure
	5944	"""
	5945	fname = 'plot_ptZvals'
	5946
	5947	figname = 'pointsZval'
	5948
	5949	minlon = points[:,0].min()
	5950	maxlon = points[:,0].max()
	5951
	5952	minlat = points[:,1].min()
	5953	maxlat = points[:,1].max()
	5954
	5955	minval = points[:,2].min()
	5956	maxval = points[:,2].max()
	5957
	5958	# print 'min/max val;',minval,maxval
	5959
	5960	lonrange = (points[:,0] - minlon)/(maxlon - minlon)
	5961	latrange = (points[:,1] - minlat)/(maxlat - minlat)
	5962	colorrange = (points[:,2] - minval)/(maxval - minval)
	5963
	5964	plt.rc('text', usetex=True)
	5965
	5966	if mapv is not None:
	5967	vlon = points[:,0]
	5968	vlat = points[:,1]
	5969	dx = len(vlon)
	5970	dy = len(vlat)
	5971
	5972	# vlon = np.where(vlon[:] < 0., 360. + vlon[:], vlon[:])
	5973	# xvala = np.array(xval)
	5974	# xvala = np.where(xvala < 0., 360. + xvala, xvala)
	5975	# xval = list(xvala)
	5976
	5977	map_proj=mapv.split(',')[0]
	5978	map_res=mapv.split(',')[1]
	5979
	5980	if graphlims is not None:
	5981	nlon = graphlims[0]
	5982	xlon = graphlims[2]
	5983	nlat = graphlims[1]
	5984	xlat = graphlims[3]
	5985	else:
	5986	nlon = np.min(vlon)
	5987	xlon = np.max(vlon)
	5988	nlat = np.min(vlat)
	5989	xlat = np.max(vlat)
	5990
	5991	lon2 = vlon[dy/2]
	5992	lat2 = vlat[dy/2]
	5993
	5994	print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:', \
	5995	xlon, ',', xlat
	5996
	5997	if map_proj == 'cyl':
	5998	m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat, \
	5999	urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	6000	elif map_proj == 'lcc':
	6001	m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
	6002	llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	6003	else:
	6004	print errormsg
	6005	print ' ' + fname + ": map projecion '" + map_proj + "' not ready!!"
	6006	print ' available: cyl, lcc'
	6007	quit(-1)
	6008
	6009	# lons, lats = np.meshgrid(vlon, vlat)
	6010	# lons = np.where(lons < 0., lons + 360., lons)
	6011
	6012	x,y = m(vlon,vlat)
	6013
	6014	m.drawcoastlines()
	6015
	6016	meridians = pretty_int(nlon,xlon,5)
	6017	m.drawmeridians(meridians,labels=[True,False,False,True])
	6018
	6019	parallels = pretty_int(nlat,xlat,5)
	6020	m.drawparallels(parallels,labels=[False,True,True,False])
	6021	# else:
	6022	# x = vlon
	6023	# y = vlat
	6024	# plt.xlim(0,dx-1)
	6025	# plt.ylim(0,dy-1)
	6026
	6027	if minmax == 'auto':
	6028	plt.scatter(points[:,0], points[:,1], c=points[:,2], s=ptsize, cmap=cbar, \
	6029	marker=ptype)
	6030	else:
	6031	minv = np.float(minmax.split(',')[0])
	6032	maxv = np.float(minmax.split(',')[1])
	6033
	6034	plt.scatter(points[:,0], points[:,1], c=points[:,2], s=ptsize, cmap=cbar, \
	6035	marker=ptype, vmin=minv, vmax=maxv)
	6036
	6037	cbar = plt.colorbar()
	6038	cbar.set_label(vname.replace('_','\_') +' ('+ units_lunits(vunits) + ')')
	6039
	6040	plt.title(figtitle)
	6041	if graphlims is not None:
	6042	plt.xlim(graphlims[0], graphlims[2])
	6043	plt.ylim(graphlims[1], graphlims[3])
	6044
	6045	output_kind(kfig, figname, True)
	6046
	6047	return
	6048
	6049	#pts = np.zeros((10,3), dtype=np.float)
	6050	#pts[:,0] = np.arange(10,20)*1.
	6051	#pts[:,1] = np.arange(30,40)*1.
	6052	#pts[:,2] = np.arange(-5,5)*1.
	6053
	6054	#plot_ptZvals('vals','kgm-2',pts,'.',300, 'values of values', 'seismic', 'cyl,l', 'pdf')
	6055
[625]	6056	def plot_ZQradii(Zmeans, graphtit, kfig, figname):
	6057	""" Function to plot following radial averages only at exact grid poins
	6058	Zmeans= radial means
	6059	radii= values of the taken radii
	6060	graphtit= title of the graph ('\|', for spaces)
	6061	kfig= kind of figure
	6062	figname= name of the figure
	6063	"""
	6064
	6065	fname = 'plot_ZQradii'
	6066
	6067	output_kind(kfig, figname, True)
	6068
	6069	return
[698]	6070
	6071	def plot_vector(xvals,yvals,uvals,vvals,vecfreq,vecoln,veccolor,veclength,windn,wuts,\
	6072	mapv,graphtit,kfig,figname):
	6073	""" Function to plot vectors
	6074	xvals= values for the x-axis
	6075	yvals= values for the y-axis
	6076	uvals= values for the x-wind
	6077	vvals= values for the y-wind
	6078	vecfreq= [xfreq],[yfreq] frequency of values allong each axis (None, all grid points;
	6079	'auto', computed automatically to have 20 vectors along each axis)
	6080	veccoln= name for the color of the vectors
	6081	'singlecol'@[colorn]: all the vectors same color ('auto': for 'red')
	6082	'wind'@[colorbar]: color of the vectors according to wind speed sqrt(u^2+v^2) and given [colorbar]
[704]	6083	'3rdvar'@[colorbar]@[varn]@[units]: color of the vectors according to a 3rd variable (to be added at -v) and given [colorbar]
[698]	6084	veccolor= color of the vectors
	6085	veclength= length of the wind vectors:
	6086	'singlecol': 'auto', for 9
	6087	'wind' and '3rdvar': 'auto' length as wind speed, otherwise fix length
	6088	windn= name of the wind variable in the graph
	6089	wuts= units of the wind variable in the graph
	6090	mapv= map characteristics: [proj],[res]
	6091	see full documentation: http://matplotlib.org/basemap/
	6092	[proj]: projection
	6093	* 'cyl', cilindric
	6094	* 'lcc', lambert conformal
	6095	[res]: resolution:
	6096	* 'c', crude
	6097	* 'l', low
	6098	* 'i', intermediate
	6099	* 'h', high
	6100	* 'f', full
	6101	graphtit= title of the graph ('\|', for spaces)
	6102	kfig= kind of figure
	6103	figname= name of the figure
	6104	"""
	6105	fname = 'plot_vector'
	6106
	6107	dx=xvals.shape[1]
	6108	dy=xvals.shape[0]
	6109
	6110	# Frequency of vectors
	6111	if vecfreq is None:
	6112	xfreq = 1
	6113	yfreq = 1
	6114	elif vecfreq == 'auto':
	6115	xfreq = dx/20
	6116	yfreq = dy/20
	6117	else:
	6118	xfreq=int(vecfreq.split('@')[0])
	6119	yfreq=int(vecfreq.split('@')[1])
	6120
	6121	# Vector length
	6122	if veclength == 'auto':
	6123	vlength = 9
	6124	else:
	6125	vlength = veclength
	6126
	6127	# Colors
	6128	VecN = vecoln.split('@')[0]
	6129	if VecN == 'singlecol':
	6130	if veccolor == 'auto':
	6131	vcolor = "red"
	6132	else:
	6133	vcolor = veccolor
	6134	elif VecN == 'wind' or VecN == '3rdvar':
	6135	vcolor = vecoln.split('@')[1]
	6136
	6137	plt.rc('text', usetex=True)
	6138
	6139	if not mapv is None:
	6140	lon00 = np.where(xvals[:] < 0., 360. + xvals[:], xvals[:])
	6141	lat00 = yvals[:]
	6142
	6143	map_proj=mapv.split(',')[0]
	6144	map_res=mapv.split(',')[1]
	6145
	6146	nlon = np.min(xvals[::yfreq,::xfreq])
	6147	xlon = np.max(xvals[::yfreq,::xfreq])
	6148	nlat = np.min(yvals[::yfreq,::xfreq])
	6149	xlat = np.max(yvals[::yfreq,::xfreq])
	6150
	6151	lon2 = xvals[dy/2,dx/2]
	6152	lat2 = yvals[dy/2,dx/2]
	6153
	6154	print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:', \
	6155	xlon, ',', xlat
	6156
	6157	if map_proj == 'cyl':
	6158	m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat, \
	6159	urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	6160	elif map_proj == 'lcc':
	6161	m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
	6162	llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	6163	else:
	6164	print errormsg
	6165	print ' ' + fname + ": projection '" + map_proj + "' not ready!!"
	6166	print ' projections available: cyl, lcc'
	6167	quit(-1)
	6168
	6169	m.drawcoastlines()
	6170
	6171	meridians = pretty_int(nlon,xlon,5)
	6172	m.drawmeridians(meridians,labels=[True,False,False,True],color="black")
	6173
	6174	parallels = pretty_int(nlat,xlat,5)
	6175	m.drawparallels(parallels,labels=[False,True,True,False],color="black")
	6176
	6177	plt.xlabel('W-E')
	6178	plt.ylabel('S-N')
	6179
	6180	if VecN == 'singlecol':
	6181	plt.quiver(xvals[::yfreq,::xfreq], yvals[::yfreq,::xfreq], \
	6182	uvals[::yfreq,::xfreq], vvals[::yfreq,::xfreq], color=vcolor, pivot='middle')
	6183	plt.annotate(windn.replace('_','\_') +' (' + units_lunits(wuts) + ')', \
	6184	xy=(0.80,-0.15), xycoords='axes fraction', color=vcolor)
	6185	else:
	6186	if veclength != 'auto':
	6187	wind = np.sqrt(uvals2 + vvals2)
	6188	uvals = np.where(wind == 0., 0., uvals)
	6189	vvals = np.where(wind == 0., 0., vvals)
	6190	uvals = np.float(veclength)*uvals/wind
	6191	vvals = np.float(veclength)*vvals/wind
	6192
	6193	plt.quiver(xvals[::yfreq,::xfreq], yvals[::yfreq,::xfreq], \
	6194	uvals[::yfreq,::xfreq], vvals[::yfreq,::xfreq],
	6195	veccolor[::yfreq,::xfreq], cmap=plt.get_cmap(vcolor), pivot='middle')
	6196	cbar = plt.colorbar()
	6197
	6198	if VecN == 'wind':
	6199	cbar.set_label('$\sqrt{u^{2} + v^{2}}$ (' + units_lunits(wuts) + ')')
	6200	else:
	6201	vN = vecoln.split('@')[2]
	6202	vU = vecoln.split('@')[3]
	6203	cbar.set_label(vN + ' (' + units_lunits(vU) + ')')
	6204
	6205	plt.annotate(windn.replace('_','\_') +' (' + units_lunits(wuts) + ')', \
	6206	xy=(0.80,-0.15), xycoords='axes fraction', color='black')
	6207
	6208	plt.title(graphtit.replace('\|',' ').replace('&','\&'))
	6209
	6210	output_kind(kfig, figname, True)
	6211
	6212	return
	6213
[704]	6214	def plot_basins(xvals,yvals,fvals,vecfreq,vecoln,veccolor,veclength,windn,wuts,\
	6215	mapv,graphtit,kfig,figname):
	6216	""" Function to plot vectors
	6217	xvals= values for the x-axis
	6218	yvals= values for the y-axis
	6219	fvals= values for the flow (1-8: N, NE, E, ..., NW; 97: sub-basin; 98: small to sea; 99: large to sea)
	6220	vecfreq= [xfreq],[yfreq] frequency of values allong each axis (None, all grid points;
	6221	'auto', computed automatically to have 20 vectors along each axis)
	6222	veccoln= name for the color of the vectors (as '3rdvar@[basinsvar]@[varn]@[units]' from plot_vector)
	6223	veccolor= color of the vectors
	6224	veclength= length of the wind vectors:
	6225	'singlecol': 'auto', for 9
	6226	'wind' and '3rdvar': 'auto' length as wind speed, otherwise fix length
	6227	windn= name of the wind variable in the graph
	6228	wuts= units of the wind variable in the graph
	6229	mapv= map characteristics: [proj],[res]
	6230	see full documentation: http://matplotlib.org/basemap/
	6231	[proj]: projection
	6232	* 'cyl', cilindric
	6233	* 'lcc', lambert conformal
	6234	[res]: resolution:
	6235	* 'c', crude
	6236	* 'l', low
	6237	* 'i', intermediate
	6238	* 'h', high
	6239	* 'f', full
	6240	graphtit= title of the graph ('\|', for spaces)
	6241	kfig= kind of figure
	6242	figname= name of the figure
	6243	"""
	6244	fname = 'plot_basins'
	6245
	6246	dx=xvals.shape[1]
	6247	dy=xvals.shape[0]
	6248
	6249	# Frequency of vectors
	6250	if vecfreq is None:
	6251	xfreq = 1
	6252	yfreq = 1
	6253	elif vecfreq == 'auto':
	6254	xfreq = dx/20
	6255	yfreq = dy/20
	6256	else:
	6257	xfreq=int(vecfreq.split('@')[0])
	6258	yfreq=int(vecfreq.split('@')[1])
	6259
	6260	# Vector length
	6261	if veclength == 'auto':
	6262	vlength = 9
	6263	else:
	6264	vlength = veclength
	6265
	6266	# flow direction
	6267	angle = (fvals[::yfreq,::xfreq] - 1)*np.pi/4
	6268	uvals = np.where(fvals[::yfreq,::xfreq] < 9, np.float(veclength)*np.sin(angle), 0.)
	6269	vvals = np.where(fvals[::yfreq,::xfreq] < 9, np.float(veclength)*np.cos(angle), 0.)
	6270
	6271	# Colors
	6272	vcolor = vecoln.split('@')[0]
	6273
	6274	plt.rc('text', usetex=True)
	6275
	6276	ddx = np.abs(xvals[dy/2+1,dx/2] - xvals[dy/2,dx/2])
	6277	ddy = np.abs(yvals[dy/2,dx/2+1] - yvals[dy/2,dx/2])
	6278	fontcharac = {'family': 'serif', 'weight': 'normal', 'size': 3}
	6279
	6280	# Setting up colors for each label
	6281	# From: http://stackoverflow.com/questions/15235630/matplotlib-pick-up-one-color-associated-to-one-value-in-a-colorbar
	6282	my_cmap = plt.cm.get_cmap(vcolor)
	6283	vcolmin = np.min(veccolor[::yfreq,::xfreq])
	6284	vcolmax = np.max(veccolor[::yfreq,::xfreq])
	6285	vcolmin = 0.
	6286	vcolmax = 2500.
	6287	norm = mpl.colors.Normalize(vcolmin, vcolmax)
	6288	print 'min col:',vcolmin,'max col:',vcolmax
	6289
	6290	xlabpos = []
	6291	ylabpos = []
	6292	labels = []
	6293	labcol = []
	6294	flow = []
	6295	flowvals = []
	6296
	6297	for j in range(0,dy,yfreq):
	6298	for i in range(0,dx,xfreq):
	6299	if veccolor[j,i] != '--':
	6300	xlabpos.append(xvals[j,i])
	6301	ylabpos.append(yvals[j,i])
	6302	labels.append(int(veccolor[j,i]))
	6303	labcol.append(my_cmap(norm(veccolor[j,i])))
	6304	flowvals.append(fvals[j,i])
	6305
	6306	if not mapv is None:
	6307	lon00 = np.where(xvals[:] < 0., 360. + xvals[:], xvals[:])
	6308	lat00 = yvals[:]
	6309
	6310	map_proj=mapv.split(',')[0]
	6311	map_res=mapv.split(',')[1]
	6312
	6313	nlon = np.min(xvals[::yfreq,::xfreq])
	6314	xlon = np.max(xvals[::yfreq,::xfreq])
	6315	nlat = np.min(yvals[::yfreq,::xfreq])
	6316	xlat = np.max(yvals[::yfreq,::xfreq])
	6317
	6318	lon2 = xvals[dy/2,dx/2]
	6319	lat2 = yvals[dy/2,dx/2]
	6320
	6321	print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:', \
	6322	xlon, ',', xlat
	6323
	6324	if map_proj == 'cyl':
	6325	m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat, \
	6326	urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	6327	elif map_proj == 'lcc':
	6328	m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
	6329	llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	6330	else:
	6331	print errormsg
	6332	print ' ' + fname + ": projection '" + map_proj + "' not ready!!"
	6333	print ' projections available: cyl, lcc'
	6334	quit(-1)
	6335
	6336	m.drawcoastlines()
	6337
	6338	meridians = pretty_int(nlon,xlon,5)
	6339	m.drawmeridians(meridians,labels=[True,False,False,True],color="black")
	6340
	6341	parallels = pretty_int(nlat,xlat,5)
	6342	m.drawparallels(parallels,labels=[False,True,True,False],color="black")
	6343
	6344	plt.xlabel('W-E')
	6345	plt.ylabel('S-N')
	6346
	6347	if veclength != 'auto':
	6348	wind = np.sqrt(uvals2 + vvals2)
	6349	uvals = np.where(wind == 0., 0., uvals)
	6350	vvals = np.where(wind == 0., 0., vvals)
	6351	uvals = np.float(veclength)*uvals/wind
	6352	vvals = np.float(veclength)*vvals/wind
	6353
	6354	plt.quiver(xvals[::yfreq,::xfreq], yvals[::yfreq,::xfreq], \
	6355	uvals[::yfreq,::xfreq], vvals[::yfreq,::xfreq], veccolor[::yfreq,::xfreq], \
	6356	cmap=plt.get_cmap(vcolor), pivot='middle')
	6357	cbar = plt.colorbar()
	6358
	6359	vN = vecoln.split('@')[1]
	6360	vU = vecoln.split('@')[2]
	6361	cbar.set_label(vN + ' (' + units_lunits(vU) + ')')
	6362
	6363	for i in range(len(xlabpos)):
	6364	plt.text(xlabpos[i]+0.5ddx, ylabpos[i]+0.95ddy, labels[i], \
	6365	color=labcol[i], fontdict=fontcharac)
	6366
	6367	# Sea-flow
	6368	for i in range(len(xlabpos)):
	6369	if flowvals[i] == 97:
	6370	plt.plot(xlabpos[i], ylabpos[i], 'x', color=labcol[i])
	6371	elif flowvals[i] == 98:
	6372	plt.plot(xlabpos[i], ylabpos[i], '*', color=labcol[i])
	6373	elif flowvals[i] == 99:
	6374	plt.plot(xlabpos[i], ylabpos[i], 'h', color=labcol[i])
	6375
	6376	plt.annotate(windn.replace('_','\_') +' (' + units_lunits(wuts) + ')', \
	6377	xy=(0.80,-0.15), xycoords='axes fraction', color='black')
	6378
	6379	plt.title(graphtit.replace('\|',' ').replace('&','\&'))
	6380
	6381	output_kind(kfig, figname, True)
	6382
	6383	return
	6384
[698]	6385	def var_3desc(ovar):
	6386	""" Function to provide std_name, long_name and units from an object variable
	6387	ovar= object variable
	6388	"""
	6389	fname = 'var_desc'
	6390	varattrs = ovar.ncattrs()
	6391
	6392	if searchInlist(varattrs,'std_name'):
	6393	stdn = ovar.getncattr('std_name')
	6394	else:
	6395	vvalues = variables_values(ovar._name)
	6396	stdn = vvalues[1]
	6397
	6398	if searchInlist(varattrs,'long_name'):
	6399	lonn = ovar.getncattr('long_name')
	6400	else:
	6401	lonn = vvalues[4].replace('\|',' ')
	6402
	6403	if searchInlist(varattrs,'units'):
	6404	un = ovar.getncattr('units')
	6405	else:
	6406	un = vvalues[5]
	6407
	6408	return stdn, lonn, un
[705]	6409
	6410	def plot_river_desc(lons, lats, rns, rss, rus, ros, bcolor, ucolor, uuts, mapv, \
	6411	graphtit, kfig, lloc, figname):
	6412	""" Function to plot rivers from 'river_desc.nc' ORCDHIEE
	6413	lons= values for the x-axis
	6414	lats= values for the y-axis
	6415	rns= list of the name of the rivers to plot
	6416	rss= dictionary with the lon,lats of the subbasins of each river
	6417	rus= dictionary with the lon,lats of the upstream values of each river
	6418	ros= dictionary with the lon,lats of the outflow points of each river
	6419	bcolor= color of the lines for the subbasins
	6420	ucolor= bar color for the upstreams
	6421	uuts= units of the upstream
	6422	mapv= map characteristics: [proj],[res]
	6423	see full documentation: http://matplotlib.org/basemap/
	6424	[proj]: projection
	6425	* 'cyl', cilindric
	6426	* 'lcc', lambert conformal
	6427	[res]: resolution:
	6428	* 'c', crude
	6429	* 'l', low
	6430	* 'i', intermediate
	6431	* 'h', high
	6432	* 'f', full
	6433	graphtit= title of the graph ('\|', for spaces)
	6434	lloc= location of the legend (0, automatic)
	6435	1: 'upper right', 2: 'upper left', 3: 'lower left', 4: 'lower right',
	6436	5: 'right', 6: 'center left', 7: 'center right', 8: 'lower center',
	6437	9: 'upper center', 10: 'center' kfig= kind of figure
	6438	figname= name of the figure
	6439	"""
	6440	fname = 'plot_basins'
	6441
	6442	colvalues, linekinds, pointkinds, lwidths, psizes = ColorsLinesPointsStyles( \
	6443	len(rns), bcolor, ['-'], ['.'], [1.], [1.], None)
	6444
	6445	dx=lons.shape[1]
	6446	dy=lats.shape[0]
	6447
	6448	plt.rc('text', usetex=True)
	6449
	6450	nlon = np.min(lons)
	6451	xlon = np.max(lons)
	6452	nlat = np.min(lats)
	6453	xlat = np.max(lats)
	6454
	6455	dlon = xlon - nlon
	6456	dlat = xlat - nlat
	6457
	6458	# Making bigger the area to map
	6459	nlon = np.min(lons)-dlon*0.1
	6460	xlon = np.max(lons)+dlon*0.1
	6461	nlat = np.min(lats)-dlat*0.1
	6462	xlat = np.max(lats)+dlat*0.1
	6463
	6464	plt.xlim(nlon,xlon)
	6465	plt.ylim(nlat,xlat)
	6466
	6467	if not mapv is None:
	6468	lon00 = np.where(lons[:] < 0., 360. + lons[:], lons[:])
	6469	lat00 = lats[:]
	6470
	6471	map_proj=mapv.split(',')[0]
	6472	map_res=mapv.split(',')[1]
	6473
	6474	lon2 = (nlon + xlon)/2.
	6475	lat2 = (nlat + xlat)/2.
	6476
	6477	print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:', \
	6478	xlon, ',', xlat
	6479
	6480	if map_proj == 'cyl':
	6481	m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat, \
	6482	urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	6483	elif map_proj == 'lcc':
	6484	m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
	6485	llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
	6486	else:
	6487	print errormsg
	6488	print ' ' + fname + ": projection '" + map_proj + "' not ready!!"
	6489	print ' projections available: cyl, lcc'
	6490	quit(-1)
	6491
	6492	m.drawcoastlines()
	6493
	6494	meridians = pretty_int(nlon,xlon,5)
	6495	m.drawmeridians(meridians,labels=[True,False,False,True],color="black")
	6496
	6497	parallels = pretty_int(nlat,xlat,5)
	6498	m.drawparallels(parallels,labels=[False,True,True,False],color="black")
	6499
	6500	plt.xlabel('W-E')
	6501	plt.ylabel('S-N')
	6502
	6503	umin = 10.e20
	6504	umax = -umin
	6505	for rn in rns:
	6506	nrns = np.min(rus[rn])
	6507	xrns = np.max(rus[rn])
	6508
	6509	if umin > nrns: umin = nrns
	6510	if umax < xrns: umax = xrns
	6511
	6512	i = 0
	6513	for rn in rns:
	6514	plt.pcolormesh(lons, lats, rus[rn], vmin=umin, vmax=umax, \
	6515	cmap=plt.get_cmap(ucolor), norm=matplotlib.colors.LogNorm())
	6516	# plt.pcolormesh(lons, lats, rss[rn], cmap=plt.get_cmap(ucolor))
	6517	if rn == rns[0]: cbar = plt.colorbar()
	6518	riverarea = rss[rn]
	6519
	6520	riverarea.mask = ma.nomask
	6521	rarea = np.where(riverarea == 999999999, -5, riverarea)
	6522	rarea = np.where(rarea > 0, 1, 0)
	6523	plt.contour(lons, lats, rarea, levels = [0.], colors=colvalues[i], \
	6524	linewidths=1.5)
	6525
	6526	oflow = ros[rn]
	6527	plt.plot(oflow[0], oflow[1], 'h', color=colvalues[i], label=rn)
	6528	# plt.annotate(rn, xy=(0., i*0.05), xycoords='axes fraction', color=colvalues[i])
	6529	i = i+1
	6530
	6531
	6532	# Attempts to plot sub-basins
	6533
	6534	# Gradient subbasins (not working)
	6535	# gradriver = np.zeros((dy,dx), dtype=int)
	6536	# for j in range(dy-2):
	6537	# for i in range(dx-2):
	6538	# gradriver[j,i] = riverarea[j,i+1]-riverarea[j,i]+riverarea[j+1,i]- \
	6539	# riverarea[j,i]
	6540	# garea = np.where(gradriver != 0, 1, gradriver)
	6541	# print garea
	6542	# plt.contour(lons, lats, garea, levels = [0.], colors='red', linewidths=1.)
	6543
	6544	# Not working
	6545	# subbasins = np.sort(np.unique(rarea))
	6546	# for subb in subbasins:
	6547	# if subb > 0.:
	6548	# sarea = np.where(rarea != subb, 0, rarea)
	6549	# plt.contour(lons, lats, sarea, levels = [1.], colors='gray', linewidths=1.)
	6550
	6551	cbar.set_label('upstream (' + units_lunits(uuts) + ')')
	6552	plt.legend(loc=lloc)
	6553
	6554	# plt.annotate(windn.replace('_','\_') +' (' + units_lunits(wuts) + ')', \
	6555	# xy=(0.80,-0.15), xycoords='axes fraction', color='black')
	6556
	6557	plt.title(graphtit.replace('\|',' ').replace('&','\&'))
	6558
	6559	output_kind(kfig, figname, True)
	6560
	6561	return
	6562

Note: See TracBrowser for help on using the repository browser.

Download in other formats: