Context Navigation

source: lmdz_wrf/trunk/tools/model_graphics.py @ 1400

Last change on this file since 1400 was 1394, checked in by lfita, 8 years ago

Adding a try:except pair for `ivarattrs'
Adding (when possible)

if [debug/db]: print " End of '" + fname + "' "

File size: 215.9 KB

Line
1	# Python script to generate the files and the plots for a sensitivity study with multiple modle configurations and models
2	# L. Fita
3	# LMD, Jussieu/Palaisseau, France
4	# Script configuration get from ASCII file 'model_graphics.dat'
5
6	# `Wheeler-Kiladis' diagram: https://github.com/UV-CDAT/wk
7	# $ cd /home/lluis/Downloads
8	# $ git clone https://github.com/UV-CDAT/wk
9	# $ cd wk
10	# $ su
11	# # python setup.py build >& run_pysetup.log
12	# # python setup.py install >& run_pyinstall.log
13
14	import numpy as np
15	import nc_var_tools as ncvar
16	import generic_tools as gen
17	import drawing_tools as drw
18	import time as tim
19	# To avoid errors like: '/bin/sh: 1: Syntax error: Bad fd number'
20	# Make sure that /bin/sh directs to bash and not to dash:
21	# http://stackoverflow.com/questions/15809060/sh-syntax-error-bad-fd-number
22	import subprocess as sub
23	import os
24
25	main = 'model_graphics.py'
26
27	errmsg = ncvar.errormsg
28	warnmsg = ncvar.warnmsg
29
30	def verify_configuration(ExpConf, debug):
31	""" Function to verify mandatory keys from experiment configuration
32	ExpConf= dictionary with the configuration
33	"""
34	fname = 'verify_configuration'
35
36	# List with the mandatory keys
37	mandatorykeys = ['pyHOME', 'cdoHOME', 'scratch', 'filescratch', 'figscratch', \
38	'diffscratch', 'figdiffscratch', 'figallmodexpscratch', 'addfiles', \
39	'addfigures', 'adddiffs', 'adddifffigures', 'addallmodexpfigures', 'debug', \
40	'models', 'modgraphchar', 'expgraphchar', 'ifold', 'ofold', 'warnmsg', \
41	'errmsg', 'titleoperations', 'kindfig', 'CFreftime', 'CFunitstime', 'mapval', \
42	'timekind', 'timefmt', 'timelabel' ]
43
44	# List with the optional keys
45	optionalkeys = ['specificvarplot', 'specificdiffopplot', 'specificdiffvarplot', \
46	'RefProj']
47
48	# Dictionary with the mandatory keys which are required as function of a given
49	# key from the dictionary
50	# if [key] must exist [keyB] = [values]
51	ifkeys = {'WRFexps': ['models','WRF'], 'LMDZexps': ['models','LMDZ'], \
52	'WRF_LMDZexps': ['models','WRF_LMDZ'], 'DYNAMICOexps': ['models','DYNAMICO'], \
53	'WRFheaders': ['models','WRF'], 'WRF_LMDZheaders': ['models','WRF_LMDZ'], \
54	'LMDZheaders': ['models','LMDZ'], 'DYNAMICOheaders': ['models','DYNAMICO']}
55
56	# Dictionary with the optional keys (at least one) which are required as function
57	# of a given key from the dictionary
58	# if [key] must exist at least one of the [keyA, keyB, keyC, ...] with values
59	ifopkeys = {'RefProj': ['reprojectvar_remapbil', 'reprojectvar_remapbic', \
60	'reprojectvar_remapdis', 'reprojectvar_remapnn', 'reprojectvar_remapcon', \
61	'reprojectvar_remapcon2', 'reprojectvar_remaplaf', 'reprojectvar_dis', \
62	'reprojecvar_dis']}
63
64	for kdict in mandatorykeys:
65	if not ExpConf.has_key(kdict):
66	print errmsg
67	print ' ' + fname + "' configuration without required '" + kdict + "' !!"
68	quit(-1)
69	if debug:
70	print ExpConf[kdict]
71
72	for kdict in ifkeys.keys():
73	vals = ifkeys[kdict]
74	keyn = vals[0]
75	keyv = vals[1]
76	if type(ExpConf[keyn]) == type('A'):
77	if not ExpConf.has_key(kdict) and ExpConf[keyn] == keyv:
78	print errmsg
79	print ' ' + fname + "' configuration without '" + kdict + \
80	"' when it is required with configuration '" + keyn + '=' + keyv + \
81	"' !!"
82	quit(-1)
83	elif type(ExpConf[keyn]) == type(['A', 'B']):
84	keyvals = ExpConf[keyn]
85	if not ExpConf.has_key(kdict) and gen.searchInlist(keyvals, keyv):
86	print errmsg
87	print ' ' + fname + "' configuration without '" + kdict + \
88	"' when it is required with configuration '" + keyn + '= [..., ' + \
89	keyv + ", ...]' !!"
90	quit(-1)
91	else:
92	print errmsg
93	print ' ' +fname+ 'dictionary type ', type(ExpConf[keyn]), ' not ready!!'
94	quit(-1)
95	if debug:
96	print ' Experiments configuration _______'
97	gen.printing_dictionary(ExpConf)
98
99	for kdict in ifopkeys.keys():
100	if ExpConf.has_key(kdict):
101	opkeys = ifopkeys[kdict]
102	hasopkey = False
103	opdictvals = {}
104	for opkv in opkeys:
105	if ExpConf.has_key(opkv):
106	hasopkey = True
107	opdictvals[opkv] = ExpConf[opkv]
108
109	if not hasopkey:
110	print errmsg
111	print ' ' + fname + "' configuration wit '" + kdict + "' but " + \
112	"without any key value:", opkeys, "' when it is required !!"
113	quit(-1)
114
115	if debug:
116	print " Optional key '" + kdict + "' with values ________"
117	gen.printing_dictionary(opdictvals)
118
119	print fname + ': configuration seems to be fine'
120
121	return
122
123	def scratches(config):
124	""" Function to set-up if it is needed to start from the scratch
125	config: dictionary with the configuration
126	"""
127	fname = 'scratches'
128
129	if gen.Str_Bool(config['scratch']):
130	scr = True
131	print warnmsg
132	print " " + fname + ": starting from the SCRATCH !!"
133	print " 10 seconds left!!"
134	filescr = True
135	figscr = True
136	difscr = True
137	figdifscr = True
138	moddifscr = True
139	figmoddifscr = True
140	figallmodexpscr = True
141	tim.sleep(10)
142	else:
143	scr = False
144	if gen.Str_Bool(config['filescratch']):
145	filescr = True
146	print warnmsg
147	print " " + main + ": files starting from the SCRATCH !!"
148	print " 5 seconds left!!"
149	tim.sleep(5)
150	else:
151	filescr = False
152
153	if gen.Str_Bool(config['figscratch']):
154	figscr = True
155	print warnmsg
156	print " " + main + ": figures starting from the SCRATCH !!"
157	print " 5 seconds left!!"
158	tim.sleep(5)
159	else:
160	figscr = False
161
162	if gen.Str_Bool(config['diffscratch']):
163	difscr = True
164	print warnmsg
165	print " " + main + ": experiment differences starting from the SCRATCH !!"
166	print " 5 seconds left!!"
167	tim.sleep(5)
168	else:
169	difscr = False
170
171	if gen.Str_Bool(config['figdiffscratch']):
172	figdifscr = True
173	print warnmsg
174	print " " + main + ": figures experiment differences starting from the SCRATCH !!"
175	print " 5 seconds left!!"
176	tim.sleep(5)
177	else:
178	figdifscr = False
179
180	if gen.Str_Bool(config['moddiffscratch']):
181	moddifscr = True
182	print warnmsg
183	print " " + main + ": model differences starting from the SCRATCH !!"
184	print " 5 seconds left!!"
185	tim.sleep(5)
186	else:
187	moddifscr = False
188
189	if gen.Str_Bool(config['figmoddiffscratch']):
190	figmoddifscr = True
191	print warnmsg
192	print " " + main + ": figures model differences starting from the SCRATCH !!"
193	print " 5 seconds left!!"
194	tim.sleep(5)
195	else:
196	figmoddifscr = False
197
198	if gen.Str_Bool(config['figallmodexpscratch']):
199	figallmodexpscr = True
200	print warnmsg
201	print " " + main + ": figures all model-experiment starting from the SCRATCH !!"
202	print " 5 seconds left!!"
203	tim.sleep(5)
204	else:
205	figallmodexpscr = False
206
207	if gen.Str_Bool(config['addall']):
208	print warnmsg
209	print " " + fname + ": adding new values everywhere !!"
210	addfils = True
211	addfigs = True
212	adddiffs = True
213	adddifffigs = True
214	addmoddiffs = True
215	addmoddifffigs = True
216	addallmodexpfigs = True
217	else:
218	addfils = gen.Str_Bool(config['addfiles'])
219	addfigs = gen.Str_Bool(config['addfigures'])
220	adddiffs = gen.Str_Bool(config['adddiffs'])
221	adddifffigs = gen.Str_Bool(config['adddifffigures'])
222	addmoddiffs = gen.Str_Bool(config['addmoddiffs'])
223	addmoddifffigs = gen.Str_Bool(config['addmoddifffigures'])
224	addallmodexpfigs = gen.Str_Bool(config['addallmodexpfigures'])
225
226	debug = gen.Str_Bool(config['debug'])
227
228	return scr, filescr, figscr, difscr, figdifscr, moddifscr, figmoddifscr, \
229	figallmodexpscr, addfils, addfigs, adddiffs, adddifffigs, addmoddiffs, \
230	addmoddifffigs, addallmodexpfigs, debug
231
232
233	class gc(object):
234	""" Class which holds all the graphical characteristics
235	[label]: label as it should appear in the graphics
236	[color]: specific color of the model
237	[linetype]: specific type of line of the model
238	[marker]: specific marker of the model
239	[sizes]: line width and point size for the model
240	[tmod]: time modification to apply to the model files (None for nothing)
241	'setorigin',[YYYYMMDDHHMISS]: re-set origin of times at [YYYYMMDDHHMISS]
242	"""
243	def __init__( self, label, color, linetype, marker, sizes, Tmod):
244	self.label = None
245	self.color = None
246	self.linetype = None
247	self.marker = None
248	self.sizes = None
249	self.tmod = None
250	if label is not None:
251	self.label = label
252	self.color = color
253	self.linetype = linetype
254	self.marker = marker
255	self.sizes = sizes
256	if Tmod != 'None':
257	self.tmod = Tmod
258
259	def graphical_characteristics(config, debug):
260	""" Function to provide the graphical characteristics of models and experiments
261	config= configuration of the experiment
262	"""
263	fname = 'graphical_characteristics'
264
265	modgraphchar = {}
266	modvals = config['modgraphchar'].split(':')
267	for modval in modvals:
268	modv = modval.split('\|')
269	modgraphchar[modv[0]] = gc(modv[1], modv[2], modv[3], modv[4], modv[5], modv[6])
270
271	expgraphchar = {}
272	expvals = config['expgraphchar'].split(':')
273	for expval in expvals:
274	expvs = expval.split('\|')
275	modexp = expvs[0] + '/' + expvs[1]
276	if not modgraphchar.has_key(expvs[0]):
277	print errmsg
278	print ' ' + fname + ": a model called '" +expvs[0]+ "' does not exist !!"
279	print ' existing models with graphic characteristics:', \
280	modgraphchar.keys()
281	quit(-1)
282
283	modvs = modgraphchar[expvs[0]]
284	expv = expvs[2:7]
285	if expv[1] == 'asmodel': expv[1] = modvs.color
286	if expv[2] == 'asmodel': expv[2] = modvs.linetype
287	if expv[3] == 'asmodel': expv[3] = modvs.marker
288	if expv[4] == 'asmodel': expv[4] = modvs.sizes
289
290	expgraphchar[modexp] = gc(expv[0], expv[1], expv[2], expv[3], expv[4], 'None')
291
292	# Running some tests
293	mods = config['models'].split(':')
294	for mod in mods:
295	if not modgraphchar.has_key(mod):
296	print errmsg
297	print ' ' + fname + ": model called '" + mod + "' does not have " + \
298	"graphical characteristics !!"
299	print ' existing models with graphic characteristics:', \
300	modgraphchar.keys()
301	quit(-1)
302
303	exps = config[mod + 'exps'].split(':')
304	for exp in exps:
305	modexp = mod + '/' + exp
306	if not expgraphchar.has_key(modexp):
307	print errmsg
308	print ' ' + fname + ": model/experiment called '" + modexp + \
309	"' does not have graphical characteristics !!"
310	print ' existing model/experiments with graphic ' + \
311	'characteristics:', expgraphchar.keys()
312	quit(-1)
313
314	if debug:
315	print ' ' + fname + ': model graphical characteristics _______'
316	for modn in modgraphchar.keys():
317	with gen.Capturing() as output:
318	gen.printing_class(modgraphchar[modn])
319	print "'" + modn + "'; " + ', '.join(output)
320	print ' ' + fname + ': experiment graphical characteristics _______'
321	for modexpn in expgraphchar.keys():
322	with gen.Capturing() as output:
323	gen.printing_class(expgraphchar[modexpn])
324	print "'" + modexpn + "'; " + ', '.join(output)
325
326	if debug: print " End of '" + fname + "' "
327
328	return modgraphchar, expgraphchar
329
330	def exp_headers(mod,config):
331	""" Function to provide the headers and the experiments of a given model
332	model= model
333	config= configuration of the experiment
334	"""
335	fname = 'exp_headers'
336
337	# No CASE in python!
338	# case ${mod} in ...
339	if mod == 'WRF':
340	expers = config['WRFexps'].split(':')
341	fhs = config['WRFheaders'].split(':')
342	elif mod == 'LMDZ':
343	expers = config['LMDZexps'].split(':')
344	fhs = config['LMDZheaders'].split(':')
345	elif mod == 'WRF_LMDZ':
346	expers = config['WRF_LMDZexps'].split(':')
347	fhs = config['WRF_LMDZheaders'].split(':')
348	elif mod == 'DYNAMICO':
349	expers = config['DYNAMICOexps'].split(':')
350	fhs = config['DYNAMICOheaders'].split(':')
351	else:
352	print errmsg
353	print " " + fname + ": model '" + mod + "' not ready!!"
354	quit(-1)
355
356	return expers, fhs
357
358	class VariableInf(object):
359	""" Class which holds all information of a given variable
360	name= CF name of the variabgle
361	header= header of the file from which it can be computed
362	model= file-header variable from which it can be directly computed
363	diag= file-header diagnostics from which it can be computed
364	"""
365	def __init__( self, name, fheader, model, diag):
366	self.name= None
367	self.fheader= None
368	self.model= None
369	self.diag= None
370	if name is not None:
371	self.name = name
372	self.fheader= fheader
373	self.model= model
374	self.diag= diag
375
376	class ModelInf(object):
377	""" Class which holds all information from a given model
378	name= Acronym of the model
379	model= Long description of the model
380	dim[x/y/z/t/s]n= name of the dimensions of the model
381	vdim[x/y/z/t/s]n= name of the variable-dimensions of the model
382	dimensions= list of the dimensions
383	vardimensions= list of the variable-dimensions
384	timemodif= time modification to apply to the model files ('None' for nothing)
385	'setorigin',[YYYYMMDDHHMISS]: re-set origin of times at [YYYYMMDDHHMISS]
386	"""
387	def __init__( self, name, model, dx, dy, dz, dt, ds, vdx, vdy, vdz, vdt, vds, \
388	tmod):
389	self.name= None
390	self.model= None
391	self.dimxn= None
392	self.dimyn= None
393	self.dimzn= None
394	self.dimtn= None
395	self.dimsn= None
396	self.vardxn= None
397	self.vardyn= None
398	self.vardzn= None
399	self.vardtn= None
400	self.vardsn= None
401	self.timemodif = None
402	if name is not None:
403	self.name = name
404	self.model= model
405	self.dimxn= dx
406	self.dimyn= dy
407	self.dimzn= dz
408	self.dimtn= dt
409	self.dimsn= ds
410	self.vardxn= vdx
411	self.vardyn= vdy
412	self.vardzn= vdz
413	self.vardtn= vdt
414	self.vardsn= vds
415	if tmod is not None:
416	self.timemodif = tmod
417	self.dimensions = [dx, dy, dz, dt, ds]
418	self.vardimensions = [vdx, vdy, vdz, vdt, vds]
419
420	def variable_compute(idir,var,ftests,db):
421	""" Function to retrieve the computation way of a given variable using a series of test files
422	iwdir= directory with the test files
423	var= name of the variable to test
424	filtests= dictionary with the test files for each header
425	"""
426	fname='variable_compute'
427
428	cancompute = True
429	for headerf in ftests.keys():
430	filen=ftests[headerf]
431	try:
432	with gen.Capturing() as output:
433	vmod, vdiag = ncvar.computevar_model(var, idir + '/' + filen)
434	except:
435	print errmsg
436	print 'ncvar.computevar_model(' + var + ', ' + idir + '/' + filen + ')'
437	for s1out in output: print s1out
438	quit(-1)
439
440	if vmod is None and vdiag is None:
441	cancompute = False
442	else:
443	cancompute = True
444	# Should be considered that variable can also be computed by both ways?
445	break
446
447	if not cancompute:
448	print warnmsg
449	print ' ' + fname + ": there is no way to compute '" + var + \
450	"' for model '" + mod
451	# Too extrict!
452	# quit(-1)
453
454	# Getting only the first possibility of model and diagnostic
455	if vmod is not None:
456	modV = vmod[0]
457	else:
458	modV = None
459	if vdiag is not None:
460	diagV = vdiag[0]
461	else:
462	diagV = None
463
464	varcomp = VariableInf(var, headerf, modV, diagV)
465
466	# a ';' list 'varcompute' it is created for each variable giving:
467	# [var]\|[vark]\|[headerf][varmod]\|[vardiag]
468	# This list will be used to compute a new file for each variable
469
470	if db:
471	print 'Variable information _______'
472	gen.printing_class(varcomp)
473
474	if db: print " End of '" + fname + "' "
475
476	return varcomp
477
478	def get_operations_var(vc,db):
479	""" Function to provide the operations to make for each variable from 'VAR_' dictionary
480	vc= 'VAR_' dictionary, dictionary with all the parameters started with 'VAR_'
481	"""
482	fname = 'get_operations_var'
483
484	LH = len('VAR_')
485	iop = 1
486	# list of operations
487	doopers = {}
488	# operations by variable
489	operationsvar = {}
490	# individual operations by variable (not repeated)
491	indivoperationsvar = {}
492
493	# Variables with a calculation whic requires vertical interpolation to all the
494	# file (operations stating by 'VAR_pinterp')
495	LVp = len('VAR_pinterp')
496	varglobalp = []
497
498	for oper in vc.keys():
499	Loper = len(oper)
500	opn = oper[LH:Loper+1]
501	vns = vc[oper].split(':')
502	ops1 = opn.split('+')
503	doopers[opn] = ops1
504	for vn in vns:
505	if not operationsvar.has_key(vn):
506	operationsvar[vn] = [opn]
507	indivoperationsvar[vn] = ops1
508	else:
509	opers = operationsvar[vn]
510	opers.append(opn)
511	operationsvar[vn] = opers
512	opers1 = indivoperationsvar[vn]
513	for op1 in ops1:
514	if not gen.searchInlist(opers1, op1):
515	opers1.append(op1)
516	indivoperationsvar[vn] = opers1
517
518	if oper[0:LVp] == 'VAR_pinterp':
519	for vn in vns:
520	if not gen.searchInlist(varglobalp,vn): varglobalp.append(vn)
521
522	iop = iop + 1
523
524	if db:
525	print ' operations to make _______'
526	gen.printing_dictionary(doopers)
527	print ' operations by variable _______'
528	gen.printing_dictionary(operationsvar)
529	print ' individual operations by variable _______'
530	gen.printing_dictionary(indivoperationsvar)
531	print ' variables with the vertical interpolation for all the file _______'
532	print ' #', varglobalp
533
534	if db: print " End of '" + fname + "' "
535
536	return doopers, operationsvar, indivoperationsvar, varglobalp
537
538	def pinterp_var(oper):
539	""" Function to retrieve characteristics of the vertical interpolation for the operation
540	oper= operation
541	Wether vertical interpolation is:
542	# 'global': for all file
543	# 'local': at a given step of the process
544	# 'none': no vertical interpolation
545	>>> pinterp_var('last+pinterp+xmean')
546	local
547	>>> pinterp_var('pinterp+tmean+xmean')
548	global
549	>>> pinterp_var('xmean')
550	none
551	"""
552	fname = 'pinterp_var'
553
554	pinn = 'pinterp'
555
556	Lpinterp = len(pinn)
557	if oper[0:Lpinterp] == pinn:
558	pkind = 'global'
559	return pkind
560
561	if oper.find(pinn) != -1:
562	pkind = 'local'
563	else:
564	pkind = 'none'
565
566	return pkind
567
568	def compvars_listconstruct(config, minf, Files, TestFiles, idir, odir, debug):
569	""" Function to construct the list of variables to compute
570	config= dictionary with the configuration of the execution
571	variables to compute are get with all values started by `VAR_' in 'module_graphics.dat', and then
572	providing a consecutive number of calculations separated by '+'
573	VAR_[calc1]+[calc2] = tas:wss
574	will compute first [calc1] and then [calc2] for 'tas' and 'wss'
575	minf= class with information about the model
576	Files= dictionary of files for heach header
577	TestFiles= dictionary of files to test how to compute the variable
578	odir= output directory
579	"""
580	fname='compvars_listconstruct'
581
582	varcomp = gen.get_specdictionary_HMT(config,H='VAR_')
583
584	if debug:
585	print ' variables to compute ________'
586	gen.printing_dictionary(varcomp)
587
588	# Getting operations by variable
589	opers, varoper, indivaroper, varglobp = get_operations_var(varcomp,debug)
590
591	strfiles = gen.dictKeysVals_stringList(Files)
592	strtestfiles = gen.dictKeysVals_stringList(TestFiles)
593
594	Svarcompute = ''
595
596	# Main dictionary with all the variables and their calculation
597	allvarcomp = {}
598
599	ivop = 0
600	for vn in varoper:
601	vcomp = variable_compute(idir,vn,TestFiles,False)
602	for op in varoper[vn]:
603	# Creation of a String as: [CFname]\|[operation]\|[fheader]\|[vmodel]\|[vdiag]\|[globalP]
604	# [CFname]: CF-name of the variable (must appear in 'variables_values.dat')
605	# [operation]: operation to compute
606	# [fheader]: header of file with the required variables
607	# [vmodel]: Variable from model output
608	# [vdiag]: Varible as diagnostic from different variables of the model output
609	# [globalP]: Wether vertical interpolation is:
610	# 'global': for all file
611	# 'local': at a given step of the process
612	# 'none': no vertical interpolation
613	globalP = pinterp_var(op)
614	if vcomp.model is not None:
615	if type(vcomp.model) == type(list([1, 2])):
616	Smodel = ':'.join(vcomp.model)
617	elif type(vcomp.model) == type('A'):
618	Smodel = vcomp.model
619	else:
620	Smodel = 'None'
621	if vcomp.diag is not None:
622	if type(vcomp.diag) == type(list([1, 2])):
623	Sdiag = ':'.join(vcomp.diag)
624	elif type(vcomp.diag) == type('A'):
625	Sdiag = vcomp.diag
626	else:
627	Sdiag = 'None'
628
629	# To get a combination of operations, all the precedent steps are kept
630	# thus, they are also available !
631	seqops = op.split('+')
632	for seqop in seqops:
633	if seqop == seqops[0]: seqopS=seqop
634	else: seqopS = seqopS + '+' + seqop
635	allvarcomp[vn+'_'+seqopS] = [vcomp.fheader, vcomp.model, vcomp.diag, \
636	globalP]
637
638	Svc = vcomp.name + '\|' + seqopS + '\|' + vcomp.fheader + '\|' + \
639	Smodel + '\|' + Sdiag + '\|' + globalP
640	if ivop == 0:
641	Svarcompute = Svc
642	else:
643	Svarcompute = Svarcompute + ',' + Svc
644
645	ivop = ivop + 1
646
647	if debug:
648	print ' Variables to compute _______'
649	gen.printing_dictionary(allvarcomp)
650
651	# Outwritting the varcompute to avoid next time (if it is not filescratch!)
652	objf = open(odir + '/varcompute.inf', 'w')
653	objf.write('files: ' + strfiles + '\n')
654	objf.write('testfiles: ' + strtestfiles + '\n')
655	objf.write('varcompute: ' + Svarcompute + '\n')
656	objf.write('itotv: ' + str(ivop) + '\n')
657	objf.close()
658
659	if debug: print " End of '" + fname + "' "
660
661	return allvarcomp, ivop
662
663	def read_varcomp_file(filen):
664	""" Function to read 'varcompute.inf' and reconstruct the dictionaries
665	"""
666	fname = 'read_varcomp_file'
667
668	allvarcomp = {}
669
670	objf = open(filen, 'r')
671
672	for line in objf:
673	vals = line.replace('\n','').split(' ')
674	if vals[0] == 'files:':
675	Files = gen.stringList_dictKeysVals(vals[1])
676	elif vals[0] == 'testfiles:':
677	TestFiles = gen.stringList_dictKeysVals(vals[1])
678	elif vals[0] == 'varcompute:':
679	for VvalsS in vals[1].split(','):
680
681	Vvals = VvalsS.split('\|')
682	if Vvals[3] == 'None':
683	mod = None
684	else:
685	mod = Vvals[3].split(':')
686	if Vvals[4] == 'None':
687	diag = None
688	else:
689	diag = Vvals[4].split(':')
690
691	allvarcomp[Vvals[0]+'_'+Vvals[1]] = [Vvals[2], mod, diag, Vvals[5]]
692
693	# # To get a combination of operations, all the precedent steps are kept
694	# # thus, they are also available !
695	# seqops = Vvals[1].split('+')
696	# for seqop in seqops:
697	# if seqop == seqops[0]: seqopS=seqop
698	# else: seqopS = seqopS + '+' + seqop
699	# allvarcomp[Vvals[0]+'_'+seqopS] = [Vvals[2], mod, diag, Vvals[5]]
700	elif vals[0] == 'itotv:':
701	ivop = int(vals[1])
702
703	objf.close()
704
705	return Files, TestFiles, allvarcomp, ivop
706
707	def pinterpS(gP):
708	""" For that variables which require vertical interpolation 'p' suffix to the file header is added
709	gP= kind of pinterp: 'global', 'local', 'none'
710	"""
711	fname = 'pinterpS'
712
713	if gP != 'none':
714	gPS = 'p'
715	else:
716	gPS = ''
717
718	return gPS
719
720	def compute_variable(minf, idir, usefiles, odir, cvar, gP, scr, pyH, Tref, Tunits, db):
721	""" Function to compute a variable
722	minf= class with the information of the model
723	idir= directory with the input files
724	usefiles= dictionary of files as dict([headerf]) = [file1], ..., [fileN]
725	odir= directory to write the output files
726	cvar= class with the information of the variable: 'name', 'fheader', 'varmod', 'vardiag'
727	gP= kind of vertical interpolation ('global', 'local', 'none')
728	scr= should it be done from the scratch?
729	pyH= location of the python HOME
730	Tref= CF time reference
731	Tunits= CF time units
732	"""
733	fname='compute_variable'
734
735	CFvarn=cvar.name
736	headerf = cvar.fheader
737	modvar = cvar.model
738	diagvar = cvar.diag
739
740	cfiles = usefiles[headerf]
741
742	# dimensions
743	dnx = minf.dimxn
744	dny = minf.dimyn
745	# var-dimensions
746	vdnx = minf.vardxn
747	vdny = minf.vardyn
748
749	# Computing separately and then joinging for all files
750	Ntotfiles = len(cfiles)
751	Nzeros = len(str(Ntotfiles))
752	NStot = str(Ntotfiles).zfill(Nzeros)
753	# For that variables which require vertical interpolation 'p' suffix to the
754	# file header is added
755	SgP = pinterpS(gP)
756
757	# Getting in working dir
758	os.chdir(odir)
759
760	# File to keep track of all operations
761	otrackf = open( odir + '/all_computevars.inf', 'a')
762
763	# Computing variable
764	ifile=1
765	for cf in cfiles:
766	ifS = str(ifile).zfill(Nzeros)
767	ifilen = odir + '/' + CFvarn + '_' + headerf + SgP + '_' + ifS + '-' + \
768	NStot + '.nc'
769	fileon = odir + '/' + CFvarn + '_' + headerf + SgP + '.nc'
770
771	if scr:
772	sout = sub.call('rm ' + ifilen + ' >& /dev/null', shell=True)
773	sout = sub.call('rm ' + fileon + ' >& /dev/null', shell=True)
774
775	if not os.path.isfile(ifilen) and not os.path.isfile(fileon):
776	# Since model direct values are retrieved from `variables_valules.dat' which was
777	# initially coincived as a way to only give variable attributes, range and color
778	# bars, if a variable has a diagnostic way to be computed, the later one will be
779	# preferred
780	if db:
781	print ' ' + fname + ": creation of variable file '" + CFvarn + \
782	"' in file '" + ifilen + "' ..."
783	print ' model variable:', modvar
784	print ' diagostic variable:', diagvar
785
786	if diagvar is None:
787	# model variable
788	if db: print ' '+fname+ ": variable direct from model '" +modvar+ "'"
789	values = modvar + ',0,-1,-1'
790	vs = modvar + ',' + vdnx + ',' + vdny + ',' + vdnz + ',' + vdnt
791
792	try:
793	with gen.Capturing() as output:
794	ncvar.DataSetSection_multivars(values, idir + '/' + cf, vs)
795	except:
796	print errmsg
797	print 'ncvar.DataSetSection_multivars('+values+', '+idir+'/'+cf+ \
798	', '+vs+')'
799	for s1out in output: print s1out
800	quit(-1)
801
802	newfile, loc = gen.search_sec_list(output,'succesfull')
803	ofile = newfile[0].split(' ')[7]
804	sub.call('mv ' + ofile + ' ' + ifilen, shell=True)
805
806	# Keeping track of the operations
807	pyins = pyH + "/nc_var.py -f " + idir + '/' + cf + \
808	" -o DataSetSection_multivars -v " + vs + " -S '" + values + "'"
809	otrackf.write('\n')
810	otrackf.write('# ' + CFvarn + " " + modvar + '\n')
811	otrackf.write('python ' + pyins + '\n')
812
813	# CF renaming of variable
814	ncvar.chvarname(CFvarn,ifilen,modvar)
815	else:
816	# diagnostic variable
817	if db: print ' '+fname+ ": variable as diagnostic '" +diagvar[0]+ "'"
818	dims = dnt+'@'+vdnt+','+dnz+'@'+vdnz+','+dny+'@'+vdny+','+dnx+'@'+vdnx
819	diagn = diagvar[0]
820	Ndiagvars = len(diagvar)
821	diagc = '@'.join(diagvar[1:])
822
823	values = '-f ' + idir + '/' + cf + " -d '" + dims + "' -v '" + \
824	diagn + '\|' + diagc + "'"
825	try:
826	with gen.Capturing() as output:
827	sout = sub.call('python ' +pyH+ '/diagnostics.py ' + values, \
828	shell=True)
829	except:
830	print errmsg
831	print 'python ' + pyH + '/diagnostics.py ' + values
832	for s1out in output: print s1out
833	quit(-1)
834	if db:
835	for s1out in output: print s1out
836
837	sout = sub.call(' mv diagnostics.nc ' + ifilen, shell=True)
838
839	# Keeping track of the operations
840	pyins = 'python ' + pyH + '/diagnostics.py ' + values
841	otrackf.write('\n')
842	otrackf.write('# ' + CFvarn + " " + diagn + '\n')
843	otrackf.write(pyins + '\n')
844
845	# Attaching necessary variables for the pressure interpolation
846	if gP != 'none':
847	if minf.name == 'WRF' or minf.name == 'WRF_LMDZ':
848	requiredinterpvars = ['P', 'PB', 'PSFC', 'PH', 'PHB', 'HGT', 'T',\
849	'QVAPOR', 'XLONG', 'XLAT', 'Times']
850	elif minf.name == 'LMDZ':
851	requiredinterpvars = ['pres', 'psol', 'geop', 'phis', 'temp', \
852	'ovap', 'lon', 'lat', 'time_counter']
853	elif minf.name == 'DYNAMICO':
854	requiredinterpvars = ['pres', 'psol', 'geop', 'phis', 'temp', \
855	'ovap', 'lon', 'lat', 'time_counter']
856	else:
857	print errmsg
858	print fname + ": for model '" + minf.name + "' required " + \
859	" variables for vertical interpolation are not known !!"
860	quit(-1)
861
862	print " " + fname + ": adding variables:", requiredinterpvars, \
863	' to allow pressure interpolation'
864	for rqv in requiredinterpvars:
865	try:
866	with gen.Capturing() as output:
867	ncvar.fvaradd(idir+'/'+cf+','+rqv,ifilen)
868	except:
869	print errmsg
870	print 'fvaradd('+idir+'/'+cf+','+rqv+', '+ifilen+')'
871	for s1out in output: print s1out
872	quit(-1)
873	if db:
874	for s1out in output: print s1out
875
876	# CFification of files
877	if minf.name == 'WRF' or minf.name == 'WRF_LMDZ':
878	values = vdnx + ':' + vdny + ':'+ Tref + ':' + Tunits
879	try:
880	with gen.Capturing() as output:
881	ncvar.WRF_toCF(values, ifilen)
882	except:
883	print errmsg
884	print 'WRF_toCF('+ values +', ' + ifilen + ')'
885	for s1out in output: print s1out
886	# Removing file in order to make sure that it will be redone
887	print ' ' + fname + " removing file '" + ifilen + "' ..."
888	sub.call('rm ' + ifilen + ' >& /dev/null', shell=True)
889	quit(-1)
890	if db:
891	for s1out in output: print s1out
892	elif minf.name == 'LMDZ':
893	try:
894	with gen.Capturing() as output:
895	ncvar.LMDZ_toCF(Tunits + '!since!' + Tref, ifilen)
896	except:
897	print errmsg
898	print 'LMDZ_toCF('+ Tunits +'!since!'+ Tref + ', ' + ifilen + ')'
899	for s1out in output: print s1out
900	# Removing file in order to make sure that it will be redone
901	print ' ' + fname + " removing file '" + ifilen + "' ..."
902	sub.call('rm ' + ifilen + ' >& /dev/null', shell=True)
903	quit(-1)
904	if db:
905	for s1out in output: print s1out
906	# At this stage, let's be simple. It might be necessary to complicate it! Since
907	# DYNAMICO might have 'time_counter' or 'time_instant'
908	elif minf.name == 'DYNAMICO':
909	try:
910	with gen.Capturing() as output:
911	ncvar.DYNAMICO_toCF(Tunits + '!since!' + Tref, ifilen)
912	except:
913	print errmsg
914	print 'DYNAMICO_toCF('+Tunits+'!since!'+Tref+ ', ' + ifilen + ')'
915	for s1out in output: print s1out
916	# Removing file in order to make sure that it will be redone
917	print ' ' + fname + " removing file '" + ifilen + "' ..."
918	sub.call('rm ' + ifilen + ' >& /dev/null', shell=True)
919	quit(-1)
920	if db:
921	for s1out in output: print s1out
922	else:
923	print errmsg
924	print ' ' + fname + ": no CFification for model '" +minf.name+ "' !!"
925	print " available ones: 'WRF', 'WRF_LMDZ', 'LMDZ', 'DYNAMICO'"
926	quit(-1)
927
928	ifile = ifile + 1
929
930	otrackf.close()
931
932	# Joining variable files
933	if not os.path.isfile(fileon):
934	if Ntotfiles > 1:
935	if db:
936	print ' ' + fname + ": concatenating all variable files to " + \
937	"create '" + fileon + "..."
938	try:
939	with gen.Capturing() as output:
940	ncvar.netcdf_fold_concatenation_HMT('./,time', CFvarn + '_' + \
941	headerf + SgP +'_,-,.nc', 'all')
942	except:
943	print errmsg
944	print 'netcdf_fold_concatenation_HMT(./,time, ' + CFvarn + '_' + \
945	headerf +SgP + '_,-,.nc, all)'
946	for s1out in output: print s1out
947	quit(-1)
948	if db:
949	for s1out in output: print s1out
950
951	sout = sub.call('mv netcdf_fold_concatenated_HMT.nc '+fileon, shell=True)
952	if os.path.isfile(fileon):
953	sout = sub.call('rm '+CFvarn + '_' + headerf + SgP + '_-.nc >& ' + \
954	'/dev/null', shell=True)
955	else:
956	sout = sub.call('mv ' + CFvarn + '_' + headerf + SgP + '_1-1.nc ' + \
957	fileon, shell=True)
958
959	# Re-setting time of final concatenated file
960	if minf.timemodif is not None:
961	if db:
962	print ' ' + fname + ": Modifying times of the file by '" + \
963	minf.timemodif + "' !!"
964	try:
965	with gen.Capturing() as output:
966	ncvar.time_reset(minf.timemodif, fileon,'time')
967	except:
968	print errmsg
969	print 'time_reset(' + minf.timemodif + ', ' + fileon + ', time)'
970	for s1out in output: print s1out
971	# Removing file in order to make sure that it will be redone
972	print ' ' + fname + " removing file '" + fileon + "' ..."
973	sub.call('rm ' + fileon + ' >& /dev/null', shell=True)
974	quit(-1)
975	if db:
976	for s1out in output: print s1out
977
978	if db: print " End of '" + fname + "' "
979
980	return
981
982	def compute_statistics(minf, config, idir, usefiles, odir, cvar, gP, Opers, scr, db):
983	""" Function to compute different statistics it will take previous steps if they
984	are availale
985	minf= class with the information of the model
986	config= dictionary with the configuration of the experiment
987	idir= directory with the input files
988	usefiles= ',' list of files to use [file1],...,[fileN]
989	odir= directory to write the output files
990	cvar= class with the information of the variable: 'name', 'fheader', 'varmod', 'vardiag'
991	gP= kind of vertical interpolation ('global', 'local', 'none')
992	Opers= kind of operation: (as possible multiple consecutive combination of operations separated by '+'
993	[calc1]+[calc2] will compute first [calc1] and then [calc2]
994	acc: temporal accumulated values
995	diff: differences between models
996	direct: no statistics
997	last: last temporal value
998	Lmean: latitudinal mean values
999	Lsec: latitudinal section (latitudinal value must be given, [var]@[lat])
1000	lmean: longitudinal mean values
1001	lsec: longitudinal section (longitudinal value must be given, [var]@[lat])
1002	pinterp: pressure interpolation (to the given $plevels)
1003	smean: spatial-weighted mean values
1004	tmean: temporal mean values
1005	tstd: temporal standard deviation values
1006	tturb: Taylor's turbulence decomposition value (x - <x>) for time
1007	tvar: temporal variance values
1008	xmean: x-axis mean values
1009	xvar: x-axis variance values
1010	ymean: y-axis mean values
1011	zsum: vertical aggregated values
1012	scr= should it be done from the scratch?
1013	"""
1014	fname='compute_statistics'
1015
1016	# Getting a previous file name to continue with(for combinations)
1017	CFvarn=cvar.name
1018	headerf = cvar.fheader
1019	modvar = cvar.model
1020	diagvar = cvar.diag
1021
1022	cfiles = usefiles[headerf]
1023
1024	# dimensions
1025	dnx = minf.dimxn
1026	dny = minf.dimyn
1027	# var-dimensions
1028	vdnx = minf.vardxn
1029	vdny = minf.vardyn
1030	# Model dimension-variable dictionary
1031	Modeldimvardict = {dnx: vdnx, dny: vdny, dnz: vdnz, dnt: vdnt}
1032
1033	# Some experiment configuration values
1034	# plevels= ':' separated list of pressures (in Pa) to use for the vertical interpolation
1035	plevels = config['plevels']
1036	# pyH= location of the python HOME
1037	pyH = config['pyHOME']
1038	# Tref= CF time reference
1039	Tref = config['CFreftime']
1040	# Tunits= CF time units
1041	Tunits = config['CFunitstime']
1042	# opsur = operation surnames
1043	opsur = gen.get_specdictionary_HMT(config, H='opsur_',M='',T='')
1044	Opsurs = {}
1045	for opk in opsur:
1046	opn = opk.split('_')[1]
1047	vals = opsur[opk]
1048	Opsurs[opn] = vals.split(':')
1049	# if db:
1050	# print ' ' + fname + ' operation surnames _______'
1051	# gen.printing_dictionary(Opsurs)
1052
1053	# Getting in working dir
1054	os.chdir(odir)
1055
1056	# File to keep track of all operations
1057	otrackf = open( odir + '/all_statsvars.inf', 'a')
1058
1059	# For that variables which require vertical interpolation 'p' suffix to the file
1060	# header is added.
1061	# After some operations some CF dimension-variables might not be kept
1062
1063	if gP != 'none':
1064	SgP = 'p'
1065	varnCFs = ['lon', 'lat', 'pres', 'time']
1066	else:
1067	SgP = ''
1068	varnCFs = ['lon', 'lat', 'time']
1069
1070	# CF dimension-variable dictionary
1071	CFdimvardict = {'lon': 'lon', 'lat': 'lat', 'pres': 'pres', 'time': 'time'}
1072
1073	# Input file
1074	ifilen = odir + '/' + CFvarn + '_' + headerf + SgP + '.nc'
1075
1076	# Computing variable statisitcs
1077	istats=0
1078
1079	# List of not computed statistics
1080	wrongstats = []
1081
1082	opers = Opers.split('+')
1083	Fopers = ''
1084	if db: print " computing statistics of variable:'", CFvarn, "' operation '" + \
1085	Opers + "' using file '" + ifilen + "...'"
1086	for op in opers:
1087
1088	# File name from previous operations, and name of the variable within the
1089	# file (some operations change the name of the variable)
1090	if op == opers[0]:
1091	Fopers = op
1092	prevfile = ifilen
1093	vninF = CFvarn
1094	else:
1095	Fopers = Fopers + '_' + op
1096	prevfile = fileon
1097	fileon = odir + '/' + CFvarn + '_' + headerf + SgP + '_' + Fopers + '.nc'
1098
1099	# Adding required variables for the vertical interpolation in all operations
1100	SvarnCFs = ',' + ','.join(varnCFs)
1101
1102	if gP != 'none':
1103	if gP == 'local':
1104	CFvarnp = vninF + ',P,PB,PSFC,PH,PHB,HGT,T,QVAPOR,XLONG,XLAT,Times'+ \
1105	SvarnCFs
1106	else:
1107	CFvarnp = vninF + SvarnCFs
1108	else:
1109	CFvarnp = vninF + SvarnCFs
1110
1111	if scr:
1112	sout = sub.call('rm ' + fileon + ' >& /dev/null', shell=True)
1113
1114	hprevfile = prevfile[0:len(prevfile)-3]
1115
1116	if db: print ' ', op, "using '" + prevfile + "' "
1117	# Just produce file in case output file does not exist
1118	if not os.path.isfile(fileon):
1119	if db:
1120	print ' ' + fname + ": creation of file '" + fileon + "' ..."
1121	dofile = True
1122	else:
1123	dofile = False
1124
1125	# Variables to be kept in the final file
1126	varkeep = []
1127
1128	if op == 'acc':
1129	# temporal accumulated values
1130	print " " + fname + ": kind '" + op + "' not ready !!"
1131	wrongstats.append(CFvarn + '_' + opers)
1132	break
1133
1134	elif op[0:11] == 'dimvarvalue':
1135	# Slicing along the index at the nearest given value of a dimension-variable
1136	dimvarn = op.split('~')[1]
1137	dimvalue = op.split('~')[2]
1138	vals = dimvarn + ',' + dimvalue + ',' + dimvalue + ',0'
1139	if dofile:
1140	try:
1141	with gen.Capturing() as output:
1142	ncvar.DataSetSection_multivars(vals,prevfile,CFvarnp)
1143	except:
1144	print errmsg
1145	print 'DataSetSection_multivars('+vals+',', prevfile, ',' + \
1146	CFvarnp + ')'
1147	for s1out in output: print s1out
1148	quit(-1)
1149
1150	if db:
1151	for s1out in output: print s1out
1152
1153	sout = sub.call('mv DataSetSection_multivars.nc '+fileon, shell=True)
1154
1155	# Keeping the operations
1156	pyins=pyH + "/nc_var.py -o DataSetSection_multivars -S '" + vals + \
1157	"' -f " + prevfile + " -v " + CFvarnp
1158	otrackf.write("\n")
1159	otrackf.write("# " + CFvarnp + " " + Fopers + "\n")
1160	otrackf.write(pyins + "\n")
1161
1162	# removing the given variable-dimension
1163	varnCFs.remove(dimvarn)
1164
1165	elif op == 'direct':
1166	# no statistics
1167	if dofile:
1168	sout = sub.call('mv ' + prevfile + ' ' + fileon, shell=True)
1169	elif op == 'last':
1170	# last temporal value
1171	vals='time,-9,0,0'
1172	if dofile:
1173	try:
1174	with gen.Capturing() as output:
1175	ncvar.DataSetSection(vals,prevfile)
1176	except:
1177	print errmsg
1178	print 'DataSetSection('+vals+',', prevfile, ')'
1179	for s1out in output: print s1out
1180	quit(-1)
1181
1182	if db:
1183	for s1out in output: print s1out
1184
1185	sout = sub.call('mv ' + hprevfile + '_time_B-9-E0-I0.nc ' + fileon, \
1186	shell=True)
1187
1188	# Keeping the operations
1189	pyins=pyH + "/nc_var.py -o DataSetSection -S '" + vals + "' -f " + \
1190	prevfile
1191	otrackf.write("\n")
1192	otrackf.write("# " + CFvarn + " " + Fopers + "\n")
1193	otrackf.write(pyins + "\n")
1194
1195	elif op =='Lmean':
1196	# latitudinal mean values
1197	print " " + fname + ": kind '" + op + "' not ready !!"
1198	wrongstats.append(CFvarn + '_' + opers)
1199	break
1200	elif op =='Lsec':
1201	# latitudinal section (latitudinal value must be given, [var]@[lat])
1202	print " " + fname + ": kind '" + op + "' not ready !!"
1203	wrongstats.append(CFvarn + '_' + opers)
1204	break
1205	elif op =='lmean':
1206	# longitudinal mean values
1207	print " " + fname + ": kind '" + op + "' not ready !!"
1208	wrongstats.append(CFvarn + '_' + opers)
1209	break
1210	elif op =='lsec':
1211	# longitudinal section (longitudinal value must be given, [var]@[lon])
1212	print " " + fname + ": kind '" + op + "' not ready !!"
1213	wrongstats.append(CFvarn + '_' + opers)
1214	break
1215	elif op == 'pinterp':
1216	# pinterp: pressure interpolation (to the given $plevels)
1217	vals=plevels + ',1,1'
1218	if dofile:
1219	try:
1220	with gen.Capturing() as output:
1221	ncvar.pinterp(vals,prevfile,vninF)
1222	except:
1223	print errmsg
1224	print 'pinterp('+vals+',', prevfile, ','+vninF+')'
1225	for s1out in output: print s1out
1226	ncvar.pinterp(vals,prevfile,vninF)
1227	quit(-1)
1228
1229	if db:
1230	for s1out in output: print s1out
1231
1232	sout = sub.call('mv pinterp.nc ' + fileon, shell=True)
1233
1234	# Keeping the operations
1235	pyins=pyH + "/nc_var.py -o pinterp -S '" + vals + "' -f " + \
1236	prevfile + "-v " + vninF
1237	otrackf.write("\n")
1238	otrackf.write("# " + CFvarn + " " + Fopers + "\n")
1239	otrackf.write(pyins + "\n")
1240
1241	# adding CF lon,lat,time in WRF files
1242	if minf.name == 'WRF' or minf.name == 'WRF_LMDZ':
1243	values = vdnx + ':' + vdny + ':'+ Tref + ':' + Tunits
1244	if db:
1245	print " CFification of '" + fileon + "' with:", values, "..."
1246	try:
1247	with gen.Capturing() as output:
1248	ncvar.WRF_toCF(values, fileon)
1249	except:
1250	print errmsg
1251	print 'ncvar.WRF_toCF(' + values+ ', ' + fileon + ')'
1252	for s1out in output: print s1out
1253	# Removing file in order to make sure that it will be redone
1254	print ' ' + fname + " removing file '" + fileon + "' ..."
1255	sub.call('rm ' + fileon + ' >& /dev/null', shell=True)
1256	quit(-1)
1257
1258	# vertical interpolation variables are no more needed
1259	CFvarnp = vninF
1260	gP = 'none'
1261
1262	elif op == 'smean':
1263	# spatial-weighted mean values
1264	noLlvdims = list(varnCFs)
1265	noLlvdims.remove('lon')
1266	noLlvdims.remove('lat')
1267	Saddvars = ':'.join(noLlvdims)
1268	if len(Saddvars) > 1:
1269	vals = 'reglonlat,lon,lat,lon,lat,' + Saddvars
1270	else:
1271	vals = 'reglonlat,lon,lat,lon,lat,None'
1272
1273	if dofile:
1274	try:
1275	with gen.Capturing() as output:
1276	ncvar.SpatialWeightedMean(vals,prevfile,vninF)
1277	except:
1278	print errmsg
1279	print 'SpatialWeightedMean('+vals+',', prevfile, ','+vninF+')'
1280	for s1out in output: print s1out
1281	quit(-1)
1282
1283	if db:
1284	for s1out in output: print s1out
1285
1286	# renaming variable
1287	ncvar.chvarname(vninF+'mean', 'SpatialWeightedMean_reglonlat.nc', \
1288	vninF+'spaceweightmean')
1289	sout = sub.call('mv SpatialWeightedMean_reglonlat.nc '+fileon, \
1290	shell=True)
1291
1292	# Keeping the operations
1293	pyins=pyH + "/nc_var.py -o SpatialWeightedMean -S '" + vals + \
1294	"' -f " + prevfile + " -v " + vninF
1295	otrackf.write("\n")
1296	otrackf.write("# " + vninF + " " + Fopers + "\n")
1297	otrackf.write(pyins + "\n")
1298
1299	# removing dimension variable-dimension 'lon', 'lat'
1300	varnCFs.remove('lon')
1301	varnCFs.remove('lat')
1302
1303	varkeep.append(vninF + 'mean')
1304
1305	elif op == 'tmean':
1306	# temporal mean values
1307	vals='time\|-1,time,mean,' + ':'.join(varnCFs) + ':' + vdnz
1308	dims = gen.dictvar_listS(varnCFs,CFdimvardict,',','@') + dnz+'@'+vdnz
1309	if dofile:
1310	try:
1311	with gen.Capturing() as output:
1312	ncvar.file_oper_alongdims(vals,prevfile,CFvarnp)
1313	except:
1314	print errmsg
1315	print 'file_oper_alongdims('+vals+',', prevfile, ','+CFvarnp+')'
1316	for s1out in output: print s1out
1317	quit(-1)
1318
1319	if db:
1320	for s1out in output: print s1out
1321
1322	sout = sub.call('mv file_oper_alongdims_mean.nc '+fileon, shell=True)
1323
1324	# Keeping the operations
1325	pyins=pyH + "/nc_var.py -o file_oper_alongdims -S '" + vals + \
1326	"' -f " + prevfile + " -v " + CFvarnp
1327	otrackf.write("\n")
1328	otrackf.write("# " + CFvarn + " " + Fopers + "\n")
1329	otrackf.write(pyins + "\n")
1330
1331	# removing dimension variable-dimension 'time'
1332	varnCFs.remove('time')
1333
1334	varkeep.append('timestats')
1335
1336	elif op == 'tstd':
1337	# temporal standard deviation values
1338	vals='time\|-1,time,std,' + ':'.join(varnCFs) + ':' + vdnz
1339	dims = gen.dictvar_listS(varnCFs,CFdimvardict,',','@') + dnz+'@'+vdnz
1340	if dofile:
1341	try:
1342	with gen.Capturing() as output:
1343	ncvar.file_oper_alongdims(vals,prevfile,CFvarnp)
1344	except:
1345	print errmsg
1346	print 'file_oper_alongdims('+vals+',', prevfile, ','+CFvarnp+')'
1347	for s1out in output: print s1out
1348	quit(-1)
1349
1350	if db:
1351	for s1out in output: print s1out
1352
1353	sout = sub.call('mv file_oper_alongdims_std.nc '+fileon, shell=True)
1354
1355	# Keeping the operations
1356	pyins=pyH + "/nc_var.py -o file_oper_alongdims -S '" + vals + \
1357	"' -f " + prevfile + " -v " + CFvarnp
1358	otrackf.write("\n")
1359	otrackf.write("# " + CFvarn + " " + Fopers + "\n")
1360	otrackf.write(pyins + "\n")
1361
1362	# removing dimension variable-dimension 'time'
1363	varnCFs.remove('time')
1364
1365	varkeep.append('timestats')
1366
1367	elif op == 'tturb':
1368	# temporal turbulent values
1369	vals='time\|-1,time,turb,' + ':'.join(varnCFs) + ':' + vdnz
1370	dims = gen.dictvar_listS(varnCFs,CFdimvardict,',','@') + dnz+'@'+vdnz
1371	if dofile:
1372	try:
1373	with gen.Capturing() as output:
1374	ncvar.file_oper_alongdims(vals,prevfile,CFvarnp)
1375	except:
1376	print errmsg
1377	print 'file_oper_alongdims('+vals+',', prevfile, ','+CFvarnp+')'
1378	for s1out in output: print s1out
1379	quit(-1)
1380
1381	if db:
1382	for s1out in output: print s1out
1383
1384	sout = sub.call('mv file_oper_alongdims_turb.nc '+fileon, shell=True)
1385
1386	# Keeping the operations
1387	pyins=pyH + "/nc_var.py -o file_oper_alongdims -S '" + vals + \
1388	"' -f " + prevfile + " -v " + CFvarnp
1389	otrackf.write("\n")
1390	otrackf.write("# " + CFvarn + " " + Fopers + "\n")
1391	otrackf.write(pyins + "\n")
1392
1393	# removing dimension variable-dimension 'time'
1394	varkeep.append('timestats')
1395
1396	elif op == 'tvar':
1397	# temporal variance values (Taylor's turbulence)
1398	vals='time\|-1,time,var,' + ':'.join(varnCFs) + ':' + vdnz
1399	dims = gen.dictvar_listS(varnCFs,CFdimvardict,',','@') + dnz+'@'+vdnz
1400	if dofile:
1401	try:
1402	with gen.Capturing() as output:
1403	ncvar.file_oper_alongdims(vals,prevfile,CFvarnp)
1404	except:
1405	print errmsg
1406	print 'file_oper_alongdims('+vals+',', prevfile, ','+CFvarnp+')'
1407	for s1out in output: print s1out
1408	quit(-1)
1409
1410	if db:
1411	for s1out in output: print s1out
1412
1413	sout = sub.call('mv file_oper_alongdims_var.nc '+fileon, shell=True)
1414
1415	# Keeping the operations
1416	pyins=pyH + "/nc_var.py -o file_oper_alongdims -S '" + vals + \
1417	"' -f " + prevfile + " -v " + CFvarnp
1418	otrackf.write("\n")
1419	otrackf.write("# " + CFvarn + " " + Fopers + "\n")
1420	otrackf.write(pyins + "\n")
1421
1422	# removing dimension variable-dimension 'time'
1423	varnCFs.remove('time')
1424
1425	varkeep.append('timestats')
1426
1427	elif op == 'xmean':
1428	# x-axis mean values
1429	vals='lon\|-1,lon,mean,' + ':'.join(varnCFs) + ':' + vdnz
1430	dims = gen.dictvar_listS(varnCFs,CFdimvardict,',','@') + dnz+'@'+vdnz
1431	if dofile:
1432	try:
1433	with gen.Capturing() as output:
1434	ncvar.file_oper_alongdims(vals,prevfile,CFvarnp)
1435	except:
1436	print errmsg
1437	print 'file_oper_alongdims('+vals+',', prevfile, ','+CFvarnp+')'
1438	for s1out in output: print s1out
1439	quit(-1)
1440
1441	if db:
1442	for s1out in output: print s1out
1443
1444	sout = sub.call('mv file_oper_alongdims_mean.nc '+fileon, shell=True)
1445
1446	# Keeping the operations
1447	pyins=pyH + "/nc_var.py -o file_oper_alongdims -S '" + vals + \
1448	"' -f " + prevfile + " -v " + CFvarnp
1449	otrackf.write("\n")
1450	otrackf.write("# " + CFvarn + " " + Fopers + "\n")
1451	otrackf.write(pyins + "\n")
1452
1453	# removing dimension variable-dimension 'lon'
1454	varnCFs.remove('lon')
1455
1456	varkeep.append('lonstats')
1457
1458	elif op == 'xvar':
1459	# x-axis variance values
1460	vals='lon\|-1,lon,var,' + ':'.join(varnCFs) + ':' + vdnz
1461	dims = gen.dictvar_listS(varnCFs,CFdimvardict,',','@') + dnz+'@'+vdnz
1462	if dofile:
1463	try:
1464	with gen.Capturing() as output:
1465	ncvar.file_oper_alongdims(vals,prevfile,CFvarnp)
1466	except:
1467	print errmsg
1468	print 'file_oper_alongdims('+vals+',', prevfile, ','+CFvarnp+')'
1469	for s1out in output: print s1out
1470	quit(-1)
1471
1472	if db:
1473	for s1out in output: print s1out
1474
1475	sout = sub.call('mv file_oper_alongdims_var.nc '+fileon, shell=True)
1476
1477	# Keeping the operations
1478	pyins=pyH + "/nc_var.py -o file_oper_alongdims -S '" + vals + \
1479	"' -f " + prevfile + " -v " + CFvarnp
1480	otrackf.write("\n")
1481	otrackf.write("# " + CFvarn + " " + Fopers + "\n")
1482	otrackf.write(pyins + "\n")
1483
1484	# removing dimension variable-dimension 'lon'
1485	varnCFs.remove('lon')
1486
1487	varkeep.append('lonstats')
1488
1489	elif op == 'ymean':
1490	# y-axis mean values
1491	vals='lat\|-1,lat,mean,' + ':'.join(varnCFs) + ':' + vdnz
1492	dims = gen.dictvar_listS(varnCFs,CFdimvardict,',','@') + dnz+'@'+vdnz
1493	if dofile:
1494	try:
1495	with gen.Capturing() as output:
1496	ncvar.file_oper_alongdims(vals,prevfile,CFvarnp)
1497	except:
1498	print errmsg
1499	print 'file_oper_alongdims('+vals+',', prevfile, ','+CFvarnp+')'
1500	for s1out in output: print s1out
1501	quit(-1)
1502
1503	if db:
1504	for s1out in output: print s1out
1505
1506	sout = sub.call('mv file_oper_alongdims_mean.nc '+fileon, shell=True)
1507
1508	# Keeping the operations
1509	pyins=pyH + "/nc_var.py -o file_oper_alongdims -S '" + vals + \
1510	"' -f " + prevfile + " -v " + CFvarnp
1511	otrackf.write("\n")
1512	otrackf.write("# " + CFvarn + " " + Fopers + "\n")
1513	otrackf.write(pyins + "\n")
1514
1515	# removing dimension variable-dimension 'lat'
1516	varnCFs.remove('lat')
1517
1518	varkeep.append('latstats')
1519
1520	elif op == 'zsum':
1521	# vertical aggregated values
1522	print " " + fname + ": kind '" + op + "' not ready !!"
1523	wrongstats.append(CFvarn + '_' + opers)
1524	break
1525	else:
1526	print errmsg
1527	print ' ' + fname + ": operation '" + op + "' not ready !!"
1528	quit(-1)
1529
1530	# End of kind of operation
1531
1532	# Variable name in file (vninF) changed due to operation
1533	# but only if previous operation does not the same 'statistic'
1534	chvn = gen.dictionary_key_list(Opsurs, op)
1535	if chvn is not None:
1536	oldvninF = vninF
1537	vninF = vninF + chvn
1538	CFvarnp = CFvarnp.replace(oldvninF,vninF)
1539
1540	if dofile:
1541	if len(varkeep) > 0:
1542	varkeepS = ',' + ','.join(varkeep)
1543	else:
1544	varkeepS = ''
1545
1546	# Adding such CF dimension variables which might not be in the
1547	# post-operation file
1548	try:
1549	with gen.Capturing() as output:
1550	varinfile = ncvar.ivars(fileon)
1551	except:
1552	print errmsg
1553	print 'ivars('+fileon+')'
1554	for s1out in output: print s1out
1555	# Removing file in order to make sure that it will be redone
1556	print ' ' + fname + " removing file '" + fileon + "' ..."
1557	sub.call('rm ' + fileon + ' >& /dev/null', shell=True)
1558	quit(-1)
1559
1560	for CFvn in varnCFs:
1561	if not gen.searchInlist(varinfile, CFvn):
1562	if db:
1563	print ' ' + fname + ": recupering CF variable '" + CFvn + "'"
1564	try:
1565	with gen.Capturing() as output:
1566	ncvar.fvaradd(prevfile+','+CFvn, fileon)
1567	except:
1568	print errmsg
1569	print 'fvaradd(' + prevfile + ',' + CFvn +', '+fileon+')'
1570	ncvar.fvaradd(prevfile+','+CFvn, fileon)
1571	for s1out in output: print s1out
1572	# Removing file in order to make sure that it will be redone
1573	print ' ' + fname + " removing file '" + fileon + "' ..."
1574	#sub.call('rm ' + fileon + ' >& /dev/null', shell=True)
1575	quit(-1)
1576
1577	if db:
1578	for s1out in output: print s1out
1579
1580	totalvarkeeps = CFvarnp + ',' + ','.join(varnCFs) + varkeepS
1581	try:
1582	with gen.Capturing() as output:
1583	oclean = ncvar.cleaning_varsfile(totalvarkeeps,fileon)
1584	except:
1585	print errmsg
1586	print 'cleaning_varsfile('+totalvarkeeps+','+fileon+')'
1587	ncvar.cleaning_varsfile(totalvarkeeps,fileon)
1588	for s1out in output: print s1out
1589	# Removing file in order to make sure that it will be redone
1590	print ' ' + fname + " removing file '" + fileon + "' ..."
1591	sub.call('rm ' + fileon + ' >& /dev/null', shell=True)
1592	quit(-1)
1593
1594	if db:
1595	for s1out in output: print s1out
1596
1597	# End of operations
1598	if db:
1599	print fname + ": successful calculation of '" + vninF + "' from '" + \
1600	CFvarn + "' '" + Opers + "' !!"
1601
1602	if len(wrongstats) > 1:
1603	print warnmsg
1604	print ' ' + fname + ": statisitcs not possible to compute:", wrongstats
1605
1606	if db: print " End of '" + fname + "' "
1607
1608	return
1609
1610	def compute_vars(config, modinf, idir, odir, Files, allvarcomp, fscr, debug):
1611	""" Function to compute the variables
1612	config= Configuration of the experiment
1613	modinf= class with information about the model
1614	idir= input experiment folder
1615	odir= output experiment folder
1616	Files= dictionary with the header and the files' correspondence
1617	allvarcomp= dictionary with all the variables to compute and their information
1618	fscr= whether files should be done from the scratch or not
1619	"""
1620	fname = 'compute_vars'
1621
1622	for vopn in allvarcomp.keys():
1623	# variable & operation
1624	vn = vopn.split('_')[0]
1625	op = vopn.split('_')[1]
1626	vopnV = allvarcomp[vopn]
1627	fheader = vopnV[0]
1628	if type(vopnV[1]) == type([1, 2]) and len(vopnV[1]) == 1:
1629	vals = vopnV[1]
1630	model = vals[0]
1631	else:
1632	model = vopnV[1]
1633	diag = vopnV[2]
1634	globalP = vopnV[3]
1635
1636	if debug:
1637	print ' ' + vn + ': ' + op
1638
1639	# Computing CF variable
1640	if model is not None or diag is not None:
1641	vinf = VariableInf(vn,fheader,model,diag)
1642	if op.find('pinterp') != -1:
1643	SP = 'p'
1644	else:
1645	SP = ''
1646
1647	# Comppute variable
1648	finalfilen = odir + '/' + vn + '_' + fheader + SP + '.nc'
1649	if fscr:
1650	sout = sub.call('rm ' + finalfilen + ' >& /dev/null', shell=True)
1651
1652	if not os.path.isfile(finalfilen):
1653	compute_variable(modinf, idir, Files, odir, vinf, globalP, fscr, \
1654	config['pyHOME'], config['CFreftime'], config['CFunitstime'], debug)
1655
1656	# Compute variable statistics
1657	finalfilen = odir + '/' + vn + '_' + fheader + SP + '_' + \
1658	op.replace('+','_') + '.nc'
1659	if fscr:
1660	sout = sub.call('rm ' + finalfilen + ' >& /dev/null', shell=True)
1661
1662	if not os.path.isfile(finalfilen):
1663	compute_statistics(modinf, cnf, iwdir, Files, owdir, vinf, globalP, \
1664	op, fscr, debug)
1665
1666	else:
1667	print errmsg
1668	print ' ' + fname + ": neither 'model' or 'diag' variables for '" + vn \
1669	+ "' !!"
1670	quit(-1)
1671
1672	return
1673
1674	def get_plots_var(vc,pltk,db):
1675	""" Function to provide the plots to make for each variable from pltk ('DIRPLT_', or 'DIFFPLT_') dictionary
1676	vc= pltk dictionary, dictionary with all the parameters started with pltk
1677	pltk= kind of plots. Values started by 'DIRPLT_', or 'DIFFPLT_' in model configuration
1678	"""
1679	fname = 'get_plots_var'
1680
1681	LH = len(pltk)
1682	# list of plots
1683	doplots = {}
1684	# plots by variable
1685	plotsvar = {}
1686	# individual plots by variable (not repeated)
1687	indivplotsvar = {}
1688
1689	# Variables with a plot which requires vertical interpolation
1690	varplotp = []
1691
1692	ipl = 0
1693	for plot in vc.keys():
1694	Lplot = len(plot)
1695	pln = plot[LH:Lplot+1]
1696	varops = vc[plot].split(':')
1697	for vn in varops:
1698	VOn = vn.split('#')
1699	# Variables and operations in plot
1700	vplt = []
1701	oplt = []
1702	voplt = []
1703	for vop in VOn:
1704	vv = vop.split('\|')[0]
1705	oo = vop.split('\|')[1]
1706	vplt.append(vv)
1707	oplt.append(oo)
1708	if not gen.searchInlist(voplt,vop): voplt.append(vop)
1709	vpltS = '#'.join(vplt)
1710	opltS = '#'.join(oplt)
1711
1712	if not doplots.has_key(pln):
1713	doplots[pln] = [vn]
1714	else:
1715	plots = doplots[pln]
1716	plots.append(vn)
1717	doplots[pln] = plots
1718
1719	if not plotsvar.has_key(vn):
1720	plotsvar[vn] = [pln]
1721	else:
1722	plots = plotsvar[vn]
1723	plots.append(pln)
1724	plotsvar[vn] = plots
1725
1726	for VOv in voplt:
1727	if not indivplotsvar.has_key(VOv):
1728	indivplotsvar[VOv] = [pln]
1729	else:
1730	plots = indivplotsvar[VOv]
1731	plots.append(pln)
1732	indivplotsvar[VOv] = plots
1733
1734	if vc[plot].find('pinterp') != -1:
1735	if not gen.searchInlist(varplotp,vn): varplotp.append(pln)
1736
1737	ipl = ipl + 1
1738
1739	if db:
1740	print ' plots to make _______'
1741	gen.printing_dictionary(doplots)
1742	print ' plots by variable\|operation _______'
1743	gen.printing_dictionary(plotsvar)
1744	print ' individual plots by variable\|operation _______'
1745	gen.printing_dictionary(indivplotsvar)
1746	print ' plots with the vertical interpolation _______'
1747	print ' #', varplotp
1748
1749	if db: print " End of '" + fname + "' "
1750
1751	return doplots, plotsvar, indivplotsvar, varplotp
1752
1753	def plots_listconstruct(config, pkind, finf, odir, debug):
1754	""" Function to create the list of plots to draw
1755	config= Configuration of the experiment
1756	pkind= kind of plots ('DIRPLT', 'DIFFPLT')
1757	finf= file with the instructions of the plots
1758	odir= output experiment folder
1759	"""
1760	fname='plots_listconstruct'
1761
1762	dirplot = gen.get_specdictionary_HMT(config, H=pkind+'_')
1763
1764	# No plots because there are not plots of this kind
1765	if dirplot is None:
1766	print warnmsg
1767	print ' ' + fname + ": no plots for type '" + pkind + "' !!"
1768	return {}, 0
1769
1770	if debug:
1771	print " '" + pkind + "' plots to draw ________"
1772	gen.printing_dictionary(dirplot)
1773
1774	# Getting plots by variable
1775	plots, varplot, indivarplot, plotp = get_plots_var(dirplot, pkind+'_', debug)
1776
1777	Svarplot = gen.dictKeysVals_stringList(plots,cV=':')
1778
1779	Nplots = 0
1780	for pl in Svarplot.split(','):
1781	Nplots = Nplots + len(pl.split(':'))
1782
1783	# Outwritting the varcompute to avoid next time (if it is not filescratch!)
1784	objf = open(finf, 'w')
1785	objf.write('plots: ' + Svarplot + '\n')
1786	objf.write('itotp: ' + str(Nplots) + '\n')
1787	objf.close()
1788
1789	if debug: print " End of '" + fname + "' "
1790
1791	return plots, Nplots
1792
1793	def read_plot_file(figfile):
1794	""" Function to read the file with the information about the plots to draw
1795	figfile= file with the information
1796	"""
1797	fname = 'read_plot_file'
1798
1799	if not os.path.isfile(figfile):
1800	print errormsg
1801	print ' ' + fname + ": figures file '" + figfile + "' does not exist !!"
1802	quit(-1)
1803
1804	objf = open(figfile, 'r')
1805	for line in objf:
1806	if line[0:1] != '#' and len(line) > 1:
1807	values = line.replace('\\n','').split(' ')
1808	if values[0] == 'plots:':
1809	if values[1] != 'none':
1810	plots = gen.stringList_dictKeysVals(values[1],cV=':')
1811	else:
1812	pots = {}
1813	elif values[0] == 'itotp:':
1814	Nplots = int(values[1])
1815
1816	objf.close()
1817
1818	return plots, Nplots
1819
1820	def varnoper(vn, oper, opsurdict):
1821	""" Function to provide name of the variable after operation as result of addition of the 'surnames'
1822	vn= variable name
1823	oper= '+' separated list of operations
1824	opsurdict= dictionary with the surname of operations
1825	>>> OpSurDict = {'mean': ['tmean', 'xmean', 'ymean']}
1826	>>> varnoper('tas', 'pinterp+tmean+xmean', OpSurDict)
1827	tasmeanmean
1828	"""
1829	fname = 'varnoper'
1830
1831	newvn = vn
1832
1833	for op in oper.split('+'):
1834	surname = gen.dictionary_key_list(opsurdict,op)
1835	if surname is not None:
1836	newvn = newvn + surname
1837
1838	return newvn
1839
1840	def draw_plot(kplot, CFvplot, fplot, vplot, dplot, pplot, finame, tfig, kfig, mapval,\
1841	tvals, expgraphc, od, pyH, fscr, db):
1842	""" Function to draw a plot
1843	kplot= kind of plot
1844	CFvplot= list of the CFnames of the variables
1845	fplot= list with the files in the plot
1846	vplot= list with the name of the variables in each file
1847	dplot= list of the dimensions in each file
1848	pplot= list of pictoric characteristics for each variable
1849	finame= name of the figure
1850	tfig= title of the figure
1851	kfig= kind of the figure
1852	mapval= value of the map
1853	tvals= list with time values
1854	tunits: units of time ('!' for spaces)
1855	timekind: kind of time ticks in the plot
1856	timefmt: format of time ticks in the plot
1857	timelabel: label of time-axis in the plot
1858	expgraphc= dictionary with expriment graphical characteristics
1859	od= output directory
1860	pyH= python HOME
1861	fscr= whether figure should be done from scratch
1862	"""
1863	fname = 'draw_plot'
1864
1865	if fscr:
1866	sout = sub.call('rm ' + finame + ' >& /dev/null', shell=True)
1867
1868	os.chdir(od)
1869
1870	# CF variable-dimensions
1871	CFvardims = {'lon':'lon', 'lat': 'lat', 'pres': 'pres', 'time': 'time'}
1872
1873	# Tracking file with all the figures
1874	trkobjf = open('all_figures.inf', 'a')
1875
1876	# Time-characteristics
1877	tunits = tvals[0]
1878	timekind = tvals[1]
1879	timefmt = tvals[2]
1880	timelabel = tvals[3]
1881
1882	# Graphical labels and configuration
1883
1884
1885	if not os.path.isfile(finame):
1886	if db:
1887	print " drawing '" + finame + "' ..."
1888	print ' plot kind:', kplot
1889	print ' CFvars:', CFvplot
1890	print ' files:', fplot
1891	print ' in file vars:', vplot
1892	print ' dims:', dplot
1893	print ' pictoric values:', pplot
1894	print ' figure name:', finame
1895	print ' title:', tfig.replace('!',' ')
1896	print ' kind:', kfig
1897	print ' map:', mapval
1898	print ' time units:', tunits
1899
1900	if kplot == 'diffmap2Dsfc':
1901	print " " + fname + ": kind of plot '" + kplot + "' not ready !!"
1902	quit(-1)
1903	elif kplot == 'diffmap2Dz':
1904	print " " + fname + ": kind of plot '" + kplot + "' not ready !!"
1905	quit(-1)
1906	elif kplot == 'map2Dsfc':
1907	print " " + fname + ": kind of plot '" + kplot + "' not ready !!"
1908	quit(-1)
1909	elif kplot == 'map3D':
1910	print " " + fname + ": kind of plot '" + kplot + "' not ready !!"
1911	quit(-1)
1912	elif kplot == '2lines':
1913	figtit = tfig.replace('!','\|')
1914
1915	lineAstdn = CFvplot[0]
1916	lineBstdn = CFvplot[1]
1917	figfs = ','.join(fplot)
1918
1919	lineA = pplot[0]
1920	Arange = str(lineA[0]) + ',' + str(lineA[1])
1921	# Values are changed from specific values in `model_graphics.dat'
1922	if lineA[3].find('%') == -1:
1923	Aline = lineA[2]
1924	Akind = lineA[3]
1925	Amark = lineA[4]
1926	Asize = lineA[5]
1927	else:
1928	Aline = 'red'
1929	Akind = '-'
1930	Amark = ','
1931	Asize = 2.
1932
1933	lineB = pplot[1]
1934	Brange = str(lineB[0]) + ',' + str(lineB[1])
1935	# Values are changed from specific values in `model_graphics.dat'
1936	if lineB[3].find('%') == -1:
1937	Bline = lineB[2]
1938	Bkind = lineB[3]
1939	Bmark = lineB[4]
1940	Bsize = lineB[5]
1941	else:
1942	Bline = 'blue'
1943	Bkind = '-'
1944	Bmark = ','
1945	Bsize = '2.'
1946
1947	# It is assumed that if the space variable is 'lon': is desired a
1948	# (lon, vals) plot if it is 'lat': then (vals, lat) plot
1949	if gen.searchInlist(dplot[0],'lon'):
1950	spacedim ='lon'
1951	axisvals = 'y'
1952	figmid = 'longitudinal'
1953	elif gen.searchInlist(dplot[0],'lat'):
1954	spacedim = 'lat'
1955	axisvals = 'x'
1956	figmid = 'meridional'
1957	elif gen.searchInlist(dplot[0],'pres'):
1958	spacedim = 'pres'
1959	axisvals = 'x'
1960	figmid = 'vertical'
1961	else:
1962	print errmsg
1963	print ' ' + fname + ": in '2lines' only ready for: 'lon', 'lat'," + \
1964	" 'pres' as common dimension !!"
1965	print ' dimensions in plot:', dplot[0]
1966	quit(-1)
1967
1968	figtit = '!'.join(tfig.split('!')[0:2]) + '!' + figmid + '!' + \
1969	'!'.join(tfig.split('!')[2:])
1970
1971	graphvals = spacedim + ':' + Arange + ':' + Brange + ':Extrs:' + \
1972	axisvals + ':' + ','.join(CFvplot) + ':' + Aline + ',' + Bline + \
1973	':2.,2.:' + Akind + ',' + Bkind + ':2.,2.:,:' + figtit + ':' + \
1974	spacedim + ':0\|auto:' + finame.replace('.'+kfig, '') + ':' + kfig + \
1975	':True'
1976
1977	fvarS = ','.join(vplot)
1978
1979	drwins = 'draw_2lines'
1980	plotins = 'python ' + pyH + '/drawing.py -f ' + figfs +' -o ' + drwins + \
1981	" -S '" + graphvals + "' -v " + fvarS
1982
1983	try:
1984	with gen.Capturing() as output:
1985	sout = sub.call(plotins, shell=True)
1986	except:
1987	print errmsg
1988	print drwins + '(' + graphvals + ',' + figfs + ',' + fvarS + ')'
1989	print sout
1990	for s1out in output: print s1out
1991	quit(-1)
1992
1993	# keeping all figures
1994	trkobjf.write('\n')
1995	trkobjf.write("# '" + kplot + "'; " + tfig.replace('!',' ') + '\n')
1996	trkobjf.write(plotins + '\n')
1997
1998	elif kplot == '2linesTime':
1999	figtit = tfig.replace('!','\|')
2000
2001	lineAstdn = CFvplot[0]
2002	lineBstdn = CFvplot[1]
2003	figfs = ','.join(fplot)
2004
2005	lineA = pplot[0]
2006	Arange = str(lineA[0]) + ',' + str(lineA[1])
2007	# Values are changed from specific values in `model_graphics.dat'
2008	if lineA[3].find('%') == -1:
2009	Aline = lineA[2]
2010	Akind = lineA[3]
2011	Amark = lineA[4]
2012	Asize = lineA[5]
2013	else:
2014	Aline = 'red'
2015	Akind = '-'
2016	Amark = ','
2017	Asize = '2.'
2018
2019	lineB = pplot[1]
2020	Brange = str(lineB[0]) + ',' + str(lineB[1])
2021	# Values are changed from specific values in `model_graphics.dat'
2022	if lineB[3].find('%') == -1:
2023	Bline = lineB[2]
2024	Bkind = lineB[3]
2025	Bmark = lineB[4]
2026	Bsize = lineB[5]
2027	else:
2028	Bline = 'blue'
2029	Bkind = '-'
2030	Bmark = ','
2031	Bsize = '2.'
2032
2033	timeaxis = 'x'
2034	figmid = 'evolution'
2035
2036	figtit = '!'.join(tfig.split('!')[0:2]) + '!' + figmid + '!' + \
2037	'!'.join(tfig.split('!')[2:])
2038
2039	graphvals = 'time:' + Arange + ':' + Brange + ':' + timekind + ';' + \
2040	timefmt + ':' + timeaxis + ':' + ','.join(CFvplot) + ':' + Aline + ',' \
2041	+ Bline + ':2.,2.:' + Akind + ',' + Bkind + ':2.,2.:,:' + figtit + ':' \
2042	+ timelabel + ':0\|auto:' + finame.replace('.'+kfig, '') + ':' + \
2043	kfig + ':True'
2044
2045	fvarS = ','.join(vplot)
2046
2047	drwins = 'draw_2lines_time'
2048	plotins = 'python ' + pyH + '/drawing.py -f ' + figfs +' -o ' + drwins + \
2049	" -S '" + graphvals + "' -v " + fvarS
2050
2051	try:
2052	with gen.Capturing() as output:
2053	sout = sub.call(plotins, shell=True)
2054	except:
2055	print errmsg
2056	print drwins + '(' + graphvals + ',' + figfs + ',' + fvarS + ')'
2057	print sout
2058	for s1out in output: print s1out
2059	quit(-1)
2060
2061	# keeping all figures
2062	trkobjf.write('\n')
2063	trkobjf.write("# '" + kplot + "'; " + tfig.replace('!',' ') + '\n')
2064	trkobjf.write(plotins + '\n')
2065
2066	elif kplot == 'Nlines':
2067	figtit = tfig.replace('!','\|')
2068
2069	linestdn = CFvplot[0]
2070	figfs = ','.join(fplot)
2071
2072	Nlines = len(fplot)
2073
2074	lablines = []
2075	for il in range(Nlines):
2076	linev = pplot[il]
2077	# Values are changed from specific values in `model_graphics.dat'
2078	if linev[3].find('%') == -1:
2079	line = linev[2]
2080	kind = linev[3]
2081	mark = linev[4]
2082	size = linev[5]
2083	if il == 0:
2084	vrange = str(linev[0]) + ',' + str(linev[1])
2085	kinds = kind
2086	lines = line
2087	marks = mark
2088	sizes = str(size)
2089	else:
2090	kinds = kinds + ',' + kind
2091	lines = lines + ',' + line
2092	marks = marks + '@' + mark
2093	sizes = sizes + ',' + str(size)
2094	else:
2095	lines = 'None'
2096	kinds = '-'
2097	marks = ','
2098	sizes = '2.'
2099
2100	secsf = fplot[il].split('/')
2101	Nsecsf = len(secsf)
2102	expvs = expgraphc[secsf[Nsecsf-3] + '/' + secsf[Nsecsf-2]]
2103	lablines.append(expvs.label)
2104
2105	# It is assumed that if the space variable is 'lon': is desired a
2106	# (lon, vals) plot if it is 'lat': then (vals, lat) plot
2107	if gen.searchInlist(dplot[0],'lon'):
2108	spacedim ='lon'
2109	sdlab ='lon ($degrees\ East$)'
2110	axisvals = 'y'
2111	figmid = 'longitudinal'
2112	elif gen.searchInlist(dplot[0],'lat'):
2113	spacedim = 'lat'
2114	sdlab = 'lat ($degrees\ North$)'
2115	axisvals = 'x'
2116	figmid = 'meridional'
2117	elif gen.searchInlist(dplot[0],'pres'):
2118	spacedim = 'pres'
2119	sdlab = 'pres ($Pa$)'
2120	axisvals = 'x'
2121	figmid = 'vertical'
2122	else:
2123	print errmsg
2124	print ' ' + fname + ": in 'Nlines' only ready for: 'lon', 'lat'," + \
2125	" 'pres' as common dimension !!"
2126	print ' dimensions in plot:', dplot[0]
2127	quit(-1)
2128
2129	figtit = '!'.join(tfig.split('!')[0:2]) + '!' + figmid + '!' + \
2130	'!'.join(tfig.split('!')[2:])
2131	figtit = figtit.replace('!',' ')
2132	leglabels = ','.join(lablines)
2133
2134	graphvals = spacedim + ':' + axisvals + ':' + sdlab + ':auto:' + \
2135	leglabels + ':' + CFvplot[0] +':'+ figtit + ':0\|auto:' + lines + ':' + \
2136	kinds + ':' + marks +':'+ sizes +':'+ sizes +':all:'+ \
2137	finame.replace('.'+kfig, '') + ':' + kfig + ':True'
2138
2139	fvarS = vplot[0]
2140
2141	drwins = 'draw_lines'
2142	plotins = 'python ' + pyH + '/drawing.py -f ' + figfs +' -o ' + drwins + \
2143	" -S '" + graphvals + "' -v " + fvarS
2144
2145	try:
2146	with gen.Capturing() as output:
2147	sout = sub.call(plotins, shell=True)
2148	except:
2149	print errmsg
2150	print drwins + '(' + graphvals + ',' + figfs + ',' + fvarS + ')'
2151	print sout
2152	for s1out in output: print s1out
2153	quit(-1)
2154
2155	# keeping all figures
2156	trkobjf.write('\n')
2157	trkobjf.write("# '" + kplot + "'; " + tfig.replace('!',' ') + '\n')
2158	trkobjf.write(plotins + '\n')
2159
2160	elif kplot == 'Nlines_time':
2161	figtit = tfig.replace('!','\|')
2162
2163	linestdn = CFvplot[0]
2164	figfs = ','.join(fplot)
2165
2166	Nlines = len(fplot)
2167
2168	lablines = []
2169	for il in range(Nlines):
2170	linev = pplot[il]
2171	# Values are changed from specific values in `model_graphics.dat'
2172	if linev[3].find('%') == -1:
2173	line = linev[2]
2174	kind = linev[3]
2175	mark = linev[4]
2176	size = linev[5]
2177	if il == 0:
2178	vrange = str(linev[0]) + ',' + str(linev[1])
2179	kinds = kind
2180	lines = line
2181	marks = mark
2182	sizes = str(size)
2183	else:
2184	kinds = kinds + ',' + kind
2185	lines = lines + ',' + line
2186	marks = marks + '@' + mark
2187	sizes = sizes + ',' + str(size)
2188	else:
2189	lines = 'None'
2190	kinds = '-'
2191	marks = ','
2192	sizes = '2.'
2193
2194	secsf = fplot[il].split('/')
2195	Nsecsf = len(secsf)
2196	expvs = expgraphc[secsf[Nsecsf-3] + '/' + secsf[Nsecsf-2]]
2197	lablines.append(expvs.label)
2198
2199	valsaxis = 'y'
2200	figmid = 'evolution'
2201
2202	figtit = '!'.join(tfig.split('!')[0:2]) + '!' + figmid + '!' + \
2203	'!'.join(tfig.split('!')[2:])
2204	figtit = figtit.replace('!',' ')
2205	leglabels = ','.join(lablines)
2206
2207	graphvals = 'time;' + valsaxis + ';time;' + leglabels + ';' + \
2208	CFvplot[0] + ';' + figtit + ';None;time\|' + '\|'.join(tvals) + \
2209	';0\|auto;' + kfig + ';' + kinds + ';' + lines + ';' + marks + ';' + \
2210	sizes + ';' + sizes + ';all;-1;True'
2211
2212	fvarS = vplot[0]
2213
2214	drwins = 'draw_lines_time'
2215	plotins = 'python ' + pyH + '/drawing.py -f ' + figfs +' -o ' + drwins + \
2216	" -S '" + graphvals + "' -v " + fvarS
2217
2218	try:
2219	with gen.Capturing() as output:
2220	sout = sub.call(plotins, shell=True)
2221	except:
2222	print errmsg
2223	print drwins + '(' + graphvals + ',' + figfs + ',' + fvarS + ')'
2224	print sout
2225	for s1out in output: print s1out
2226	quit(-1)
2227
2228	sout = sub.call('mv lines_time.' + kfig + ' ' + finame, shell=True)
2229
2230	# keeping all figures
2231	trkobjf.write('\n')
2232	trkobjf.write("# '" + kplot + "'; " + tfig.replace('!',' ') + '\n')
2233	trkobjf.write(plotins + '\n')
2234
2235	elif kplot == 'shadcont2Dsfc':
2236	figtit = tfig.replace('!','\|')
2237	shdstdn = CFvplot[0]
2238	cntstdn = CFvplot[1]
2239	figfs = ','.join(fplot)
2240
2241	shad = pplot[0]
2242	srange = str(shad[0]) + ',' + str(shad[1])
2243	cbar = shad[2]
2244	cnt = pplot[1]
2245	crange = str(cnt[0]) + ',' + str(cnt[1])
2246	cfmt = cnt[3]
2247	ckind = cnt[4]
2248	cline = cnt[5]
2249
2250	graphvals = ','.join(CFvplot)
2251	graphvals = graphvals + ':lon\|-1,lat\|-1:lon\|-1,lat\|-1:lon:lat:auto:' + \
2252	cbar + ',auto,auto:' + ckind + ',' + cline + ':' + cfmt + ':' + \
2253	srange + ':' + crange + ',9:' + figtit + ':' + kfig + ':None:' + \
2254	mapval + ':True'
2255
2256	fvarS = ','.join(vplot)
2257
2258	drwins = 'draw_2D_shad_cont'
2259	plotins = "python " + pyH + "/drawing.py -f " + figfs + " -o " + drwins +\
2260	" -S '" + graphvals + "' -v " + fvarS
2261	try:
2262	with gen.Capturing() as output:
2263	sout = sub.call(plotins, shell=True)
2264	except:
2265	print errmsg
2266	print drwins + '(' + graphvals + ',' + figfs + ',' + fvarS + ')'
2267	print sout
2268	for s1out in output: print s1out
2269	quit(-1)
2270
2271	sout = sub.call('mv 2Dfields_shadow-contour.'+kfig+' '+finame, shell=True)
2272
2273	# keeping all figures
2274	trkobjf.write('\n')
2275	trkobjf.write("# '" + kplot + "'; " + tfig.replace('!',' ') + '\n')
2276	trkobjf.write(plotins + '\n')
2277
2278	elif kplot == 'shadconthovmsfc':
2279	figtit = tfig.replace('!','\|')
2280	shdstdn = CFvplot[0]
2281	cntstdn = CFvplot[1]
2282	figfs = ','.join(fplot)
2283
2284	shad = pplot[0]
2285	srange = str(shad[0]) + ',' + str(shad[1])
2286	cbar = shad[2]
2287	cnt = pplot[1]
2288	crange = str(cnt[0]) + ',' + str(cnt[1])
2289	cfmt = cnt[3]
2290	ckind = cnt[4]
2291	cline = cnt[5]
2292	# It is assumed that if the space variable is 'lon': is desired a
2293	# (lon, time) plot if it is 'lat': then (time, lat) plot
2294	if gen.searchInlist(dplot,'lon'):
2295	spacedim ='lon'
2296	figmid = 'longitudinal\|evolution\|of'
2297	figtit = '\|'.join(tfig.split('!')[0:2]) + '\|' + figmid + '\|' + \
2298	'\|'.join(tfig.split('!')[2:])
2299	reverse= 'None'
2300	dims= spacedim+'\|-1,time\|-1;'+spacedim+'\|-1,time\|-1;'+spacedim+';time'
2301	else:
2302	spacedim='lat'
2303	figmid = 'meridional\|evolution\|of'
2304	figtit = '\|'.join(tfig.split('!')[0:2]) + '\|' + figmid + '\|' + \
2305	'\|'.join(tfig.split('!')[2:])
2306	reverse='None'
2307	dims= spacedim+'\|-1,time\|-1;'+spacedim+'\|-1,time\|-1;time;'+spacedim
2308
2309	graphvals = ','.join(CFvplot)
2310	graphvals = graphvals + ';' + dims +';auto;' + cbar + ',auto,auto' + ';' \
2311	+ ckind + ',' + cline + ';' + cfmt + ';' + srange + ';' + crange + \
2312	',9;' + figtit + ';' + kfig + ';' + reverse + ';' + 'time\|' + tunits + \
2313	'\|'+ timekind + '\|' + timefmt + '\|' + timelabel + ';True'
2314
2315	fvarS = ','.join(vplot)
2316
2317	drwins = 'draw_2D_shad_cont_time'
2318	plotins = 'python ' + pyH + '/drawing.py -f ' + figfs +' -o ' + drwins + \
2319	" -S '" + graphvals + "' -v " + fvarS
2320
2321	try:
2322	with gen.Capturing() as output:
2323	sout = sub.call(plotins, shell=True)
2324	except:
2325	print errmsg
2326	print drwins + '(' + graphvals + ',' + figfs + ',' + fvarS + ')'
2327	print sout
2328	for s1out in output: print s1out
2329	quit(-1)
2330
2331	sout = sub.call('mv 2Dfields_shadow-contour.'+kfig+' '+finame, shell=True)
2332
2333	# keeping all figures
2334	trkobjf.write('\n')
2335	trkobjf.write("# '" + kplot + "'; " + tfig.replace('!',' ') + '\n')
2336	trkobjf.write(plotins + '\n')
2337
2338	elif kplot == 'shadcont2Dzsec':
2339	figtit = tfig.replace('!','\|')
2340	shdstdn = CFvplot[0]
2341	cntstdn = CFvplot[1]
2342	figfs = ','.join(fplot)
2343
2344	shad = pplot[0]
2345	srange = str(shad[0]) + ',' + str(shad[1])
2346	cbar = shad[2]
2347	cnt = pplot[1]
2348	crange = str(cnt[0]) + ',' + str(cnt[1])
2349	cfmt = cnt[3]
2350	ckind = cnt[4]
2351	cline = cnt[5]
2352
2353	# It is assumed that if the space variable is 'lon': is desired a
2354	# (lon, pres) plot it it is 'lat': then (pres, lat) plot
2355	if gen.searchInlist(dplot, 'lon'):
2356	spacedim='lon'
2357	figmid = 'long.\|vert.\|cross\|sec.\|of'
2358	figtit = '\|'.join(tfig.split('!')[0:2]) + '\|' + figmid + '\|' + \
2359	'\|'.join(tfig.split('!')[2:])
2360	dims= spacedim+'\|-1,pres\|-1:'+spacedim+'\|-1,pres\|-1:'+spacedim+':pres'
2361	else:
2362	spacedim='lat'
2363	figmid = 'mer.\|vert.\|cross\|sec.\|of'
2364	figtit = '\|'.join(tfig.split('!')[0:2]) + '\|' + figmid + '\|' + \
2365	'\|'.join(tfig.split('!')[2:])
2366	# NOT WORKING? dims= spacedim+'\|-1,pres\|-1:'+spacedim+'\|-1,pres\|-1:'+'pres:'+spacedim
2367	dims= spacedim+'\|-1,pres\|-1:'+spacedim+'\|-1,pres\|-1:'+spacedim+':pres'
2368
2369	reverse = 'None'
2370
2371	graphvals = ','.join(CFvplot)
2372	graphvals = graphvals + ':' + dims + ':auto:' + cbar + ',auto,auto:' + \
2373	ckind + ',' + cline + ':' + cfmt + ':' + srange + ':' + crange + ',9:' \
2374	+ figtit + ':' + kfig + ':' + reverse + ':None:True'
2375
2376	fvarS = ','.join(vplot)
2377
2378	drwins = 'draw_2D_shad_cont'
2379	plotins = 'python ' + pyH + '/drawing.py -f ' + figfs + ' -o ' + drwins + \
2380	" -S '" + graphvals + "' -v " + fvarS
2381	try:
2382	with gen.Capturing() as output:
2383	sout0 = sub.call(plotins, shell=True)
2384	except:
2385	print errmsg
2386	print drwins + '(' + graphvals + ',' + figfs + ',' + fvarS + ')'
2387	for s1out in output: print s1out
2388	quit(-1)
2389
2390	sout = sub.call('mv 2Dfields_shadow-contour.'+kfig+' '+finame, shell=True)
2391
2392	# keeping all figures
2393	trkobjf.write('\n')
2394	trkobjf.write("# '" + kplot + "'; " + tfig.replace('!',' ') + '\n')
2395	trkobjf.write(plotins + '\n')
2396
2397	else:
2398	print errmsg
2399	print " " + fname + ": plot kind '" + kplot + "' not ready !!"
2400	quit(-1)
2401
2402	trkobjf.close()
2403
2404	if db: print " End of '" + fname + "' "
2405
2406	return
2407
2408	def opexplained(Opn,Exp):
2409	""" Function to provide the final explanation for the title in the graph. Some operations have
2410	values separated by `~' which need to be processed
2411	Opn= full operation string
2412	Exp= explanation from dictionary
2413	>>> opexplained('dimvarvalue~pres~85000','@')
2414	pres@85000
2415	>>> opexplained('xmean','xmean')
2416	xmean
2417	"""
2418	fname = 'opexplained'
2419
2420	if Opn.find('~') == -1:
2421	explanation = Exp
2422	else:
2423	Opnv = Opn.split('~')
2424	if Opnv[0] == 'dimvarvalue':
2425	explanation = Opnv[1] + Exp + Opnv[2]
2426	else:
2427	print errormsg
2428	print ' ' + fname + ": unknow '~' separated operation '" + Opnv[0] + \
2429	"' !!"
2430	quit(-1)
2431	return explanation
2432
2433	def optitle(op,opexp):
2434	""" Function to creat the operation section in the title of a figure ('!' for spaces)
2435	op= '+' separated list of operations
2436	opexp= dictionary with the `explanation'(text in title) to appear for each operation
2437	>>> optitle('pinterp+xmean+tmean',{'pinterp':'pinterp', 'xmean':'xmean', 'tmean':'tmean'})
2438	$_{[pinterp\!xmean\!tmean]}$
2439	>>> optitle('pinterp+dimvarvalue~pres~85000+tmean',{'dimvarvalue':'@', 'pinterp':'pinterp', 'xmean':'xmean', 'tmean':'tmean'})
2440	$_{[pinterp\!pres@85000\!tmean]}$
2441	"""
2442	fname = 'optitle'
2443
2444	opvals = op.split('+')
2445	for op1 in opvals:
2446	op1n = op1.split('~')[0]
2447	if not opexp.has_key(op1n):
2448	print errmsg
2449	print ' ' + fname + ": no explanation for operation '" + op1n + "' !!"
2450	print ' provided:', opexp.keys()
2451	quit(-1)
2452	# Final explanation
2453	op1en = opexplained(op1,opexp[op1n]).replace(' ','!')
2454
2455	if op1n == opvals[0].split('~')[0]:
2456	titop = '$_{[' + op1en
2457	if len(opvals) == 1: titop = titop + ']}$'
2458	elif op1n == opvals[len(opvals)-1].split('~')[0]:
2459	titop = titop + '\!' + op1en + ']}$'
2460	else:
2461	titop = titop + '\!' + op1en
2462
2463	return titop
2464
2465	def create_figure_title(mod,exp,varops,explop):
2466	""" Function to create the title of a figure ('!' for spaces)
2467	mod: model name
2468	exp: experiment name
2469	varops: list with [var]\|[op] values from wich create the title
2470	explop: dictionary with the `explanation'(text in title) to appear for each operation
2471	>>> expops = {'pinterp':'pinterp', 'xmean':'xmean', 'tmean':'tmean', 'last':'last'}
2472	>>> create_figure_title('WRF','current',['ua\|pinterp+xmean+tmean', 'va\|pinterp+xmean+tmean'], expops)
2473	WRF!current!ua!&!va$_{[pinterp\!xmean\!tmean]}$
2474	>>> create_figure_title('WRF','current',['ua\|pinterp+xmean+tmean', 'ua\|pinterp+xmean+last'], expops)
2475	WRF!current!ua$_{[pinterp\!xmean\!tmean]}$!&!!$_{[pinterp\!xmean\!last]}$
2476	>>> create_figure_title('WRF','current',['ua\|pinterp+xmean+tmean', 'va\|pinterp+xmean+last'], expops)
2477	WRF!current!ua$_{[pinterp\!xmean\!tmean]}$!&!va$_{[pinterp\!xmean\!last]}$
2478	>>> create_figure_title('WRF','current',['uas\|dimvarvalue~lon~23.23', 'vas\|dimvarvalue~lon~23.23'], expops)
2479	WRF!current!uas!&!vas$_{[lon@23.23]}$
2480	>>> create_figure_title('WRF','current',['hus\|pinterp+tmean+dimvarvalue~pres~85000.', 'ta\|pinterp+tmean+dimvarvalue~pres~85000.'], expops)
2481	WRF!current!hus!&!ta$_{[pinterp\!tmean\!pres@85000.]}$
2482	"""
2483	fname = 'create_figure_title'
2484
2485	titfig = mod + '!' + exp + '!'
2486
2487	varns = []
2488	opns = []
2489	for varop in varops:
2490	vn = varop.split('\|')[0]
2491	op = varop.split('\|')[1]
2492	varns.append(vn)
2493	opns.append(op)
2494	if varop == varops[0]:
2495	allvarequal = True
2496	allopequal = True
2497	varinfig = vn
2498	opinfig = op
2499	else:
2500	if vn != varinfig: allvarequal = False
2501	if op != opinfig: allopequal = False
2502
2503	Nvars = len(varns)
2504	Nops = len(opns)
2505
2506	if allvarequal:
2507	titfig = titfig + '!' + varns[0]
2508	if allopequal:
2509	opS = optitle(op,explop)
2510	titfig = titfig + opS
2511	else:
2512	for opn in opns:
2513	opS = optitle(opn,explop)
2514	if opn == opns[0]:
2515	titfig = titfig + opS
2516	elif opn == opns[Nops-1]:
2517	titfig = titfig + '!&!' + opS
2518	else:
2519	titfig = titfig + ',!' + opS
2520	else:
2521	if allopequal:
2522	opS = optitle(op,explop)
2523	for vn in varns:
2524	if vn == varns[0]:
2525	titfig = titfig + '!' + vn
2526	elif vn == varns[Nvars-1]:
2527	titfig = titfig + '!&!' + vn
2528	else:
2529	titfig = titfig + ',!' + vn
2530	titfig = titfig + opS
2531	else:
2532	for ivop in range(Nvars):
2533	vn = varns[ivop]
2534	op = opns[ivop]
2535	vnop = vn + optitle(op,explop)
2536
2537	if vn == varns[0]:
2538	titfig = titfig + '!' + vnop
2539	elif vn == varns[Nvars-1]:
2540	titfig = titfig + '!&!' + vnop
2541	else:
2542	titfig = titfig + ',!' + vnop
2543
2544	return titfig.replace('!!','!')
2545	#expops = {'dimvarvalue':'@', 'last':'last', 'pinterp':'pinterp', 'xmean':'xmean', 'tmean':'tmean'}
2546
2547	def draw_plots(config, plots, mod, exp, odir, allvarcomp, figscr, debug):
2548	""" Function to draw all plots
2549	config= Configuration of the experiment
2550	plots= dictionary with the plots
2551	mod= model of the plots
2552	exp= experiment of the plots
2553	odir= output experiment folder
2554	allvarcomp= dictionary with all the variables to compute and their information
2555	figscr= whether figures should be done from the scratch or not
2556
2557	* Plot as
2558	{[kplot]} = [varn1]\|[op1]#[varn2]\|[op2]#[...[varnN]\|[opN]], ...
2559	[kplot] ___
2560	diffmap2Dsfc: 2D map of surface differences values of 1 variable
2561	diffmap2Dz: 2D map of 3D differences values of 1 variable
2562	map2Dsfc: 2D map of surface values of 1 variable
2563	map3D: 2D map of 3D values of 1 variable
2564	shadconthovmsfc: Hovmoeller diagrams of 2 variable at the surface in shadow and the other in contourn
2565	shadcont2Dsfc: 2D map of shadow (1st variable) and countour (2nd variable) [stvar1]#[stvar2]
2566	shadcont2Dzsec: 2D map of vertical section of 2 variables one in shadow and the other in contourn
2567	[varn]
2568	variable
2569	[op]
2570	'+' separated list of operations
2571	in figures with more than 1 variable, use '#' to separate the [varn]\|[op]
2572	"""
2573	fname = 'draw_plots'
2574
2575	os.chdir(odir)
2576
2577	# Dictionary with the operations with surnames for the operated variable
2578	opersurnames = {}
2579	opsur = gen.get_specdictionary_HMT(config, H='opsur_',M='',T='')
2580	for opsr in opsur.keys():
2581	opn = opsr.split('_')[1]
2582	vls = opsur[opsr].split(':')
2583	opersurnames[opn] = vls
2584
2585	# time values
2586	# Units time for the plots
2587	rd = config['CFreftime']
2588	tunits = config['CFunitstime'] + '!since!' + rd[0:4] + '-' + rd[4:6] + '-' + \
2589	rd[6:8] + '!' + rd[8:10] + ':' + rd[10:12] + ':' + rd[12:14]
2590	# time ticks kind
2591	tkind = config['timekind']
2592	# time ticks format
2593	tfmt = config['timefmt']
2594	# time axis label
2595	tlab = config['timelabel']
2596	timevals = [tunits, tkind, tfmt, tlab]
2597
2598	# Dictionary of plot specificities
2599	specplotkeyn = 'specificvarplot'
2600	plotspecifics = {}
2601	if config.has_key(specplotkeyn):
2602	# [minval]: minimum value
2603	# [maxval]: minimum value
2604	# [colorbar]: name of the colorbar (from matplotlib) to use
2605	# [cntformat]: format of the contour labels
2606	# [colorcnt]: color for the countor lines
2607	plotspecs = config[specplotkeyn].split(':')
2608	for pltspc in plotspecs:
2609	pltvls = pltspc.split('\|')
2610	vn = pltvls[0]
2611	op = pltvls[1]
2612	fn = pltvls[2]
2613	plotspecifics[fn + '_' + vn + '_' + op] = pltvls[3:]
2614	if debug:
2615	print 'Specific values for plots _______'
2616	gen.printing_dictionary(plotspecifics)
2617
2618	# Kind of figures
2619	kindfigure = config['kindfig']
2620
2621	# Graphical labels and configuration
2622	modgc, expgc = graphical_characteristics(config, debug)
2623	modv = modgc[mod]
2624	modlab = modv.label
2625	expv = expgc[mod+'/'+exp]
2626	explab = expv.label
2627
2628	# Map value
2629	mapvalue = config['mapval']
2630
2631	# pythone scripts HOME
2632	pyHOME = config['pyHOME']
2633
2634	# Title-text of operations
2635	opexplained = {}
2636	optits = config['titleoperations'].split(':')
2637	for optit in optits:
2638	opn = optit.split('\|')[0]
2639	opt = optit.split('\|')[1]
2640	opexplained[opn] = opt
2641	if debug:
2642	print 'Titles for operations _______'
2643	gen.printing_dictionary(opexplained)
2644
2645	for kplot in plots.keys():
2646	varsplt = plots[kplot]
2647	for varplt in varsplt:
2648	if debug:
2649	print " printing '" + kplot + "' var ':" + varplt + "'..."
2650	varops = varplt.split('#')
2651
2652	# CF variables in plot
2653	CFvarsplot = []
2654	# Files in plot
2655	filesplot = []
2656	# Variables in plot within the files
2657	varsplot = []
2658	# Dims in figure
2659	dimsplot = []
2660	# pictoric values in figure
2661	pictplot = []
2662	# Name of the figure
2663	figname = ''
2664	# Title of the figure
2665	titfigure = ''
2666
2667	ivp = 0
2668	for varop in varops:
2669	vn = varop.split('\|')[0]
2670	op = varop.split('\|')[1]
2671
2672	# CF variables in plot
2673	CFvarsplot.append(vn)
2674
2675	vnopS = vn + '_' + op
2676	if not allvarcomp.has_key(vnopS):
2677	print errmsg
2678	print ' ' + fname + ": no file for variable-operation '" + \
2679	vnopS + "' !!"
2680	vopvals = allvarcomp[vnopS]
2681	headf = vopvals[0]
2682	globalP = vopvals[3]
2683	gP = pinterpS(globalP)
2684
2685	filen = vn + '_' + headf + gP + '_' + op.replace('+','_') + '.nc'
2686	filesplot.append(filen)
2687	# Do we have processed the given variable?
2688	if not os.path.isfile(filen):
2689	print warnmsg
2690	print " " + fname + ": there is no file for variable '" + varop \
2691	+ "' skiping it !!"
2692	break
2693
2694	# Name of the variable inside the file
2695	vnsur = varnoper(vn, op, opersurnames)
2696	varsplot.append(vnsur)
2697
2698	# Dimensions in file
2699	try:
2700	with gen.Capturing() as output:
2701	dims = ncvar.idims(filen)
2702	except:
2703	print errmsg
2704	print 'ncvar.idims('+filen+')'
2705	for s1out in output: print s1out
2706	quit(-1)
2707
2708	dimsplot.append(dims)
2709
2710	# pictoric values for the figure
2711	Sfivaop = kplot + '_' + vn + '_' + op
2712	if plotspecifics.has_key(Sfivaop):
2713	pictvals = plotspecifics[Sfivaop]
2714	else:
2715	Vvals = gen.variables_values(vn)
2716	pictvals = [Vvals[2], Vvals[3], Vvals[6], '%g', 'fixc', 'black']
2717
2718	pictplot.append(pictvals)
2719
2720	# Header of the name of the figure
2721	if ivp == 0:
2722	figname = kplot +'_'+ vn + '_' + headf + '_' + op.replace('+','-')
2723	else:
2724	figname = figname + '-'+vn+'_'+headf+'_'+op.replace('+','-')
2725
2726	ivp = ivp + 1
2727	# End of variable-operation
2728	figname = figname + '.' + kindfigure
2729
2730	# Removig double '..' (from `dimvarvalue')
2731	figname = figname.replace('..', '.')
2732
2733	# Title of figure
2734	titfigure = create_figure_title(modlab, explab, varops, opexplained)
2735
2736	draw_plot(kplot, CFvarsplot, filesplot, varsplot, dimsplot, pictplot, \
2737	figname, titfigure, kindfigure, mapvalue, timevals, expgc, odir, \
2738	pyHOME, figscr, debug)
2739
2740	# End of variables-operations
2741
2742	# End of kind of plots
2743
2744	if debug: print " End of '" + fname + "' "
2745
2746	return
2747
2748	def get_differences_var(vc,kdiff,db):
2749	""" Function to provide the operations to make for each variable from kdiff ('DIFFOP_' or 'DIFFVAR_') dictionary
2750	vc= kdiff dictionary, dictionary with all the parameters started with kdiff
2751	kdiff= kind of differences 'op', 'var'
2752	"""
2753	fname = 'get_differences_var'
2754
2755	if kdiff == 'op':
2756	diffn = 'DIFFOP'
2757	elif kdiff == 'var':
2758	diffn = 'DIFFVAR'
2759	else:
2760	print errmsg
2761	print ' ' + fname + ": differences '" + kdiff + "' not ready !!"
2762	quit(-1)
2763	LD = len(diffn + '_')
2764
2765	iop = 1
2766	# list of operations by difference
2767	doopers = {}
2768	# operations by variable
2769	operationsvar = {}
2770	# individual operations by variable (not repeated)
2771	indivoperationsvar = {}
2772
2773	# Variables with a calculation whic requires vertical interpolation to all the
2774	# file (operations stating by [kdiff]'_pinterp')
2775	LVp = len(diffn + '_pinterp')
2776	varglobalp = []
2777
2778	for oper in vc.keys():
2779	Loper = len(oper)
2780	opn = oper[LD:Loper+1]
2781	vns = vc[oper].split(':')
2782	ops1 = opn.split('+')
2783	doopers[opn] = ops1
2784	for vn in vns:
2785	if not operationsvar.has_key(vn):
2786	operationsvar[vn] = [opn]
2787	indivoperationsvar[vn] = ops1
2788	else:
2789	opers = operationsvar[vn]
2790	opers.append(opn)
2791	operationsvar[vn] = opers
2792	opers1 = indivoperationsvar[vn]
2793	for op1 in ops1:
2794	if not gen.searchInlist(opers1, op1):
2795	opers1.append(op1)
2796	indivoperationsvar[vn] = opers1
2797
2798	if oper[0:LVp] == diffn + '_pinterp':
2799	for vn in vns:
2800	if not gen.searchInlist(varglobalp,vn): varglobalp.append(vn)
2801
2802	iop = iop + 1
2803
2804	if db:
2805	print ' operations to make _______'
2806	gen.printing_dictionary(doopers)
2807	print ' operations by variable _______'
2808	gen.printing_dictionary(operationsvar)
2809	print ' individual operations by variable _______'
2810	gen.printing_dictionary(indivoperationsvar)
2811	print ' variables with the vertical interpolation for all the file _______'
2812	print ' #', varglobalp
2813
2814	if db: print " End of '" + fname + "' "
2815
2816	return doopers, operationsvar, indivoperationsvar, varglobalp
2817
2818	def diffvarop_listconstruct(config, mods, exps, reprj, odir, debug):
2819	""" Function to create the list of differences to compute and draw
2820	config= Configuration of the experiment
2821	mods= list with the models to use
2822	exps= list with the experiments to use
2823	reprj= list with whether re-rpojection needs to be done
2824	odir= output differences folder
2825	"""
2826	fname='diffvarop_listconstruct'
2827
2828	diffop = gen.get_specdictionary_HMT(config, H='DIFFOP_')
2829	diffvar = gen.get_specdictionary_HMT(config, H='DIFFVAR_')
2830
2831	if debug:
2832	if diffop is not None:
2833	print " 'op' differences ________"
2834	gen.printing_dictionary(diffop)
2835	if diffvar is not None:
2836	print " 'var' differences ________"
2837	gen.printing_dictionary(diffvar)
2838
2839	# Getting variable characteristics from each model/experiment
2840	idir1 = config['ofold'] + '/' + mods[0] + '/' + exps[0]
2841	idir2 = config['ofold'] + '/' + mods[1] + '/' + exps[1]
2842
2843	fvarcomp = 'varcompute.inf'
2844	if reprj[0]: fvc1 = 'reproj_' + fvarcomp
2845	else: fvc1 = fvarcomp
2846
2847	if reprj[1]: fvc2 = 'reproj_' + fvarcomp
2848	else: fvc2 = fvarcomp
2849
2850	files1, testfiles1, allcompvar1, Nvar1= read_varcomp_file(idir1 + '/' + fvc1)
2851	files2, testfiles2, allcompvar2, Nvar2= read_varcomp_file(idir2 + '/' + fvc2)
2852
2853	diffops = {}
2854	if diffop is not None:
2855	# Getting 'op' differences characteristics
2856	doops, opvar, indivopvar, varglobalp = get_differences_var(diffop,'op',debug)
2857
2858	Ndiffop = 0
2859	for vn in opvar.keys():
2860	vnops = opvar[vn]
2861	for op in vnops:
2862	vnop = vn + '_' + op
2863	if not allcompvar1.has_key(vnop):
2864	print warnmsg
2865	print ' ' + fname + ": DIFFOP variable+operation '" + vnop + \
2866	"' in '" + mods[0] + '/' + exps[0] + "' was not computed !!"
2867	print ' skipping it!'
2868	print ' variables computed:', allcompvar1
2869	break
2870	if not allcompvar2.has_key(vnop):
2871	print warnmsg
2872	print ' ' + fname + ": DIFFOP variable+operation '" + vnop + \
2873	"' in '" + mods[1] + '/' + exps[1] + "' was not computed !!"
2874	print ' skipping it!'
2875	print ' variables computed:', allcompvar2
2876	break
2877	vals1 = allcompvar1[vnop]
2878	vals2 = allcompvar2[vnop]
2879
2880	headerf1 = vals1[0]
2881	headerf2 = vals2[0]
2882
2883	diffops[vnop] = [mods[0],mods[1],exps[0],exps[1],headerf1,headerf2]
2884
2885	Ndiffop = Ndiffop + 1
2886	else:
2887	Ndiffop = 0
2888
2889	diffvars = {}
2890	if diffvar is not None:
2891	# Getting 'var' differences characteristics
2892	doops,opvar,indivopvar,varglobalp = get_differences_var(diffvar,'var',debug)
2893
2894	Ndiffvar = 0
2895	for vn in opvar.keys():
2896	vnops = opvar[vn]
2897	for op in vnops:
2898	vnop = vn + '_' + op
2899	if not allcompvar1.has_key(vnop):
2900	print warnmsg
2901	print ' ' + fname + ": DIFFVAR variable+operation '" + vnop + \
2902	"' in '" + mods[0] + '/' + exps[0] + "' was not computed !!"
2903	print ' skipping it!'
2904	print ' variables computed:', allcompvar1
2905	break
2906	if not allcompvar2.has_key(vnop):
2907	print warnmsg
2908	print ' ' + fname + ": DIFFVAR variable+operation '" + vnop + \
2909	"' in '" + mods[1] + '/' + exps[1] + "' was not computed !!"
2910	print ' skipping it!'
2911	print ' variables computed:', allcompvar2
2912	break
2913	vals1 = allcompvar1[vnop]
2914	vals2 = allcompvar2[vnop]
2915
2916	headerf1 = vals1[0]
2917	headerf2 = vals2[0]
2918
2919	diffvars[vnop] = [mods[0],mods[1],exps[0],exps[1],headerf1,headerf2]
2920
2921	Ndiffvar = Ndiffvar + 1
2922	else:
2923	Ndiffvar = 0
2924
2925	if diffop is not None:
2926	Sopdiffs = gen.dictKeysVals_stringList(diffops)
2927	else:
2928	Sopdiffs = 'none'
2929	# Outwritting the op diffferences file to avoid next time
2930	objf = open(odir + '/diffop.inf', 'w')
2931	objf.write('differences: ' + Sopdiffs + '\n')
2932	objf.write('Ndiff: ' + str(Ndiffop) + '\n')
2933	objf.close()
2934
2935	if diffvar is not None:
2936	Svardiffs = gen.dictKeysVals_stringList(diffvars)
2937	else:
2938	Svardiffs = 'none'
2939	# Outwritting the var diffferences file to avoid next time
2940	objf = open(odir + '/diffvar.inf', 'w')
2941	objf.write('differences: ' + Svardiffs + '\n')
2942	objf.write('Ndiff: ' + str(Ndiffvar) + '\n')
2943	objf.close()
2944
2945	if debug: print " End of '" + fname + "' "
2946
2947	return diffops, diffvars, Ndiffop, Ndiffvar
2948
2949	def read_diff_file(difffile):
2950	""" Function to read the file with the information about the differences
2951	difffile= file with the information
2952	"""
2953	fname = 'read_diff_file'
2954
2955	if not os.path.isfile(difffile):
2956	print errormsg
2957	print ' ' + fname + ": differences file '" + difffile + "' does not exist !!"
2958	quit(-1)
2959
2960	objf = open(difffile, 'r')
2961	for line in objf:
2962	if line[0:1] != '#' and len(line) > 1:
2963	values = line.replace('\n','').split(' ')
2964	if values[0] == 'differences:':
2965	if values[1] != 'none':
2966	diffs = gen.stringList_dictKeysVals(values[1])
2967	else:
2968	diffs = {}
2969	elif values[0] == 'Ndiff:':
2970	Ndiffs = int(values[1])
2971
2972	objf.close()
2973
2974	return diffs, Ndiffs
2975
2976	def compute_op_diffs(config, diffallop, odir, diffscr, debug):
2977	""" Function to compute operation differences
2978	config= experiment configuration
2979	diffallop= dictonary with the differences to compute
2980	odir= output folder
2981	diffscr= wether it should be done from the scratch
2982	"""
2983	fname = 'compute_op_diffs'
2984
2985	# output folder
2986	ofold = config['ofold']
2987
2988	# Home of the python scripts
2989	pyH = config['pyHOME']
2990
2991	# opsur = operation surnames
2992	opsur = gen.get_specdictionary_HMT(config, H='opsur_',M='',T='')
2993	Opsurs = {}
2994	for opk in opsur:
2995	opn = opk.split('_')[1]
2996	vals = opsur[opk]
2997	Opsurs[opn] = vals.split(':')
2998
2999	# Getting in working dir
3000	os.chdir(odir)
3001
3002	# CF dimensions
3003	CFdims = ['lon', 'lat', 'pres', 'time']
3004
3005	# Trakcing file
3006	trkobjf = open(odir + '/all_diffop.inf', 'a')
3007
3008	for vnop in diffallop.keys():
3009	vn = vnop.split('_')[0]
3010	op = vnop.split('_')[1]
3011	opS = op.replace('+','_')
3012
3013	# `p' header add related to 'pinterp'
3014	if opS.find('pinterp') != -1: SgP = 'p'
3015	else: SgP = ''
3016
3017	# Variable name within the file
3018	vninF = varnoper(vn, op, Opsurs)
3019
3020	vals = diffallop[vnop]
3021	mod1 = vals[0]
3022	mod2 = vals[1]
3023	exp1 = vals[2]
3024	exp2 = vals[3]
3025	headerf1 = vals[4]
3026	headerf2 = vals[5]
3027	modexpdiff = mod2 + '/' + exp2 + ' - ' + mod1 + '/' + exp1
3028	modexpdiffS = mod2 + '-' + exp2 + '_' + mod1 + '-' + exp1
3029
3030	ifile1 = ofold + '/' + mod1 + '/' + exp1 + '/' + vn + '_' + headerf1 + SgP + \
3031	'_' + opS + '.nc'
3032	ifile2 = ofold + '/' + mod2 + '/' + exp2 + '/' + vn + '_' + headerf2 + SgP + \
3033	'_' + opS + '.nc'
3034	difffilen = odir + '/' + vn + '_diffop_' + modexpdiffS + '_' + opS + '.nc'
3035
3036	if diffscr:
3037	sout = sub.call('rm ' + difffilen + ' >& /dev/null', shell=True)
3038
3039	if not os.path.isfile(difffilen):
3040	if debug:
3041	print " Computing operation difference '" + op + "' of '" + vn + \
3042	"' for: '" + modexpdiff
3043	print " var in file: '" + vninF + "'"
3044
3045	# Range of the dimensions
3046	for CFd in CFdims:
3047	if CFd == CFdims[0]:
3048	CFdimS = CFd + '\|' + CFd + '\|-1'
3049	else:
3050	CFdimS = CFdimS + ';' + CFd + '\|' + CFd + '\|-1'
3051
3052	ncvar.ivattrs(ifile2,vninF)
3053
3054	# Attributes of the variable
3055	try:
3056	with gen.Capturing() as output:
3057	varattrs = ncvar.ivattrs(ifile2,vninF)
3058	except:
3059	print errmsg
3060	print 'ncvar.ivarattrs(' + ifile2 + ',' + vninF + ')'
3061	for s1out in output: print s1out
3062	quit(-1)
3063
3064	if debug:
3065	for s1out in output: print s1out
3066	varvals = vninF + ',' + varattrs['long_name'][0] + ',' + \
3067	varattrs['units'][0]
3068
3069	values = CFdimS + '@' + 'add\|' + ifile2 + '\|' + vninF + '%' + CFdimS + \
3070	'@' + 'sub\|' + ifile1 + '\|' + vninF
3071	pyins = 'python ' + pyH + "/nc_var.py -o compute_opersvarsfiles -S '" + \
3072	values + "' -v '" + varvals + "'"
3073
3074	try:
3075	with gen.Capturing() as output:
3076	ncvar.compute_opersvarsfiles(values,varvals)
3077	except:
3078	print errmsg
3079	print 'ncvar.compute_opersvarsfiles(' + values + ',' + varvals + ')'
3080	for s1out in output: print s1out
3081	quit(-1)
3082
3083	sout = sub.call('mv opersvarsfiles_'+vninF+'.nc ' + difffilen, shell=True)
3084
3085	# keeping all differences
3086	trkobjf.write('\n')
3087	trkobjf.write("#" + vn + ' ' + op + '\n')
3088	trkobjf.write( pyins + '\n')
3089
3090	trkobjf.close()
3091	if debug: print " End of '" + fname + "' "
3092
3093	return
3094
3095	def compute_diff_statistics(Ecnf, filen, ofold, varn, Opers, scr, db):
3096	""" Function to compute statistics from var diff files
3097	Ecnf= dictionary with the configuration of the experiment
3098	filen= variable difference file to use
3099	ofold= directory to write the output files
3100	varn= name of the variable
3101	Opers= kind of operation: (as possible multiple consecutive combination of operations separated by '+'
3102	[calc1]+[calc2] will compute first [calc1] and then [calc2]
3103	acc: temporal accumulated values
3104	diff: differences between models
3105	dimvarvalue~[dimvarn]~[value]: Slicing along the index at the nearest given value of a dimension-variable
3106	direct: no statistics
3107	last: last temporal value
3108	Lmean: latitudinal mean values
3109	Lsec: latitudinal section (latitudinal value must be given, [var]@[lat])
3110	lmean: longitudinal mean values
3111	lsec: longitudinal section (longitudinal value must be given, [var]@[lat])
3112	pinterp: pressure interpolation (to the given $plevels)
3113	tmean: temporal mean values
3114	tstd: temporal standard deviation values
3115	tturb: Taylor's turbulence decomposition value (x - <x>) for time
3116	tvar: temporal variance values
3117	xmean: x-axis mean values
3118	xvar: x-axis variance values
3119	ymean: y-axis mean values
3120	zsum: vertical aggregated values
3121	scr= should it be done from the scratch?
3122	"""
3123	fname='compute_diff_statistics'
3124
3125	# Full header of file
3126	Lfilen = len(filen)
3127	Hfile = filen[0:Lfilen-3]
3128
3129	# CF dimension-variables name
3130	OpersS = '+'.join(Opers)
3131	if OpersS.find('pinterp') != -1 or filen.find('pinterp') != -1:
3132	varnCFs = ['lon', 'lat', 'pres', 'time']
3133	else:
3134	varnCFs = ['lon', 'lat', 'time']
3135
3136	# Variable-dimension CF dictionary
3137	CFdimvardict = {'lon': 'lon', 'lat': 'lat', 'pres': 'pres', 'time': 'time'}
3138
3139	# Python scripts HOME
3140	pyH = Ecnf['pyHOME']
3141
3142	# opsur = operation surnames
3143	opsur = gen.get_specdictionary_HMT(Ecnf, H='opsur_',M='',T='')
3144	Opsurs = {}
3145	for opk in opsur:
3146	opn = opk.split('_')[1]
3147	vals = opsur[opk]
3148	Opsurs[opn] = vals.split(':')
3149
3150	# Getting in working dir
3151	os.chdir(ofold)
3152
3153	# File to keep track of all the statistics of var differences
3154	otrackf = open(ofold + '/all_vardiffstatistics.inf', 'a')
3155
3156	if db:
3157	print " computing statistics of diff variable: '", varn ,"' operation '"+ \
3158	OpersS + "' using file '" + filen + " ...'"
3159
3160	for op in Opers:
3161	# File name from previous operations, and name of the variable within the
3162	# file (some operations change the name of the variable)
3163	if op == Opers[0]:
3164	Fopers = op
3165	prevfile = filen
3166	vninF = varn
3167	else:
3168	Fopers = Fopers + '_' + op
3169	prevfile = fileon
3170	fileon = Hfile + '_' + Fopers + '.nc'
3171
3172	SvarnCFs = ',' + ','.join(varnCFs)
3173	CFvarnp = vninF + SvarnCFs
3174
3175	if scr:
3176	sout = sub.call('rm ' + fileon + ' >& /dev/null', shell=True)
3177
3178	# Just produce file in case output file does not exist
3179	if not os.path.isfile(fileon):
3180	if db:
3181	print ' ' + fname + ": creation of file '" + fileon + "' ..."
3182	dofile = True
3183	else:
3184	dofile = False
3185
3186	# Variables to be kept in the final file
3187	varkeep = []
3188
3189	if op == 'acc':
3190	# temporal accumulated values
3191	print " " + fname + ": kind '" + op + "' not ready !!"
3192	wrongstats.append(varn + '_' + opers)
3193	break
3194
3195	elif op[0:11] == 'dimvarvalue':
3196	# Slicing along the index at the nearest given value of a dimension-variable
3197	dimvarn = op.split('~')[1]
3198	dimvalue = op.split('~')[2]
3199	vals = dimvarn + ',' + dimvalue + ',' + dimvalue + ',0'
3200	if dofile:
3201	try:
3202	with gen.Capturing() as output:
3203	ncvar.DataSetSection_multivars(vals,prevfile,CFvarnp)
3204	except:
3205	print errmsg
3206	print 'DataSetSection_multivars('+vals+',', prevfile, ',' + \
3207	CFvarnp + ')'
3208	for s1out in output: print s1out
3209	quit(-1)
3210
3211	if db:
3212	for s1out in output: print s1out
3213
3214	sout = sub.call('mv DataSetSection_multivars.nc '+fileon, shell=True)
3215
3216	# Keeping the operations
3217	pyins=pyH + "/nc_var.py -o DataSetSection_multivars -S '" + vals + \
3218	"' -f " + prevfile + " -v " + CFvarnp
3219	otrackf.write("\n")
3220	otrackf.write("# " + CFvarnp + " " + Fopers + "\n")
3221	otrackf.write(pyins + "\n")
3222
3223	# removing the given variable-dimension
3224	varnCFs.remove(dimvarn)
3225
3226	elif op == 'direct':
3227	# no statistics
3228	if dofile:
3229	sout = sub.call('mv ' + prevfile + ' ' + fileon, shell=True)
3230	elif op == 'last':
3231	# last temporal value
3232	vals='time,-9,0,0'
3233	if dofile:
3234	try:
3235	with gen.Capturing() as output:
3236	ncvar.DataSetSection(vals,prevfile)
3237	except:
3238	print errmsg
3239	print 'DataSetSection('+vals+',', prevfile, ')'
3240	for s1out in output: print s1out
3241	quit(-1)
3242
3243	if db:
3244	for s1out in output: print s1out
3245
3246	hprevfile = prevfile[0:len(prevfile)-3]
3247
3248	sout = sub.call('mv ' + hprevfile + '_time_B-9-E0-I0.nc ' + fileon, \
3249	shell=True)
3250
3251	# Keeping the operations
3252	pyins=pyH + "/nc_var.py -o DataSetSection -S '" + vals + "' -f " + \
3253	prevfile
3254	otrackf.write("\n")
3255	otrackf.write("# " + varn + " " + Fopers + "\n")
3256	otrackf.write(pyins + "\n")
3257
3258	elif op =='Lmean':
3259	# latitudinal mean values
3260	print " " + fname + ": kind '" + op + "' not ready !!"
3261	wrongstats.append(varn + '_' + opers)
3262	break
3263	elif op =='Lsec':
3264	# latitudinal section (latitudinal value must be given, [var]@[lat])
3265	print " " + fname + ": kind '" + op + "' not ready !!"
3266	wrongstats.append(varn + '_' + opers)
3267	break
3268	elif op =='lmean':
3269	# longitudinal mean values
3270	print " " + fname + ": kind '" + op + "' not ready !!"
3271	wrongstats.append(varn + '_' + opers)
3272	break
3273	elif op =='lsec':
3274	# longitudinal section (longitudinal value must be given, [var]@[lon])
3275	print " " + fname + ": kind '" + op + "' not ready !!"
3276	wrongstats.append(varn + '_' + opers)
3277	break
3278	elif op == 'tmean':
3279	# temporal mean values
3280	vals='time\|-1,time,mean,' + ':'.join(varnCFs)
3281	dims = gen.dictvar_listS(varnCFs,CFdimvardict,',','@')
3282	if dofile:
3283	try:
3284	with gen.Capturing() as output:
3285	ncvar.file_oper_alongdims(vals,prevfile,CFvarnp)
3286	except:
3287	print errmsg
3288	print 'file_oper_alongdims('+vals+',', prevfile, ','+CFvarnp+')'
3289	for s1out in output: print s1out
3290	quit(-1)
3291
3292	if db:
3293	for s1out in output: print s1out
3294
3295	sout = sub.call('mv file_oper_alongdims_mean.nc '+fileon, shell=True)
3296
3297	# Keeping the operations
3298	pyins=pyH + "/nc_var.py -o file_oper_alongdims -S '" + vals + \
3299	"' -f " + prevfile + " -v " + CFvarnp
3300	otrackf.write("\n")
3301	otrackf.write("# " + varn + " " + Fopers + "\n")
3302	otrackf.write(pyins + "\n")
3303
3304	# removing dimension variable-dimension 'time'
3305	varnCFs.remove('time')
3306
3307	varkeep.append('timestats')
3308
3309	elif op == 'tstd':
3310	# temporal standard deviation values
3311	vals='time\|-1,time,std,' + ':'.join(varnCFs) + ':' + vdnz
3312	dims = gen.dictvar_listS(varnCFs,CFdimvardict,',','@') + dnz+'@'+vdnz
3313	if dofile:
3314	try:
3315	with gen.Capturing() as output:
3316	ncvar.file_oper_alongdims(vals,prevfile,CFvarnp)
3317	except:
3318	print errmsg
3319	print 'file_oper_alongdims('+vals+',', prevfile, ','+CFvarnp+')'
3320	for s1out in output: print s1out
3321	quit(-1)
3322
3323	if db:
3324	for s1out in output: print s1out
3325
3326	sout = sub.call('mv file_oper_alongdims_std.nc '+fileon, shell=True)
3327
3328	# Keeping the operations
3329	pyins=pyH + "/nc_var.py -o file_oper_alongdims -S '" + vals + \
3330	"' -f " + prevfile + " -v " + CFvarnp
3331	otrackf.write("\n")
3332	otrackf.write("# " + varn + " " + Fopers + "\n")
3333	otrackf.write(pyins + "\n")
3334
3335	# removing dimension variable-dimension 'time'
3336	varnCFs.remove('time')
3337
3338	varkeep.append('timestats')
3339
3340	elif op == 'tturb':
3341	# temporal turbulent values
3342	vals='time\|-1,time,turb,' + ':'.join(varnCFs)
3343	dims = gen.dictvar_listS(varnCFs,CFdimvardict,',','@')
3344	if dofile:
3345	try:
3346	with gen.Capturing() as output:
3347	ncvar.file_oper_alongdims(vals,prevfile,CFvarnp)
3348	except:
3349	print errmsg
3350	print 'file_oper_alongdims('+vals+',', prevfile, ','+CFvarnp+')'
3351	for s1out in output: print s1out
3352	quit(-1)
3353
3354	if db:
3355	for s1out in output: print s1out
3356
3357	sout = sub.call('mv file_oper_alongdims_turb.nc '+fileon, shell=True)
3358
3359	# Keeping the operations
3360	pyins=pyH + "/nc_var.py -o file_oper_alongdims -S '" + vals + \
3361	"' -f " + prevfile + " -v " + CFvarnp
3362	otrackf.write("\n")
3363	otrackf.write("# " + varn + " " + Fopers + "\n")
3364	otrackf.write(pyins + "\n")
3365
3366	varkeep.append('timestats')
3367
3368	elif op == 'tvar':
3369	# temporal variance values (Taylor's turbulence)
3370	vals='time\|-1,time,var,' + ':'.join(varnCFs) + ':' + vdnz
3371	dims = gen.dictvar_listS(varnCFs,CFdimvardict,',','@') + dnz+'@'+vdnz
3372	if dofile:
3373	try:
3374	with gen.Capturing() as output:
3375	ncvar.file_oper_alongdims(vals,prevfile,CFvarnp)
3376	except:
3377	print errmsg
3378	print 'file_oper_alongdims('+vals+',', prevfile, ','+CFvarnp+')'
3379	for s1out in output: print s1out
3380	quit(-1)
3381
3382	if db:
3383	for s1out in output: print s1out
3384
3385	sout = sub.call('mv file_oper_alongdims_var.nc '+fileon, shell=True)
3386
3387	# Keeping the operations
3388	pyins=pyH + "/nc_var.py -o file_oper_alongdims -S '" + vals + \
3389	"' -f " + prevfile + " -v " + CFvarnp
3390	otrackf.write("\n")
3391	otrackf.write("# " + varn + " " + Fopers + "\n")
3392	otrackf.write(pyins + "\n")
3393
3394	# removing dimension variable-dimension 'time'
3395	varnCFs.remove('time')
3396
3397	varkeep.append('timestats')
3398
3399	elif op == 'xmean':
3400	# x-axis mean values
3401	vals='lon\|-1,lon,mean,' + ':'.join(varnCFs)
3402	dims = gen.dictvar_listS(varnCFs,CFdimvardict,',','@')
3403	if dofile:
3404	try:
3405	with gen.Capturing() as output:
3406	ncvar.file_oper_alongdims(vals,prevfile,CFvarnp)
3407	except:
3408	print errmsg
3409	print 'file_oper_alongdims('+vals+',', prevfile, ','+CFvarnp+')'
3410	for s1out in output: print s1out
3411	quit(-1)
3412
3413	if db:
3414	for s1out in output: print s1out
3415
3416	sout = sub.call('mv file_oper_alongdims_mean.nc '+fileon, shell=True)
3417
3418	# Keeping the operations
3419	pyins=pyH + "/nc_var.py -o file_oper_alongdims -S '" + vals + \
3420	"' -f " + prevfile + " -v " + CFvarnp
3421	otrackf.write("\n")
3422	otrackf.write("# " + varn + " " + Fopers + "\n")
3423	otrackf.write(pyins + "\n")
3424
3425	# removing dimension variable-dimension 'lon'
3426	varnCFs.remove('lon')
3427
3428	varkeep.append('lonstats')
3429
3430	elif op == 'xvar':
3431	# x-axis variance values
3432	vals='lon\|-1,lon,var,' + ':'.join(varnCFs)
3433	dims = gen.dictvar_listS(varnCFs,CFdimvardict,',','@')
3434	if dofile:
3435	try:
3436	with gen.Capturing() as output:
3437	ncvar.file_oper_alongdims(vals,prevfile,CFvarnp)
3438	except:
3439	print errmsg
3440	print 'file_oper_alongdims('+vals+',', prevfile, ','+CFvarnp+')'
3441	for s1out in output: print s1out
3442	quit(-1)
3443
3444	if db:
3445	for s1out in output: print s1out
3446
3447	sout = sub.call('mv file_oper_alongdims_var.nc '+fileon, shell=True)
3448
3449	# Keeping the operations
3450	pyins=pyH + "/nc_var.py -o file_oper_alongdims -S '" + vals + \
3451	"' -f " + prevfile + " -v " + CFvarnp
3452	otrackf.write("\n")
3453	otrackf.write("# " + varn + " " + Fopers + "\n")
3454	otrackf.write(pyins + "\n")
3455
3456	# removing dimension variable-dimension 'lon'
3457	varnCFs.remove('lon')
3458
3459	varkeep.append('lonstats')
3460
3461	elif op == 'ymean':
3462	# y-axis mean values
3463	vals='lat\|-1,lat,mean,' + ':'.join(varnCFs)
3464	dims = gen.dictvar_listS(varnCFs,CFdimvardict,',','@')
3465	if dofile:
3466	try:
3467	with gen.Capturing() as output:
3468	ncvar.file_oper_alongdims(vals,prevfile,CFvarnp)
3469	except:
3470	print errmsg
3471	print 'file_oper_alongdims('+vals+',', prevfile, ','+CFvarnp+')'
3472	for s1out in output: print s1out
3473	quit(-1)
3474
3475	if db:
3476	for s1out in output: print s1out
3477
3478	sout = sub.call('mv file_oper_alongdims_mean.nc '+fileon, shell=True)
3479
3480	# Keeping the operations
3481	pyins=pyH + "/nc_var.py -o file_oper_alongdims -S '" + vals + \
3482	"' -f " + prevfile + " -v " + CFvarnp
3483	otrackf.write("\n")
3484	otrackf.write("# " + varn + " " + Fopers + "\n")
3485	otrackf.write(pyins + "\n")
3486
3487	# removing dimension variable-dimension 'lat'
3488	varnCFs.remove('lat')
3489
3490	varkeep.append('latstats')
3491
3492	elif op == 'zsum':
3493	# vertical aggregated values
3494	print " " + fname + ": kind '" + op + "' not ready !!"
3495	wrongstats.append(varn + '_' + opers)
3496	break
3497	else:
3498	print errmsg
3499	print ' ' + fname + ": operation '" + op + "' not ready !!"
3500	quit(-1)
3501
3502	# End of kind of operation
3503
3504	# Variable name in file (vninF) changed due to operation
3505	# but only if previous operation does not the same 'statistic'
3506	chvn = gen.dictionary_key_list(Opsurs, op)
3507	if chvn is not None:
3508	oldvninF = vninF
3509	vninF = vninF + chvn
3510	CFvarnp = CFvarnp.replace(oldvninF,vninF)
3511
3512	if dofile:
3513	if len(varkeep) > 0:
3514	varkeepS = ',' + ','.join(varkeep)
3515	else:
3516	varkeepS = ''
3517
3518	# Adding such CF dimension variables which might not be in the
3519	# post-operation file
3520	try:
3521	with gen.Capturing() as output:
3522	varinfile = ncvar.ivars(fileon)
3523	except:
3524	print errmsg
3525	print 'ivars('+fileon+')'
3526	for s1out in output: print s1out
3527	# Removing file in order to make sure that it will be redone
3528	print ' ' + fname + " removing file '" + fileon + "' ..."
3529	sub.call('rm ' + fileon + ' >& /dev/null', shell=True)
3530	quit(-1)
3531
3532	for CFvn in varnCFs:
3533	if not gen.searchInlist(varinfile, CFvn):
3534	if db:
3535	print ' ' + fname + ": recupering CF variable '" + CFvn + "'"
3536	try:
3537	with gen.Capturing() as output:
3538	ncvar.fvaradd(prevfile+','+CFvn, fileon)
3539	except:
3540	print errmsg
3541	print 'fvaradd(' + prevfile + ',' + CFvn +', ' + fileon + ')'
3542	for s1out in output: print s1out
3543	# Removing file in order to make sure that it will be redone
3544	print ' ' + fname + " removing file '" + fileon + "' ..."
3545	sub.call('rm ' + fileon + ' >& /dev/null', shell=True)
3546	quit(-1)
3547
3548	if db:
3549	for s1out in output: print s1out
3550
3551	totalvarkeeps = CFvarnp + ',' + ','.join(varnCFs) + varkeepS
3552	try:
3553	with gen.Capturing() as output:
3554	oclean = ncvar.cleaning_varsfile(totalvarkeeps,fileon)
3555	except:
3556	print errmsg
3557	print 'cleaning_varsfile('+totalvarkeeps+','+fileon+')'
3558	for s1out in output: print s1out
3559	# Removing file in order to make sure that it will be redone
3560	print ' ' + fname + " removing file '" + fileon + "' ..."
3561	sub.call('rm ' + fileon + ' >& /dev/null', shell=True)
3562	quit(-1)
3563
3564	if db:
3565	for s1out in output: print s1out
3566
3567	# End of operations
3568	otrackf.close()
3569
3570	if db: print " End of '" + fname + "' "
3571
3572	return
3573
3574	def compute_var_diffs(config, diffallvar, odir, diffscr, debug):
3575	""" Function to compute variable differences
3576	config= experiment configuration
3577	diffallvar= dictonary with the differences to compute
3578	odir= output folder
3579	diffscr= wether it should be done from the scratch
3580	"""
3581	fname = 'compute_var_diffs'
3582
3583	# output folder
3584	ofold = config['ofold']
3585
3586	# Home of the python scripts
3587	pyH = config['pyHOME']
3588
3589	# opsur = operation surnames
3590	opsur = gen.get_specdictionary_HMT(config, H='opsur_',M='',T='')
3591	Opsurs = {}
3592	for opk in opsur:
3593	opn = opk.split('_')[1]
3594	vals = opsur[opk]
3595	Opsurs[opn] = vals.split(':')
3596
3597	# Getting in working dir
3598	os.chdir(odir)
3599
3600	# CF dimensions
3601	CFdims = ['lon', 'lat', 'pres', 'time']
3602
3603	# Trakcing file
3604	trkobjf = open(odir + '/all_diffvar.inf', 'a')
3605
3606	for vnop in diffallvar.keys():
3607	vn = vnop.split('_')[0]
3608	op = vnop.split('_')[1]
3609	opSfinal = op.replace('+','_')
3610
3611	lop = op.split('+')
3612	# `p' header add related to 'pinterp'
3613	if op.find('pinterp') != -1:
3614	print warnmsg
3615	print ' ' + fname + ': there is the vertical interpolation as operation'
3616	print ' variable differences will be computed from that files where '
3617	print ' vertical interpolation was just done'
3618	ipop = lop.index('pinterp')
3619	opS = '_' + '_'.join(lop[0:ipop+1])
3620	doops = lop[ipop+1:]
3621	SgP = 'p'
3622	vninF = varnoper(vn, '+'.join(lop[0:ipop+1]), Opsurs)
3623	print ' operations to perform:', doops
3624	else:
3625	SgP = ''
3626	opS = ''
3627	doops = lop
3628	vninF = vn
3629
3630	Sdoops = '+'.join(doops)
3631
3632	# Variable name within the file
3633
3634	vals = diffallvar[vnop]
3635	mod1 = vals[0]
3636	mod2 = vals[1]
3637	exp1 = vals[2]
3638	exp2 = vals[3]
3639	headerf1 = vals[4]
3640	headerf2 = vals[5]
3641	modexpdiff = mod2 + '/' + exp2 + ' - ' + mod1 + '/' + exp1
3642	modexpdiffS = mod2 + '-' + exp2 + '_' + mod1 + '-' + exp1
3643
3644	ifile1 = ofold + '/' + mod1 + '/' + exp1 + '/' + vn + '_' + headerf1 + SgP + \
3645	opS + '.nc'
3646	ifile2 = ofold + '/' + mod2 + '/' + exp2 + '/' + vn + '_' + headerf2 + SgP + \
3647	opS + '.nc'
3648	difffilen = odir + '/' + vn + '_diffvar_' + modexpdiffS + opS + '.nc'
3649	difffinalfilen = odir + '/' + vn + '_diffvar_' + modexpdiffS + opS + '_' + \
3650	Sdoops + '.nc'
3651
3652	if diffscr:
3653	sout = sub.call('rm ' + difffilen + ' >& /dev/null', shell=True)
3654	sout = sub.call('rm ' + difffinalfilen + ' >& /dev/null', shell=True)
3655
3656	if not os.path.isfile(difffinalfilen):
3657	if debug:
3658	print " Computing variable difference of '" + vn + "' for: '" + \
3659	modexpdiff + "' and performing operation '" + Sdoops + "'"
3660	print " var in file: '" + vninF + "'"
3661
3662	# Range of the dimensions
3663	for CFd in CFdims:
3664	if CFd == CFdims[0]:
3665	CFdimS = CFd + '\|' + CFd + '\|-1'
3666	else:
3667	CFdimS = CFdimS + ';' + CFd + '\|' + CFd + '\|-1'
3668
3669	# Attributes of the variable
3670	with gen.Capturing() as output:
3671	varattrs = ncvar.ivattrs(ifile2,vninF)
3672	if debug:
3673	for s1out in output: print s1out
3674	varvals = vninF + ',' + varattrs['long_name'][0] + ',' + \
3675	varattrs['units'][0]
3676
3677	values = CFdimS + '@' + 'add\|' + ifile2 + '\|' + vninF + '%' + CFdimS + \
3678	'@' + 'sub\|' + ifile1 + '\|' + vninF
3679	pyins = 'python ' + pyH + "/nc_var.py -o compute_opersvarsfiles -S '" + \
3680	values + "' -v '" + varvals + "'"
3681
3682	try:
3683	with gen.Capturing() as output:
3684	ncvar.compute_opersvarsfiles(values,varvals)
3685	except:
3686	print errmsg
3687	print 'ncvar.compute_opersvarsfiles(' + values + ', ' + varvals + ')'
3688	for s1out in output: print s1out
3689	quit(-1)
3690
3691	sout = sub.call('mv opersvarsfiles_'+vninF+'.nc ' + difffilen, shell=True)
3692
3693	# keeping all differences
3694	trkobjf.write('\n')
3695	trkobjf.write("#" + vn + ' ' + op + '\n')
3696	trkobjf.write( pyins + '\n')
3697
3698	# Computing statisitcs
3699	compute_diff_statistics(config, difffilen, odir, vninF, doops, diffscr, \
3700	debug)
3701
3702	trkobjf.close()
3703
3704	if debug: print " End of '" + fname + "' "
3705
3706	return
3707
3708
3709	def draw_diff_plots(config, plots, odir, allvarcomp, kdiff, figscr, debug):
3710	""" Function to draw all plots
3711	config= Configuration of the experiment
3712	plots= dictionary with the plots
3713	odir= output experiment folder
3714	allvarcomp= dictionary with all the variables to compute and their information
3715	kdiff= kind of differences:
3716	'diffop': plots from operation differences
3717	'diffvar': plots from variable differences
3718	figscr= whether figures should be done from the scratch or not
3719
3720	* Plot as
3721	{[kplot]} = [varn1]\|[op1]#[varn2]\|[op2]#[...[varnN]\|[opN]], ...
3722	[kplot] ___
3723	diffmap2Dsfc: 2D map of surface differences values of 1 variable
3724	diffmap2Dz: 2D map of 3D differences values of 1 variable
3725	map2Dsfc: 2D map of surface values of 1 variable
3726	map3D: 2D map of 3D values of 1 variable
3727	shadconthovmsfc: Hovmoeller diagrams of 2 variable at the surface in shadow and the other in contourn
3728	shadcont2Dsfc: 2D map of shadow (1st variable) and countour (2nd variable) [stvar1]#[stvar2]
3729	shadcont2Dzsec: 2D map of vertical section of 2 variables one in shadow and the other in contourn
3730	[varn]
3731	variable
3732	[op]
3733	'+' separated list of operations
3734	in figures with more than 1 variable, use '#' to separate the [varn]\|[op]
3735	"""
3736	fname = 'draw_diff_plots'
3737
3738	os.chdir(odir)
3739
3740	# Dictionary with the operations with surnames for the operated variable
3741	opersurnames = {}
3742	opsur = gen.get_specdictionary_HMT(config, H='opsur_',M='',T='')
3743	for opsr in opsur.keys():
3744	opn = opsr.split('_')[1]
3745	vls = opsur[opsr].split(':')
3746	opersurnames[opn] = vls
3747
3748	# time values
3749	# Units time for the plots
3750	rd = config['CFreftime']
3751	tunits = config['CFunitstime'] + '!since!' + rd[0:4] + '-' + rd[4:6] + '-' + \
3752	rd[6:8] + '!' + rd[8:10] + ':' + rd[10:12] + ':' + rd[12:14]
3753	# time ticks kind
3754	tkind = config['timekind']
3755	# time ticks format
3756	tfmt = config['timefmt']
3757	# time axis label
3758	tlab = config['timelabel']
3759	timevals = [tunits, tkind, tfmt, tlab]
3760
3761	if kdiff == 'diffop':
3762	specplotkeyn = 'specificdiffopplot'
3763	elif kdiff == 'diffvar':
3764	specplotkeyn = 'specificdiffvarplot'
3765	else:
3766	print errmsg
3767	print ' ' + fname + ": differences kind '" + kdiff + "' not ready !!"
3768	quit(-1)
3769
3770	# Dictionary of plot specificities
3771	plotspecifics = {}
3772	if config.has_key(specplotkeyn):
3773	# [minval]: minimum value
3774	# [maxval]: minimum value
3775	# [colorbar]: name of the colorbar (from matplotlib) to use
3776	# [cntformat]: format of the contour labels
3777	# [colorcnt]: color for the countor lines
3778	plotspecs = config[specplotkeyn].split(':')
3779	for pltspc in plotspecs:
3780	pltvls = pltspc.split('\|')
3781	vn = pltvls[0]
3782	op = pltvls[1]
3783	fn = pltvls[2]
3784	plotspecifics[fn + '_' + vn + '_' + op] = pltvls[3:]
3785	if debug:
3786	print 'Specific values for plots _______'
3787	gen.printing_dictionary(plotspecifics)
3788
3789	# Kind of figures
3790	kindfigure = config['kindfig']
3791
3792	# Graphical labels and configuration
3793	modgc, expgc = graphical_characteristics(config, debug)
3794
3795	# Map value
3796	mapvalue = config['mapval']
3797
3798	# pythone scripts HOME
3799	pyHOME = config['pyHOME']
3800
3801	# Title-text of operations
3802	opexplained = {}
3803	optits = config['titleoperations'].split(':')
3804	for optit in optits:
3805	opn = optit.split('\|')[0]
3806	opt = optit.split('\|')[1]
3807	opexplained[opn] = opt
3808	if debug:
3809	print 'Titles for operations _______'
3810	gen.printing_dictionary(opexplained)
3811
3812	for kplot in plots.keys():
3813	varsplt = plots[kplot]
3814	for varplt in varsplt:
3815	if debug:
3816	print " printing '" + kplot + "' var ':" + varplt + "'..."
3817	varops = varplt.split('#')
3818
3819	# CF variables in plot
3820	CFvarsplot = []
3821	# Files in plot
3822	filesplot = []
3823	# Variables in plot within the files
3824	varsplot = []
3825	# Dims in figure
3826	dimsplot = []
3827	# pictoric values in figure
3828	pictplot = []
3829	# Name of the figure
3830	figname = ''
3831	# Title of the figure
3832	titfigure = ''
3833
3834	ivp = 0
3835	for varop in varops:
3836	vn = varop.split('\|')[0]
3837	op = varop.split('\|')[1]
3838
3839	# CF variables in plot
3840	CFvarsplot.append(vn)
3841
3842	vnopS = vn + '_' + op
3843	if not allvarcomp.has_key(vnopS):
3844	print errmsg
3845	print ' ' + fname + ": no file for variable-operation '" + \
3846	vnopS + "' !!"
3847	print ' available ones:', allvarcomp.keys()
3848	quit(-1)
3849	vopvals = allvarcomp[vnopS]
3850	mod1 = vopvals[0]
3851	mod2 = vopvals[1]
3852	mod3 = vopvals[2]
3853	mod4 = vopvals[3]
3854	headf = vopvals[4]
3855
3856	modv = modgc[mod1]
3857	expv = expgc[mod1+'/'+exp1]
3858	modlab1 = modv.label
3859	explab1 = expv.label
3860	modv = modgc[mod2]
3861	expv = expgc[mod2+'/'+exp2]
3862	modlab2 = modv.label
3863	explab2 = expv.label
3864
3865	modexpdiff = explab2 + '-' + explab1
3866	modexpdiffS = mod2 + '-' + exp2 + '_' + mod1 + '-' + exp1
3867
3868	difffilen = odir + '/' + vn + '_' + kdiff + '_' + modexpdiffS + \
3869	'_' + op.replace('+','_') + '.nc'
3870
3871	filesplot.append(difffilen)
3872	# Do we have processed the given difference?
3873	if not os.path.isfile(difffilen):
3874	print warnmsg
3875	print " " + fname + ": there is no file for '" + kdiff + \
3876	"' difference '" + varop + "' skiping it !!"
3877	break
3878
3879	# Name of the variable inside the file
3880	vnsur = varnoper(vn, op, opersurnames)
3881	varsplot.append(vnsur)
3882
3883	# Dimensions in file
3884	try:
3885	with gen.Capturing() as output:
3886	dims = ncvar.idims(difffilen)
3887	except:
3888	print errmsg
3889	print 'ncvar.idims('+difffilen+')'
3890	for s1out in output: print s1out
3891	quit(-1)
3892
3893	dimsplot.append(dims)
3894
3895	# pictoric values for the figure
3896	Sfivaop = kplot + '_' + vn + '_' + op
3897	if plotspecifics.has_key(Sfivaop):
3898	pictvals = plotspecifics[Sfivaop]
3899	else:
3900	Vvals = gen.variables_values(vn)
3901	pictvals = [Vvals[2], Vvals[3], Vvals[6], '%g', 'fixsigc','black']
3902
3903	pictplot.append(pictvals)
3904
3905	# Header of the name of the figure
3906	if ivp == 0:
3907	figname = kplot + '_' + vn + '_' + kdiff + '_' + modexpdiffS + \
3908	'_' + op.replace('+','-')
3909	else:
3910	figname = figname + '-' + vn + '_' + op.replace('+','-')
3911
3912	# Title of the figure:
3913	if mod1 == mod2:
3914	modexptit = mod1 + '!' + exp2 + '-' + exp1
3915	else:
3916	modexptit = modexpdiff
3917
3918	ivp = ivp + 1
3919	# End of variable-operation
3920	figname = figname + '.' + kindfigure
3921
3922	# Title of figure
3923	titfigure = create_figure_title(modexptit, kdiff, varops, opexplained)
3924
3925	if len(titfigure) > 80:
3926	print warnmsg
3927	print ' ' + fname + ": figure title '" + titfigure.replace('!', ' ')+\
3928	"' larger than 80 characters (actually", len(titfigure), ') !!'
3929	print " simplifying it to '" + modexptit.replace('!',' ') + '!' + \
3930	kdiff + '!' + vnS + "'"
3931	titfigure = modexptit.replace(' ','!') + '!' + kdiff + '!' + vnS
3932
3933	draw_plot(kplot, CFvarsplot, filesplot, varsplot, dimsplot, pictplot, \
3934	figname, titfigure, kindfigure, mapvalue, timevals, expgc, odir, \
3935	pyHOME, figscr, debug)
3936
3937	# End of variables-operations
3938
3939	# End of kind of plots
3940
3941	if debug: print " End of '" + fname + "' "
3942
3943	return
3944
3945	def reproject_modexp(mod,exp,config,REPRJops,fscr,fadd,debug):
3946	""" Function to re-project and re-compute files from a given model/experiment
3947	mod= model
3948	exp= experiment
3949	config= configuration
3950	REPRJops= dictionary with the reprojection operators to use for reproject and for which variable
3951	# remapbil CDO: Bilinear interpolation
3952	# remapbic CDO: Bicubic interpolation
3953	# remapdis CDO: Distance-weighted average remapping
3954	# remapnn CDO: Nearest neighbor remapping
3955	# Operators only available if projections have the corners of the grid points.
3956	# remapcon CDO: First order conservative remapping
3957	# remapcon2 CDO: Second order conservative remapping
3958	# remaplaf CDO: Largest area fraction remapping
3959	####### ####### ####### or additionally ####### ####### #######
3960	# python remapping
3961	# dis python: Distance-weighted average remapping
3962	# pnn python: Nearest neighbor remapping
3963
3964	fscr= re-projected files to compute from the scratch
3965	fadd= re-projected files to be added
3966	"""
3967	fname = 'reproject_modexp'
3968
3969	odir = config['ofold'] + '/' + mod + '/' + exp
3970
3971	# NON re-projectable operations
3972	opNOreproj = config['NOreprojops'].split(':')
3973
3974	# Need to pass to analyze all the data?
3975	inffiles = ['reproj_varcompute.inf', 'all_reproj_computevars.inf']
3976	if fscr:
3977	for inff in inffiles:
3978	if debug: print " removing information file '" + inff + "' ..."
3979	ins = 'rm ' + odir + '/' + inff + ' >& /dev/null'
3980	sout = sub.call(ins, shell=True)
3981
3982	objf = open(odir+'/all_reproj_computevars.inf','w')
3983	objf.write("## Computation of reprojected variables \n")
3984	objf.close()
3985
3986	varcompf = odir + '/reproj_varcompute.inf'
3987	if fadd:
3988	sub.call('rm ' + varcompf +' >& /dev/null', shell=True)
3989
3990	# CF dims-vardims pairs:
3991	CFvardims = ['long@lon', 'lat@lat', 'pres@pres', 'time@time']
3992
3993	# Dictionary with the operations with surnames for the operated variable
3994	opersurnames = {}
3995	opsur = gen.get_specdictionary_HMT(config, H='opsur_',M='',T='')
3996	for opsr in opsur.keys():
3997	opn = opsr.split('_')[1]
3998	vls = opsur[opsr].split(':')
3999	opersurnames[opn] = vls
4000
4001	if not os.path.isfile(varcompf):
4002	# Getting original computing information
4003	origvarcompf = odir + '/varcompute.inf'
4004	origfiles,origtestfiles,origallcompvar, Nvar = read_varcomp_file(origvarcompf)
4005
4006	Svarcompute = ''
4007	allcompvar = dict(origallcompvar)
4008	ivop = 0
4009	for vnop in origallcompvar.keys():
4010	vn = vnop.split('_')[0]
4011	op = vnop.split('_')[1]
4012	values = allcompvar[vnop]
4013	values[0] = 'reproj-' + values[0]
4014	allcompvar[vnop] = values
4015
4016	# Building strings from list values
4017	model = values[1]
4018	diag = values[2]
4019	if model is not None:
4020	if type(model) == type(list([1, 2])):
4021	Smodel = ':'.join(model)
4022	elif type(model) == type('A'):
4023	Smodel = model
4024	else:
4025	Smodel = 'None'
4026	if diag is not None:
4027	if type(diag) == type(list([1, 2])):
4028	Sdiag = ':'.join(diag)
4029	elif type(diag) == type('A'):
4030	Sdiag = diag
4031	else:
4032	Sdiag = 'None'
4033
4034	Svc = vn + '\|' + op + '\|' + values[0] + '\|' + Smodel + '\|' + Sdiag + \
4035	'\|' + values[3]
4036	if ivop == 0:
4037	Svarcompute = Svc
4038	else:
4039	Svarcompute = Svarcompute + ',' + Svc
4040	ivop = ivop + 1
4041
4042	origstrfiles = gen.dictKeysVals_stringList(origfiles)
4043	origstrtestfiles = gen.dictKeysVals_stringList(origtestfiles)
4044
4045	# Outwritting the varcompute to avoid next time (if it is not filescratch!)
4046	objf = open(odir + '/reproj_varcompute.inf', 'w')
4047	objf.write('files: ' + origstrfiles + '\n')
4048	objf.write('testfiles: ' + origstrtestfiles + '\n')
4049	objf.write('varcompute: ' + Svarcompute + '\n')
4050	objf.write('itotv: ' + str(ivop) + '\n')
4051	objf.close()
4052	else:
4053	if dbg:
4054	print warnmsg
4055	print ' ' + main + ": getting variables to compute already from file !!"
4056	origfiles, origtestfiles, allcompvar, Nvar = read_varcomp_file(varcompf)
4057
4058	# End of avoiding to repeat all the experiment search
4059
4060	print " For experiment '" + exp + "' is required to re-project:", Nvar, \
4061	"variables"
4062
4063	if dbg:
4064	print 'Variables to re-project _______'
4065	gen.printing_dictionary(allcompvar)
4066
4067	# Re-projection variables
4068	print " Reprojecting variables ..."
4069	os.chdir(odir)
4070
4071	# Keeping track of reprojection
4072	trckobjf = open(odir + '/all_reproj_computevars.inf','a')
4073
4074	for vnop in allcompvar.keys():
4075	vn = vnop.split('_')[0]
4076	op = vnop.split('_')[1]
4077	values = allcompvar[vnop]
4078	VnOpS = varnoper(vn, op, opersurnames)
4079
4080	# Only are reprojected that files which do contain 'lon' and 'lat',
4081	# otherways, it is only re-projected the original file
4082	inNO, iopNO, iop = gen.list_coincidences(opNOreproj,op.split('+'))
4083
4084	reprjop = gen.dictionary_key_list(REPRJops,vn).split('_')[1]
4085	if reprjop is None:
4086	print errmsg
4087	print ' ' + fname + ": no reprojecting operator found for " + \
4088	" variable '" + vn + "' !!"
4089	print ' available values _______'
4090	gen.printing_dictionary(REPRJops)
4091	quit(-1)
4092
4093	# Re-projecting also the 'original' (at least with 'pinterp') file for varsdif
4094	if op.find('pinterp') != -1:
4095	ifileorig = vn +'_'+ values[0].replace('reproj-','') + 'p_pinterp.nc'
4096	ofileorig = vn +'_'+ values[0] + 'p_pinterp.nc'
4097	ofilen = vn +'_'+ values[0] + 'p_pinterp.nc'
4098	ifileop = vn +'_'+ values[0].replace('reproj-','') + 'p_' + \
4099	op.replace('+','_') + '.nc'
4100	else:
4101	ifileorig = vn +'_'+ values[0].replace('reproj-','') + '.nc'
4102	ofileorig = vn +'_'+ values[0] + '.nc'
4103	ifileop = vn +'_'+ values[0].replace('reproj-','') + '_' + \
4104	op.replace('+','_') + '.nc'
4105
4106	ofileop = vn + '_' + values[0] + '_' + op.replace('+','_') + '.nc'
4107
4108	if fscr:
4109	sout = sub.call('rm ' + odir+'/'+ofileorig + ' >& /dev/null', shell=True)
4110	sout = sub.call('rm ' + odir+'/'+ofileop + ' >& /dev/null', shell=True)
4111
4112	# List of files to re-project (first without operation)
4113	ifiles = [odir+'/'+ifileorig, odir+'/'+ifileop]
4114	# List of output files after re-projection (first without operation)
4115	ofiles = [odir+'/'+ofileorig, odir+'/'+ofileop]
4116
4117	for iif in range(2):
4118	ifile = ifiles[iif]
4119	ofile = ofiles[iif]
4120
4121	# Only projecting original file-variable if there are not 'lon' and 'lat'
4122	doreproj = True
4123	if iif == 1 and len(inNO) > 0:
4124	doreproj = False
4125	if dbg:
4126	print warnmsg
4127	print ' ' + fname + ": operation '" + op + "' can not be " + \
4128	"reprojected due to the lack of 'lon' or 'lat' skipping it !!"
4129	print " NOTE: difference can only be computed as:"
4130	print " - 1st: compute variable's differences between models"
4131	print " - 2nd: Perform the operations"
4132
4133	# Building up resources to compute re-projected statistics
4134	if dbg:
4135	print ' '+fname+': computing from the original reprojected file'
4136	ModI = ModelInf(mod, mod, 'lon', 'lat', 'pres', 'time', 'depth', \
4137	'lon', 'lat', 'pres', 'time', 'depth', None)
4138	if type(values) == type([1]):
4139	fileh = values[0]
4140	else:
4141	fileh = values
4142
4143	if type(values) == type([1]):
4144	fileh = values[0]
4145	else:
4146	fileh = values
4147
4148	VarI = VariableInf(vn, values[0], values[2], values[3])
4149	usefs = {values[0]: ofileorig}
4150
4151	compute_statistics(ModI, config, config['ifold'], usefs, \
4152	config['ofold']+'/'+mod+'/'+exp,VarI,pinterp_var(op), op, fscr, dbg)
4153
4154	if not os.path.isfile(ofile) and doreproj:
4155	if debug and ofile == ofiles[0]:
4156	print " reprojecting '" + vn + "' '" + op + "' into '" + \
4157	ofile + "'"
4158
4159	# Reprojecting...
4160	if reprjop[0:6] == 'remap':
4161	ins = config['cdoHOME'] + '/cdo ' + reprjop + ',' + \
4162	config['RefProjfile'] + ' ' + ifile + ' ' + ofile
4163	try:
4164	with gen.Capturing() as output:
4165	sout = sub.call(ins, shell=True)
4166	except:
4167	print errmsg
4168	print ' ' + fname + ': $ ' + ins
4169	for s1out in output: print s1out
4170	print sout
4171	quit(-1)
4172	if sout != 0:
4173	print errmsg
4174	print ' ' + fname + ': $ ' + ins
4175	sub.call(ins, shell=True)
4176	quit(-1)
4177	else:
4178	# Name of the variable to reproject
4179	if iif == 0:
4180	reprjvn = vn
4181	else:
4182	reprjvn = VnOpS
4183
4184	reprojvalues = 'lon,lat,' + config['RefProjfile'] + ',lon,lat,'+ \
4185	reprjop + ',' + ':'.join(CFvardims)
4186	ins= 'ncvar.reproject('+reprojvalues + ', ' + ifile + ', '+ \
4187	reprjvn + ')'
4188	try:
4189	with gen.Capturing() as output:
4190	sout=ncvar.reproject(reprojvalues, ifile, reprjvn)
4191	except:
4192	print errmsg
4193	print ' ' + fname + ': ' + ins
4194	for s1out in output: print s1out
4195	quit(-1)
4196
4197	sub.call('mv reproject.nc ' + ofile, shell=True)
4198
4199	if debug:
4200	for s1out in output: print s1out
4201	print sout
4202
4203	# Keeping track of re-projection
4204	trckobjf.write('\n')
4205	if iif == 0:
4206	trckobjf.write('# ' + vn + '\n')
4207	else:
4208	trckobjf.write('# ' + vn + ' ' + op + '\n')
4209
4210	trckobjf.write(ins + '\n')
4211
4212	if reprjop[0:6] == 'remap':
4213	# CFing the reprojected file
4214	try:
4215	with gen.Capturing() as output:
4216	ncvar.CDO_toCF(ofile)
4217	except:
4218	print errmsg
4219	print 'ncvar.CDO_toCF(' + ofile + ')'
4220	for s1out in output: print s1out
4221	# Removing file in order to make sure that it will be redone
4222	print ' ' + fname + " removing file '" + ofile + "' ..."
4223	sub.call('rm ' + ofile + ' >& /dev/null', shell=True)
4224	quit(-1)
4225
4226	if debug:
4227	for s1out in output: print s1out
4228
4229	trckobjf.close()
4230
4231	if debug: print " End of '" + fname + "' "
4232
4233	return
4234
4235	def allmodexps_listconstruct(config, modexps, odir, debug):
4236	""" Function to create the list of all model-experiments to draw
4237	config= Configuration of the experiment
4238	modexps= list with the models-experiments pairs to use
4239	odir= output differences folder
4240	"""
4241	fname='allmodexps_listconstruct'
4242
4243	allplts = gen.get_specdictionary_HMT(config, H='PLOTALLMODEXP_')
4244
4245	if debug:
4246	if allplts is not None:
4247	print " 'all mod-exps' plots ________"
4248	gen.printing_dictionary(allplts)
4249
4250	# Getting Model-Reference Projection
4251	ModComProj = cnf['RefProj'].split(':')
4252
4253	allmodexp = {}
4254	Nallmodexp = 0
4255	for modexp in modexps:
4256	if debug:
4257	print " " + fname + ": '" + modexp + "' ..."
4258	mod = modexp.split('/')[0]
4259	exp = modexp.split('/')[1]
4260
4261	# Getting variable characteristics from each model/experiment
4262	idir = config['ofold'] + '/' + modexp
4263
4264	reproj = not gen.searchInlist(ModComProj,mod)
4265
4266	fvarcomp = 'varcompute.inf'
4267	if reproj: fvc = 'reproj_' + fvarcomp
4268	else: fvc = fvarcomp
4269
4270	files, testfiles, allcompvar, Nvar= read_varcomp_file(idir + '/' + fvc)
4271
4272	if allplts is not None:
4273	# Getting all model-experiments plots characteristics
4274
4275	for allplt in allplts.keys():
4276	pltn = allplt.split('_')[1]
4277	if debug and modexp == modexps[0]:
4278	print ' ' + fname + ": plot '" + pltn + "' "
4279	varops = allplts[allplt].split(':')
4280	for varop in varops:
4281	vn = varop.split('\|')[0]
4282	op = varop.split('\|')[1]
4283	vnop = vn + '_' + op
4284	if debug and modexp == modexps[0]:
4285	print ' ' + fname + ": varop '" + vnop + "' "
4286	if not allcompvar.has_key(vnop):
4287	print warnmsg
4288	print ' ' + fname + ": variable+operation '" + vnop + \
4289	"' in '" + modexp + "' was not computed !!"
4290	print ' skipping it!'
4291	print ' computed values:', allcompvar.keys()
4292	break
4293
4294	vals = allcompvar[vnop]
4295
4296	headerf = vals[0]
4297	if modexp == modexps[0]:
4298	allmodexp[vnop] = [modexp,headerf]
4299	Nallmodexp = Nallmodexp + 1
4300	else:
4301	prevals = allmodexp[vnop]
4302	prevals = prevals + [modexp,headerf]
4303	allmodexp[vnop] = prevals
4304
4305	else:
4306	Nallmodexp = 0
4307
4308	if allplts is not None:
4309	Sallmodexps = gen.dictKeysVals_stringList(allmodexp)
4310	else:
4311	Sallmodexps = 'none'
4312
4313	# Outwritting the all model-experiment plots file to avoid next time
4314	objf = open(odir + '/allmodexp.inf', 'w')
4315	objf.write('allmodexps: ' + Sallmodexps + '\n')
4316	objf.write('Nallmodexp: ' + str(Nallmodexp) + '\n')
4317	objf.close()
4318
4319	if debug: print " End of '" + fname + "' "
4320
4321	return allmodexp, Nallmodexp
4322
4323	def allmodexps_read(filen):
4324	""" Function to read the file with the information about the all model-experiment plots
4325	filen= file with the information
4326	"""
4327	fname = 'allmodexps_read'
4328
4329	if not os.path.isfile(filen):
4330	print errormsg
4331	print ' ' + fname + ": all model-experiment file '" + filen + \
4332	"' does not exist !!"
4333	quit(-1)
4334
4335	objf = open(filen, 'r')
4336	for line in objf:
4337	if line[0:1] != '#' and len(line) > 1:
4338	values = line.replace('\n','').split(' ')
4339	if values[0] == 'allmodexps:':
4340	allplts = gen.stringList_dictKeysVals(values[1])
4341	elif values[0] == 'Nallmodexp:':
4342	Nallmodexp = int(values[1])
4343
4344	objf.close()
4345
4346	return allplts, Nallmodexp
4347
4348	def draw_allmodexp_plots(config, allvarcomp, plots, modexp, odir, figscr, debug):
4349	""" Function to draw all model-experiment plots
4350	config= Configuration of the experiment
4351	allvarcomp = dictionary with the file headers for each variable
4352	plots= dictionary with the plots
4353	modexps= list with the names of the model-experiment pairs
4354	odir= output experiment folder
4355	figscr= whether figures should be done from the scratch or not
4356
4357	* Plot as
4358	{[kplot]} = [varn1]\|[op1]#[varn2]\|[op2]#[...[varnN]\|[opN]], ...
4359	[kplot] ___
4360	Nlines: Multiple lines with one line by model-experiment pairs
4361	[varn]
4362	variable
4363	[op]
4364	'+' separated list of operations
4365	in figures with more than 1 variable, use '#' to separate the [varn]\|[op]
4366	"""
4367	fname = 'draw_allmodexp_plots'
4368
4369	os.chdir(odir)
4370
4371	# Folder with the processed files
4372	infold = config['ofold']
4373
4374	# Dictionary with the operations with surnames for the operated variable
4375	opersurnames = {}
4376	opsur = gen.get_specdictionary_HMT(config, H='opsur_',M='',T='')
4377	for opsr in opsur.keys():
4378	opn = opsr.split('_')[1]
4379	vls = opsur[opsr].split(':')
4380	opersurnames[opn] = vls
4381
4382	# time values
4383	# Units time for the plots
4384	rd = config['CFreftime']
4385	tunits = config['CFunitstime'] + '!since!' + rd[0:4] + '-' + rd[4:6] + '-' + \
4386	rd[6:8] + '!' + rd[8:10] + ':' + rd[10:12] + ':' + rd[12:14]
4387	# time ticks kind
4388	tkind = config['timekind']
4389	# time ticks format
4390	tfmt = config['timefmt']
4391	# time axis label
4392	tlab = config['timelabel']
4393	timevals = [tunits, tkind, tfmt, tlab]
4394
4395	# Dictionary of plot specificities
4396	specplotkeyn = 'specificvarplot'
4397	plotspecifics = {}
4398	if config.has_key(specplotkeyn):
4399	# [minval]: minimum value
4400	# [maxval]: minimum value
4401	# [colorbar]: name of the colorbar (from matplotlib) to use
4402	# [cntformat]: format of the contour labels
4403	# [colorcnt]: color for the countor lines
4404	plotspecs = config[specplotkeyn].split(':')
4405	for pltspc in plotspecs:
4406	pltvls = pltspc.split('\|')
4407	vn = pltvls[0]
4408	op = pltvls[1]
4409	fn = pltvls[2]
4410	plotspecifics[fn + '_' + vn + '_' + op] = pltvls[3:]
4411	if debug:
4412	print 'Specific values for plots _______'
4413	gen.printing_dictionary(plotspecifics)
4414
4415	# Graphical labels and configuration
4416	modgc, expgc = graphical_characteristics(config, debug)
4417
4418	# Kind of figures
4419	kindfigure = config['kindfig']
4420
4421	# Map value
4422	mapvalue = config['mapval']
4423
4424	# pythone scripts HOME
4425	pyHOME = config['pyHOME']
4426
4427	# Title-text of operations
4428	opexplained = {}
4429	optits = config['titleoperations'].split(':')
4430	for optit in optits:
4431	opn = optit.split('\|')[0]
4432	opt = optit.split('\|')[1]
4433	opexplained[opn] = opt
4434	if debug:
4435	print 'Titles for operations _______'
4436	gen.printing_dictionary(opexplained)
4437
4438	for kplot in plots.keys():
4439	varsplt = plots[kplot]
4440	for varplt in varsplt:
4441	if debug:
4442	print " printing '" + kplot + "' var: '" + varplt + "'..."
4443	varops = varplt.split('#')
4444
4445	# CF variables in plot
4446	CFvarsplot = []
4447	# Files in plot
4448	filesplot = []
4449	# Variables in plot within the files
4450	varsplot = []
4451	# Dims in figure
4452	dimsplot = []
4453	# pictoric values in figure
4454	pictplot = []
4455	# Name of the figure
4456	figname = ''
4457	# Title of the figure
4458	titfigure = ''
4459
4460	ivp = 0
4461	for varop in varops:
4462	vn = varop.split('\|')[0]
4463	op = varop.split('\|')[1]
4464
4465	# CF variables in plot
4466	CFvarsplot.append(vn)
4467
4468	if op.find('pinterp') != -1: gP = 'p'
4469	else: gP = ''
4470
4471	vnopS = vn + '_' + op
4472	if not allvarcomp.has_key(vnopS):
4473	print errmsg
4474	print ' ' + fname + ": no file for variable-operation '" + \
4475	vnopS + "' !!"
4476	modexpvals = allvarcomp[vnopS]
4477	Nmodexps = len(modexpvals)
4478
4479	for imodexp in range(0,Nmodexps,2):
4480	modexp = modexpvals[imodexp]
4481	headf = modexpvals[imodexp+1]
4482	if debug:
4483	print ' ' + fname + " model/experiment: '" + modexp + "'"
4484
4485	filen = infold + '/' + modexp + '/' + vn +'_'+ headf+gP + '_' + \
4486	op.replace('+','_') + '.nc'
4487
4488	filesplot.append(filen)
4489	# Do we have processed the given variable?
4490	if not os.path.isfile(filen):
4491	print warnmsg
4492	print " " + fname + ": there is no file for variable '" + \
4493	varop + "' skiping it !!"
4494	break
4495
4496	if imodexp == 0:
4497	# Name of the variable inside the file
4498	vnsur = varnoper(vn, op, opersurnames)
4499	varsplot.append(vnsur)
4500
4501	# Dimensions in file
4502	try:
4503	with gen.Capturing() as output:
4504	dims = ncvar.idims(filen)
4505	except:
4506	print errmsg
4507	print 'ncvar.idims('+filen+')'
4508	for s1out in output: print s1out
4509	quit(-1)
4510
4511	if imodexp == 0:
4512	# Dimensions in plot
4513	dimsplot.append(dims)
4514
4515	# Header of the name of the figure
4516	if ivp == 0:
4517	figname = kplot+'_'+vn+'_'+headf+'_'+ op.replace('+','-')
4518	else:
4519	figname = figname+'-'+vn+'_'+headf+'_'+op.replace('+','-')
4520
4521	# pictoric values for the figure
4522	Sfivaop = kplot + '_' + vn + '_' + op
4523	if plotspecifics.has_key(Sfivaop):
4524	pictvals = plotspecifics[Sfivaop]
4525	else:
4526	Vvals = gen.variables_values(vn)
4527	pictvals = [Vvals[2],Vvals[3],Vvals[6], '%g', 'fixc', 'black']
4528
4529	pictplot.append(pictvals)
4530
4531	ivp = ivp + 1
4532	# End of variable-operation
4533	figname = figname + '.' + kindfigure
4534
4535	# Title of figure
4536	titfigure = 'all!model-experiments!' + vn + optitle(op,opexplained)
4537
4538	draw_plot(kplot, CFvarsplot, filesplot, varsplot, dimsplot, pictplot, \
4539	figname, titfigure, kindfigure, mapvalue, timevals, expgc, odir, \
4540	pyHOME, figscr, debug)
4541
4542	# End of variables-operations
4543
4544	# End of kind of plots
4545
4546	if debug: print " End of '" + fname + "' "
4547
4548	return
4549
4550	def figinf_figname(figname,config):
4551	""" Function to retrieve figure information from its name
4552	figname= name of the figure
4553	config= configuration of `model_graphics.py'
4554	>>> figinf_figname('2linesTime_wss_wrfout_xvar-ymean-tas_wrfout_xvar-ymean.pdf', cnf)
4555	(2, '2linesTime', 'wss-tas', 'xvar-ymean@xvar-ymean')
4556	>>> figinf_figname('Nlines_tas_wrfout_tturb-xmean-tmean.pdf', cnf)
4557	(1, 'Nlines', 'tas', 'tturb-xmean-tmean')
4558	>>> figinf_figname('2lines_wss_diffvar_WRF-micro1_WRF-current_tturb-xmean-last-tas_tturb-xmean-last.pdf',cnf)
4559	(2, '2lines', 'wss-tas', 'tturb-xmean-last@tturb-xmean-last')
4560	"""
4561	fname = 'figinf_figname'
4562	plotsecs = figname.split('_')
4563	plotk = plotsecs[0]
4564
4565	if gen.searchInlist(config['pairfigures'].split(':'), plotk):
4566	Nvars = 2
4567	varn1 = plotsecs[1]
4568	if plotsecs[2] == 'diffvar' or plotsecs[2] == 'diffop':
4569	statn1varn2 = plotsecs[5].split('-')
4570	statn2 = plotsecs[6].split('.')[0]
4571	Lstatn1varn2 = len(statn1varn2)
4572	statn1 = '-'.join(statn1varn2[0:Lstatn1varn2-1])
4573	varn2 = statn1varn2[Lstatn1varn2-1]
4574	else:
4575	statn1varn2 = plotsecs[3].split('-')
4576	statn2 = plotsecs[5].split('.')[0]
4577	Lstatn1varn2 = len(statn1varn2)
4578	statn1 = '-'.join(statn1varn2[0:Lstatn1varn2-1])
4579	varn2 = statn1varn2[Lstatn1varn2-1]
4580	return Nvars, plotk, varn1+'-'+varn2, statn1+'@'+statn2
4581	elif gen.searchInlist(config['Nsourcesfigures'].split(':'), plotk):
4582	Nvars = 1
4583	varn = plotsecs[1]
4584	statn = plotsecs[3].split('.')[0]
4585	return Nvars, plotk, varn, statn
4586	else:
4587	print errmsg
4588	print ' ' + fname + ": kind of figure '" + plotk + "' not ready !!"
4589	print ' ready ones _______'
4590	print " 'pair_figures': figures of pair of variables: ", \
4591	config['pairfigures'].split(':')
4592	print " 'N-sources_figures': figures of pair of variables: ", \
4593	config['Nsourcesfigures'].split(':')
4594	quit(-1)
4595
4596	# Files with information about the configuration of the script
4597	inffiles = ['varcompute.inf', 'all_computevars.inf', 'all_statsvars.inf']
4598
4599	####### #######
4600	## MAIN
4601	#######
4602	if not os.path.isfile('model_graphics.dat'):
4603	print errmsg
4604	print main + ": configuration file 'model_graphics.dat' does not exist!!"
4605	quit(-1)
4606
4607	# Getting configuration from external ASCII file 'model_graphics.dat'
4608	cnf = gen.get_configuration('model_graphics.dat', False)
4609
4610	verify_configuration(cnf, gen.Str_Bool(cnf['debug']))
4611
4612	# scratches
4613	scratch, filescratch, figscratch, diffscratch, figdiffscratch, moddiffscratch, \
4614	figmoddiffscratch, figallmodexpscratch, addfiles, addfigures, adddiffs, \
4615	adddifffigures, addmoddiffs, addmoddifffigures, addallmodexpfigures, dbg = \
4616	scratches(cnf)
4617
4618	if dbg:
4619	print 'Experiment configuration scratches _______'
4620	print ' scratch:', scratch, 'filescratch:', filescratch,'figscratch:', figscratch
4621	print ' diffscratch:', diffscratch, 'figdiffscratch:', figdiffscratch
4622	print ' moddiffscratch:', moddiffscratch, 'figmoddiffscratch:', figmoddiffscratch
4623	print 'Experiment configuration adding _______'
4624	print ' addfiles:', addfiles, 'addfigures:', addfigures
4625	print ' adddiffs:', adddiffs, 'adddifffigures:', adddifffigures
4626	print ' addmoddiffs:', addmoddiffs, 'addmoddifffigures:', addmoddifffigures
4627
4628	# Getting models
4629	mods = cnf['models'].split(':')
4630
4631	# Getting graphical characeristics
4632	modGC, expGC = graphical_characteristics(cnf, dbg)
4633
4634	# Models loop
4635	##
4636
4637	# dictionary with the experiments of each model
4638	modexps = {}
4639
4640	for mod in mods:
4641	print mod
4642	if scratch:
4643	if cnf['ofold'] != cnf['ifold']:
4644	sout = sub.call('rm -rf '+cnf['ofold']+'/'+mod+' > /dev/null', shell=True)
4645	else:
4646	print warnmsg
4647	print ' ' + main + ": input '" + cnf['ifold'] + "' and output '" + \
4648	cnf['ofold'] + "' are the same folder !!"
4649	print " Keeping output folder although it has 'scratch' start"
4650
4651	# Get experiments and headers of model
4652	exps, fheaders = exp_headers(mod,cnf)
4653
4654	modexps[mod] = exps
4655	# Characteristics of the model
4656	Modinf = ncvar.model_characteristics(mod,'None','False')
4657	dnx = Modinf.dimxn
4658	dny = Modinf.dimyn
4659	dnz = Modinf.dimzn
4660	dnt = Modinf.dimtn
4661	dns = Modinf.dimsn
4662	vdnx = Modinf.vardxn
4663	vdny = Modinf.vardyn
4664	vdnz = Modinf.vardzn
4665	vdnt = Modinf.vardtn
4666	vdns = Modinf.vardsn
4667
4668	modgraphv = modGC[mod]
4669	Modinf = ModelInf(mod, mod, dnx, dny, dnz, dnt, dns, vdnx, vdny, vdnz, vdnt, \
4670	vdns, modgraphv.tmod)
4671
4672	if dbg:
4673	print ' model characteristics _______'
4674	gen.printing_class(Modinf)
4675
4676	moddims = dnx + ',' + dny + ',' + dnz + ',' + dnt
4677	modvdims = vdnx + ',' + vdny + ',' + vdnz + ',' + vdnt
4678
4679	# Experiments loop
4680	##
4681	for exp in exps:
4682	print ' ' + exp + '...'
4683
4684	# input folder
4685	iwdir = cnf['ifold'] + '/' + mod + '/' + exp
4686
4687	# Does input folder exist?
4688	if not os.path.isdir(iwdir):
4689	if filescratch*addfiles:
4690	print errmsg
4691	print " " + main + ": folder '" + iwdir + "' does not exist !!"
4692	quit(-1)
4693	else:
4694	print warnmsg
4695	print " " + main + ": folder '" + iwdir + "' does not exist !!"
4696	print " but start of files from scratch 'filescratch':", \
4697	filescratch, "and there is not the add of any file 'addfiles':", \
4698	addfiles
4699	print ' so, keep moving'
4700
4701	owdir = cnf['ofold'] + '/' + mod + '/' + exp
4702	sout = sub.call('mkdir -p ' + owdir, shell=True)
4703
4704	# Need to pass to analyze all the data?
4705	if filescratch:
4706	for inff in inffiles:
4707	if dbg: print " removing information file '" + inff + "' ..."
4708	ins = 'rm ' + owdir + '/' + inff + ' >& /dev/null'
4709	sout = sub.call(ins, shell=True)
4710
4711	objf = open(owdir+'/all_computevars.inf','w')
4712	objf.write("## Computation of variables \n")
4713	objf.close()
4714	objf = open(owdir+'/all_statsvars.inf','w')
4715	objf.write("## Computation of statistics \n")
4716	objf.close()
4717
4718	varcompf = owdir + '/varcompute.inf'
4719	if addfiles:
4720	if dbg:
4721	print ' ' + main + ": adding variables to compute removing " + \
4722	"file '" + varcompf + "' ..."
4723	sub.call('rm ' + varcompf +' >& /dev/null', shell=True)
4724
4725	if not os.path.isfile(varcompf):
4726	# Does input folder has header files?
4727	ih=1
4728	# Dictionary with the list of files for each headers
4729	files = {}
4730	# Dictionary with a file fromor each headers
4731	testfiles = {}
4732
4733	for fh in fheaders:
4734	if filescratch:
4735	ins = 'rm '+ owdir+'/_' + fh + '.nc >& /dev/null'
4736	sout = sub.call(ins, shell=True)
4737	files1h = gen.files_folder(iwdir,fh)
4738	if len(files1h) < 1:
4739	print errmsg
4740	print ' ' + main + ": folder '" + iwdir + "' does not " + \
4741	"contain files '" + fh + "*' !!"
4742	quit(-1)
4743	files[fh] = files1h
4744	testfiles[fh] = files1h[0]
4745
4746	if dbg:
4747	print ' Dictionary of files _______'
4748	gen.printing_dictionary(files)
4749
4750	print ' Dictionary of test-files _______'
4751	gen.printing_dictionary(testfiles)
4752
4753	allcompvar, Nvar = compvars_listconstruct(cnf, Modinf, files, testfiles, \
4754	iwdir, owdir, dbg)
4755	else:
4756	if dbg:
4757	print warnmsg
4758	print ' '+main+": getting variables to compute already from file !!"
4759	files, testfiles, allcompvar, Nvar = read_varcomp_file(varcompf)
4760
4761	# End of avoiding to repeat all the experiment search
4762
4763	print " For experiment '" + exp + "' is required to compute:", Nvar, \
4764	"variables"
4765
4766	if dbg:
4767	print 'Variables to compute _______'
4768	gen.printing_dictionary(allcompvar)
4769
4770	# Computing variables
4771	print " Computing variables ..."
4772	compute_vars(cnf, Modinf, iwdir, owdir, files, allcompvar, filescratch, dbg)
4773
4774	# Figures of variables direct from files
4775	print " Plotting direct figures ..."
4776	dirfigf = owdir + '/directplotsdraw.inf'
4777	if figscratch:
4778	sout = sub.call('rm ' + dirfigf + ' >& /dev/null', shell=True)
4779
4780	objf = open(owdir+'/all_figures.inf','w')
4781	objf.write("## Drawing of all figures \n")
4782	objf.close()
4783
4784	if addfigures:
4785	if dbg:
4786	print ' ' + main + ": adding direct figures removing file '" + \
4787	dirfigf + "' ..."
4788	sout = sub.call('rm ' + dirfigf + ' >& /dev/null', shell=True)
4789
4790	if not os.path.isfile(dirfigf):
4791	listplots, Nplt = plots_listconstruct(cnf, 'DIRPLT', dirfigf, owdir, dbg)
4792	else:
4793	if dbg:
4794	print warnmsg
4795	print ' ' + main + ": getting plots to draw already from file !!"
4796	listplots, Nplt = read_plot_file(dirfigf)
4797
4798	# End of avoiding to repeat all the plots search
4799
4800	print " For experiment '" + exp + "' is required to plot:", Nplt, "plots"
4801
4802	if dbg:
4803	print 'Plots to draw _______'
4804	gen.printing_dictionary(listplots)
4805
4806	draw_plots(cnf, listplots, mod, exp, owdir, allcompvar, figscratch, dbg)
4807
4808	# end of experiments loop
4809
4810	### ## #
4811	# Experiment differences
4812	## # ## #
4813
4814	# Experiments loop
4815	##
4816	print ' ***** ** * * ** * * ** * ** *****'
4817	print " ** '" + mod + "': Inter experiments differences "
4818	print ' ***** ** * * ** * * ** * ** *****'
4819	print ' experiments:', exps
4820	# There are two kind of differences:
4821	# DIFFop: differences between operations of each given variable.
4822	# Differences are computed directly from the last stage of the operation
4823	# DIFFvar: operations of differences between variables
4824	# First are computed the differences from the initial variable file
4825	# and then operations are made
4826	# NOTE: remember that: meanvar2 - meanvar1 = mean(var2 - var1)
4827	difffiles = ['diffop.inf', 'diffvar.inf']
4828
4829	Nexps = len(exps)
4830	for iexp1 in range(0,Nexps-1):
4831	exp1 = exps[iexp1]
4832	for iexp2 in range(iexp1+1,Nexps):
4833	exp2 = exps[iexp2]
4834	Sexps = exp2 + '-' + exp1
4835	print ' ' + Sexps + '...'
4836	owdir = cnf['ofold'] + '/' + mod + '/' + exp2 + '-' + exp1
4837	sout = sub.call('mkdir -p ' + owdir, shell=True)
4838
4839	# Removing files with list of differences if should be started from scratch or add differences
4840	for fdiff in difffiles:
4841	difff = owdir + '/' + fdiff
4842	if diffscratch:
4843	sub.call('rm -rf' + owdir +' >& /dev/null', shell=True)
4844	sub.call('rm ' + difff +' >& /dev/null', shell=True)
4845	objf = open(owdir+'/all_' + fdiff,'w')
4846	objf.write("## Computation and drawing of differences " + \
4847	"between '" + exp2 + "'-'" + exp1 + "'\n")
4848	objf.close()
4849	difff = owdir + '/all_vardiffstatistics.inf'
4850	sub.call('rm ' + difff +' >& /dev/null', shell=True)
4851	objf = open(owdir+'/all_' + fdiff,'w')
4852	objf.write("## Computation of all differences statistics " + \
4853	"between '" + exp2 + "'-'" + exp1 + "'\n")
4854	objf.close()
4855
4856	if adddiffs:
4857	if dbg:
4858	print ' ' + main + ": adding differences removing file '" + \
4859	difff + "' ..."
4860	sub.call('rm ' + difff +' >& /dev/null', shell=True)
4861
4862	# op and var differences
4863	diffvarcompf = owdir + '/' + difffiles[0]
4864	if not os.path.isfile(diffvarcompf):
4865	alldiffop, alldiffvar,Nopdiffs,Nvardiffs=diffvarop_listconstruct(cnf,\
4866	[mod, mod], [exp1, exp2], [False, False], owdir, dbg)
4867	else:
4868	if dbg:
4869	print warnmsg
4870	print ' ' + main + ": getting 'op' and 'var' differences to " + \
4871	"compute already from file !!"
4872	alldiffop, Nopdiffops = read_diff_file(diffvarcompf)
4873	alldiffvar, Nopdiffvars = read_diff_file(owdir+'/'+difffiles[1])
4874	print 'Nopdiffops:', Nopdiffops,'Nopdiffvars:', Nopdiffvars
4875
4876	# End of avoiding to repeat all the experiment search
4877	print " For experiments '"+exp2+"'-'"+exp1+"' is required to " + \
4878	"compute:", Nvar, "differences"
4879
4880	if dbg:
4881	print 'Differences to compute _______'
4882	gen.printing_dictionary(alldiffop)
4883	gen.printing_dictionary(alldiffvar)
4884
4885	# Computing differences
4886	##
4887	print " Computing operation differences ..."
4888	compute_op_diffs(cnf, alldiffop, owdir, diffscratch, dbg)
4889	print " Computing variable differences ..."
4890	compute_var_diffs(cnf, alldiffvar, owdir, diffscratch, dbg)
4891
4892	# Plotting operation differences
4893	##
4894	print " " + main + ": Plotting operation differences' figures ..."
4895	dirfigf = owdir + '/diffopplotsdraw.inf'
4896	if figscratch:
4897	sout = sub.call('rm ' + dirfigf + ' >& /dev/null', shell=True)
4898
4899	objf = open(owdir+'/all_diffopfigures.inf','w')
4900	objf.write("## Drawing of all operation difference figures \n")
4901	objf.close()
4902
4903	if adddifffigures:
4904	if dbg:
4905	print ' ' + main + ": adding differences' figures removing " + \
4906	"file '" + dirfigf + "' ..."
4907
4908	sout = sub.call('rm ' + dirfigf + ' >& /dev/null', shell=True)
4909
4910	if not os.path.isfile(dirfigf):
4911	listplots, Nplt = plots_listconstruct(cnf, 'PLOTDIFFOP', dirfigf, \
4912	owdir, dbg)
4913	else:
4914	if dbg:
4915	print warnmsg
4916	print ' ' + main + ": getting plots to draw already from file !!"
4917	listplots, Nplt = read_plot_file(dirfigf)
4918
4919	# End of avoiding to repeat all the plots search
4920
4921	print " For experiment 'operation' differences '" + Sexps + "' is " + \
4922	"required to plot:" , Nplt, "plots"
4923
4924	if dbg:
4925	print ' Plots to draw _______'
4926	gen.printing_dictionary(listplots)
4927
4928	draw_diff_plots(cnf, listplots, owdir, alldiffop, 'diffop', \
4929	figdiffscratch, dbg)
4930
4931	# Plotting variable differences
4932	##
4933	print " " + main + ": Plotting variable differences' figures ..."
4934	dirfigf = owdir + '/diffvarplotsdraw.inf'
4935	if figscratch:
4936	sout = sub.call('rm ' + dirfigf + ' >& /dev/null', shell=True)
4937
4938	objf = open(owdir+'/all_diffvarfigures.inf','w')
4939	objf.write("## Drawing of all variables difference figures \n")
4940	objf.close()
4941
4942	if adddifffigures:
4943	if dbg:
4944	print ' '+main+": adding differences' figures removing file '" +\
4945	dirfigf + "' ..."
4946	sout = sub.call('rm ' + dirfigf + ' >& /dev/null', shell=True)
4947
4948	if not os.path.isfile(dirfigf):
4949	listplots, Nplt = plots_listconstruct(cnf, 'PLOTDIFFVAR', dirfigf, \
4950	owdir, dbg)
4951	else:
4952	if dbg:
4953	print warnmsg
4954	print ' ' + main + ": getting plots to draw already from file !!"
4955	listplots, Nplt = read_plot_file(dirfigf)
4956
4957	# End of avoiding to repeat all the plots search
4958
4959	print " For experiment 'variables' differences '" + Sexps + "' is " + \
4960	"required to plot:" , Nplt, "plots"
4961
4962	if dbg:
4963	print ' Plots to draw _______'
4964	gen.printing_dictionary(listplots)
4965
4966	draw_diff_plots(cnf, listplots, owdir, alldiffvar, 'diffvar', \
4967	figdiffscratch, dbg)
4968
4969	# end of mods loop
4970
4971	### ## #
4972	# Model differences
4973	### ## #
4974
4975	# Models already at the reference projection
4976	ModComProj = cnf['RefProj'].split(':')
4977	if dbg:
4978	print 'Models to use as reference for the projection:', ModComProj
4979
4980	# Operators to use for the reprojection of each variable
4981	REPRJvar0 = gen.get_specdictionary_HMT(cnf, H='reprojectvar_')
4982	REPRJvar = {}
4983	for Skey in REPRJvar0.keys():
4984	REPRJvar[Skey] = gen.str_list(REPRJvar0[Skey],':')
4985
4986	if dbg:
4987	print 'Remaping operators to use _______'
4988	gen.printing_dictionary(REPRJvar)
4989
4990	# Getting common base weights for grid point remapping with CDO
4991	frefgridn = 'RefProj.nc'
4992	for mod in mods:
4993	frefgriddes = cnf['ofold'] + '/' + mod + '/' + frefgridn
4994	if moddiffscratch:
4995	sout = sub.call('rm ' + frefgriddes + ' >& /dev/null', shell=True)
4996	if gen.searchInlist(ModComProj,mod) and not os.path.isfile(frefgriddes):
4997	# Looking for a file to use (all files are CF compilant, but we need to
4998	# be sure that at least they have 'lon', 'lat' variables)
4999	exps = modexps[mod]
5000	exp = exps[0]
5001	reprjfdir = cnf['ofold'] + '/' + mod + '/' + exp
5002	reprjfile = None
5003	for reprjop in REPRJvar.keys():
5004	reprjvars = REPRJvar[reprjop]
5005	for reprjvar in reprjvars:
5006	reprjfs= gen.files_folder_HMT(folder=reprjfdir,head=reprjvar+'_',tail='.nc')
5007	for reprjf in reprjfs:
5008	# Getting direct files as [var]_[fhead].nc
5009	if len(reprjf.split('_')) == 2:
5010	reprjfile = reprjfdir + '/' + reprjf
5011	reprjvn = reprjvar
5012	break
5013	if reprjfile is None:
5014	print errmsg
5015	print ' ' + main + ": no proper file to get projection information " + \
5016	"from '" + reprjfdir + "' has been found !!"
5017	quit(-1)
5018
5019	print " Creation of reference projection information file from '" + mod+ "'"
5020	if dbg:
5021	print " using file: '" + reprjfile
5022
5023	# Getting only 1 time-step for disk space issues
5024	try:
5025	with gen.Capturing() as output:
5026	ncvar.DataSetSection('time,0,1,1', reprjfile)
5027	except:
5028	print errmsg
5029	print 'ncvar.DataSetSection(time,0,1,1, ' + reprjfile + ')'
5030	for s1out in output: print s1out
5031	quit(-1)
5032
5033	of = reprjfile.split('.')[0] + '_time_B0-E1-I1.nc'
5034
5035	# Cleaning variables
5036	try:
5037	with gen.Capturing() as output:
5038	ncvar.selvar('lon@lon,lat@lat,time@time', of, reprjvn)
5039	except:
5040	print errmsg
5041	print 'ncvar.selvar(lon@lon,lat@lat, ' + of + ', ' + reprjvn + ')'
5042	for s1out in output: print s1out
5043	quit(-1)
5044	sout = sub.call('mv selvar_new.nc ' + frefgriddes, shell=True)
5045	sout = sub.call('rm ' + of + ' >& /dev/null', shell=True)
5046
5047	cnf['RefProjfile'] = frefgriddes
5048
5049	if dbg:
5050	for s1out in output: print s1out
5051	break
5052
5053	elif gen.searchInlist(ModComProj,mod) and os.path.isfile(frefgriddes):
5054	# Including reprojecting reference file in configuration dictionary
5055	cnf['RefProjfile'] = frefgriddes
5056
5057	Nmods = len(mods)
5058	for imod1 in range(0,Nmods-1):
5059	mod1 = mods[imod1]
5060	exps1 = modexps[mod1]
5061
5062	for imod2 in range(imod1+1,Nmods):
5063	mod2 = mods[imod2]
5064	exps2 = modexps[mod2]
5065
5066	Smods = mod2 + '-' + mod1
5067	print ' ***** ** * * ** * * ** * ** *****'
5068	print " ** '" + Smods + "': Inter models differences "
5069	print ' ***** ** * * ** * * ** * ** *****'
5070	print ' experiments mod1:', exps1
5071	print ' experiments mod2:', exps2
5072
5073	# Experiments loop
5074	##
5075	difffiles = ['diffop.inf', 'diffvar.inf']
5076
5077	Nexps1 = len(exps1)
5078	Nexps2 = len(exps2)
5079	for iexp1 in range(0,Nexps1):
5080	exp1 = exps1[iexp1]
5081	for iexp2 in range(0,Nexps2):
5082	exp2 = exps2[iexp2]
5083	Sexps = exp2 + '-' + exp1
5084	print ' ' + Sexps + '...'
5085	owdir = cnf['ofold'] + '/' + Smods + '/' + Sexps
5086	sout = sub.call('mkdir -p ' + owdir, shell=True)
5087
5088	# Getting the right projection in order to perform differences
5089	difmods = [mod1, mod2]
5090	difexps = [exp1, exp2]
5091	difreproj = [False, False]
5092
5093	for imod in range(2):
5094	mod = difmods[imod]
5095	exp = difexps[imod]
5096	if not gen.searchInlist(ModComProj,mod):
5097	print " Projecting files of model '" + mod + "' exp: '" + \
5098	exp + "' with file '" + cnf['RefProjfile'] + "'"
5099	reproject_modexp(mod, exp, cnf, REPRJvar, moddiffscratch, \
5100	addmoddiffs, dbg)
5101	difreproj[imod] = True
5102
5103	# Removing files with list of differences if should be started from
5104	# scratch or add differences
5105	for fdiff in difffiles:
5106	difff = owdir + '/' + fdiff
5107	if moddiffscratch:
5108	sub.call('rm -rf' + owdir +' >& /dev/null', shell=True)
5109	sub.call('rm ' + difff +' >& /dev/null', shell=True)
5110	objf = open(owdir+'/all_' + fdiff,'w')
5111	objf.write("## Computation and drawing of differences " + \
5112	"between '" + mod2+'@'+exp2 + "'-'" + mod1+'@'+exp1 + "'\n")
5113	objf.close()
5114	difff = owdir + '/all_vardiffstatistics.inf'
5115	sub.call('rm ' + difff +' >& /dev/null', shell=True)
5116	objf = open(owdir+'/all_' + fdiff,'w')
5117	objf.write("## Computation of all differences statistics " + \
5118	"between '" + mod2+'@'+exp2 + "'-'" + mod1+'@'+exp1 + "'\n")
5119	objf.close()
5120
5121	if addmoddiffs:
5122	if dbg:
5123	print ' ' + main + ": adding model differences " + \
5124	"removing file '" + difff + "' ..."
5125	sub.call('rm ' + difff +' >& /dev/null', shell=True)
5126
5127	# op and var differences
5128	diffvarcompf = owdir + '/' + difffiles[0]
5129	if not os.path.isfile(owdir+'/'+difffiles[0]) or \
5130	not os.path.isfile(owdir+'/'+difffiles[1]):
5131	alldiffop, alldiffvar, Nopdiffs, Nvardiffs = \
5132	diffvarop_listconstruct(cnf, difmods, difexps, difreproj,owdir,\
5133	dbg)
5134	else:
5135	if dbg:
5136	print warnmsg
5137	print ' '+main+": getting 'op' and 'var' differences to " + \
5138	"compute already from file !!"
5139	alldiffop, Nopdiffops = read_diff_file(diffvarcompf)
5140	alldiffvar, Nopdiffvars = read_diff_file(owdir+'/'+difffiles[1])
5141
5142	# End of avoiding to repeat all the experiment search
5143
5144	print " For experiments '" + mod2+'@'+exp2 + "'-'" + mod+'@'+exp1+\
5145	"' is required to compute:", Nvar, "differences"
5146
5147	if dbg:
5148	print ' op differences to compute _______'
5149	gen.printing_dictionary(alldiffop)
5150	print ' var differences to compute _______'
5151	gen.printing_dictionary(alldiffvar)
5152
5153	# Computing differences
5154	##
5155	print " Computing operation differences ..."
5156	compute_op_diffs(cnf, alldiffop, owdir, moddiffscratch, dbg)
5157	print " Computing variable differences ..."
5158	compute_var_diffs(cnf, alldiffvar, owdir, moddiffscratch, dbg)
5159
5160	# Plotting operation differences
5161	##
5162	print " " + main + ": Plotting operation differences' figures ..."
5163	dirfigf = owdir + '/diffopplotsdraw.inf'
5164	if figmoddiffscratch:
5165	sout = sub.call('rm ' + dirfigf + ' >& /dev/null', shell=True)
5166
5167	objf = open(owdir+'/all_diffopfigures.inf','w')
5168	objf.write("## Drawing of all operation difference figures \n")
5169	objf.close()
5170
5171	if addmoddifffigures:
5172	if dbg:
5173	print ' ' + main + ": adding model differences' figures " + \
5174	"removing file '" + dirfigf + "' ..."
5175	sout = sub.call('rm ' + dirfigf + ' >& /dev/null', shell=True)
5176
5177	if not os.path.isfile(dirfigf):
5178	listplots, Nplt = plots_listconstruct(cnf, 'PLOTDIFFOP', dirfigf,\
5179	owdir, dbg)
5180	else:
5181	if dbg:
5182	print warnmsg
5183	print ' '+main+": getting plots to draw already from file !!"
5184	listplots, Nplt = read_plot_file(dirfigf)
5185
5186	# End of avoiding to repeat all the plots search
5187
5188	print " For experiment 'operation' differences '" + Sexps + "' is "+\
5189	"required to plot:" , Nplt, "plots"
5190
5191	if dbg:
5192	print 'Plots to draw _______'
5193	gen.printing_dictionary(listplots)
5194
5195	draw_diff_plots(cnf, listplots, owdir, alldiffop, 'diffop', \
5196	figmoddiffscratch, dbg)
5197
5198	# Plotting variable differences
5199	##
5200	print " " + main + ": Plotting variable differences' figures ..."
5201	dirfigf = owdir + '/diffvarplotsdraw.inf'
5202	if figscratch:
5203	sout = sub.call('rm ' + dirfigf + ' >& /dev/null', shell=True)
5204
5205	objf = open(owdir+'/all_diffvarfigures.inf','w')
5206	objf.write("## Drawing of all variables difference figures \n")
5207	objf.close()
5208
5209	if adddifffigures:
5210	if dbg:
5211	print ' ' + main + ": adding differences's figures " + \
5212	"removing file '" + dirfigf + "' ..."
5213	sout = sub.call('rm ' + dirfigf + ' >& /dev/null', shell=True)
5214
5215	if not os.path.isfile(dirfigf):
5216	listplots, Nplt = plots_listconstruct(cnf,'PLOTDIFFVAR',dirfigf, \
5217	owdir, dbg)
5218	else:
5219	if dbg:
5220	print warnmsg
5221	print ' '+main+": getting plots to draw already from file !!"
5222	listplots, Nplt = read_plot_file(dirfigf)
5223
5224	# End of avoiding to repeat all the plots search
5225
5226	print " For experiment 'variables' differences '" + Sexps+ "' is "+ \
5227	"required to plot:" , Nplt, "plots"
5228
5229	if dbg:
5230	print ' Plots to draw _______'
5231	gen.printing_dictionary(listplots)
5232
5233	draw_diff_plots(cnf, listplots, owdir, alldiffvar, 'diffvar', \
5234	figdiffscratch, dbg)
5235
5236	# end of exp2 loop
5237	# end of exp1 loop
5238	# end of mod2 loop
5239	# end of mod1 loop
5240
5241	### ## #
5242	# All model/exps linear plots
5243	### ## #
5244
5245	allmodexps = []
5246	for mod in mods:
5247	for exp in modexps[mod]:
5248	allmodexps.append(mod + '/' + exp)
5249
5250	print ' ***** ** * * ** * * ** * ** *****'
5251	print ' ** Multi models, multi experiments plots '
5252	print ' ***** ** * * ** * * ** * ** *****'
5253	print ' Model/experiments:', allmodexps
5254
5255	owdir = cnf['ofold'] + '/allmodexps'
5256	sout = sub.call('mkdir -p ' + owdir, shell=True)
5257
5258	# Plotting all model-experiments lines
5259	##
5260	print " " + main + ": Plotting all model-experiments variable figures ..."
5261	allf = owdir + '/allmodexp.inf'
5262	dirfigf = owdir + '/allmodexpfigures.inf'
5263	allfigf = owdir+'/all_figures.inf'
5264	if figallmodexpscratch:
5265	sout = sub.call('rm ' + allf + ' >& /dev/null', shell=True)
5266	sout = sub.call('rm ' + dirfigf + ' >& /dev/null', shell=True)
5267	sout = sub.call('rm ' + allfigf + ' >& /dev/null', shell=True)
5268
5269	objf = open(allfigf,'w')
5270	objf.write("## Drawing of all variables figures for all model-experiments\n")
5271	objf.close()
5272
5273	if addallmodexpfigures:
5274	if dbg:
5275	print ' ' + main + ": adding model-experiment differences removing " + \
5276	" file '" + allfigf + "' ..."
5277	print ' ' + main + ": adding model-experiment differences' figures " + \
5278	"removing file '" + dirfigf + "' ..."
5279	sout = sub.call('rm ' + allfigf + ' >& /dev/null', shell=True)
5280	sout = sub.call('rm ' + dirfigf + ' >& /dev/null', shell=True)
5281
5282	if not os.path.isfile(dirfigf):
5283	listplots, Nplt = plots_listconstruct(cnf, 'PLOTALLMODEXP', dirfigf, owdir, dbg)
5284	else:
5285	if dbg:
5286	print warnmsg
5287	print ' ' + main + ": getting plots to draw already from file !!"
5288	listplots, Nplt = read_plot_file(dirfigf)
5289
5290	# End of avoiding to repeat all the plots search
5291
5292	print " Is required to plot:", Nplt, " all model-experiment plots"
5293
5294	if dbg:
5295	print ' Plots to draw _______'
5296	gen.printing_dictionary(listplots)
5297
5298	if not os.path.isfile(allf):
5299	# Constructing the information of modexp / variable
5300	allmodexpvar, Nallmodexpvar = allmodexps_listconstruct(cnf, allmodexps, owdir, dbg)
5301	else:
5302	allmodexpvar, Nallmodexpvar = allmodexps_read(allf)
5303
5304	draw_allmodexp_plots(cnf, allmodexpvar, listplots, modexps, owdir, figallmodexpscratch, dbg)
5305
5306	print main + ': all files and figures have been properly done !!'
5307
5308	# Creation of a pdf with all figures
5309	##
5310	###
5311	owdir = cnf['ofold']
5312	os.chdir(owdir)
5313
5314	texout ='model_graphics-images'
5315	print ' ***** ** * * ** * * ** * ** *****'
5316	print ' ** Creation of a pdf with all figures '
5317	print ' ***** ** * * ** * * ** * ** *****'
5318	print ' ' + owdir + '/' + texout + '.pdf'
5319
5320	if dbg:
5321	print main + ": generation of a pdf file '" + owdir + '/' + texout + \
5322	"' with all the figures..."
5323
5324	otexf = open(owdir + '/' + texout + '.tex', 'w')
5325	otexf.write('\\documentclass{article}\n')
5326	otexf.write('\\usepackage{graphicx}\n')
5327	otexf.write('\\usepackage[colorlinks=true,urlcolor=blue]{hyperref}\n')
5328	otexf.write('\\textheight=23cm\n')
5329	otexf.write('\\textwidth=18cm\n')
5330	otexf.write('\\oddsidemargin=-1cm\n')
5331	otexf.write('\\evensidemargin=-1cm\n')
5332	otexf.write('\\topmargin=-1cm\n')
5333
5334	otexf.write('\n')
5335	otexf.write('\\begin{document}\n')
5336	otexf.write('\n')
5337	otexf.write('\\def\\fontBloc{\\fontfamily{\\sfdefault}\\large\\bfseries}\n')
5338	otexf.write('\\def\\linia{\\setlength{\\unitlength}{1mm}\n')
5339	otexf.write('\\line(1,0){80}}\n')
5340	otexf.write('\\newcommand{\\modexp}[1]{\\clearpage\n')
5341	otexf.write('\\noindent\\linia\n')
5342	otexf.write('\\section{#1}\n')
5343	otexf.write('\\linia}\n')
5344	otexf.write('\n')
5345
5346	otexf.write('\\title{model\_graphics: ' + gen.latex_text(owdir) + '}\n')
5347	otexf.write('\\maketitle\n')
5348	otexf.write('\n')
5349	otexf.write('\\tableofcontents\n')
5350	otexf.write('\\listoffigures\n')
5351	otexf.write('\\clearpage\n')
5352
5353	Nmods = len(mods)
5354	lmodexps = []
5355	ldiffmodexps = []
5356	# Figures from mod/exp pairs
5357	for mod in mods:
5358	exps = modexps[mod]
5359	for exp in exps:
5360	print ' direct plots:', mod, exp
5361	lmodexps.append(mod+'/'+exp)
5362	owdirme = owdir + '/' + mod + '/' + exp
5363	otexf.write('% ' + mod + ' ' + exp + '\n')
5364	otexf.write('\\modexp{' + gen.latex_text(mod+' '+exp) + '}\n')
5365	listplots, Nplt = read_plot_file(owdirme + '/directplotsdraw.inf')
5366	for plot in listplots.keys():
5367	plots = listplots[plot]
5368	ops = []
5369	for plt in plots:
5370	opn = plt.split('#')[0].split('\|')[1]
5371	if not gen.searchInlist(ops,opn): ops.append(opn)
5372	for op in ops:
5373	opS = op.replace('+','_')
5374	modexpimg = gen.files_folder_HMT(owdirme, head=plot, middle=opS, \
5375	tail=cnf['kindfig'])
5376	Nimages = len(modexpimg)
5377	if Nimages > 0:
5378	for img in range(Nimages): modexpimg[img] = owdirme + '/' + \
5379	modexpimg[img]
5380	caption = mod + ' ' + exp + ' ' + plot + ' ' + op
5381	flab = 'fig:' + caption.replace(' ', '_')
5382	try:
5383	with gen.Capturing() as output:
5384	gen.latex_fig_array(modexpimg, otexf, \
5385	gen.latex_text(caption), flab, refsize=0.5, dist='sqr',\
5386	dorest='center')
5387	except:
5388	print errmsg
5389	print 'gen.latex_fig_array(',modexpimg,', '+otexf+', '+ \
5390	'gen.latex_text(' + caption + '), ' + flab + \
5391	", refsize=0.5, dist='sqr', dorest='center')"
5392	for s1out in output: print s1out
5393	quit(-1)
5394	otexf.write('%\\clearpage\n')
5395
5396	# differences between experiments
5397	Nexps = len(exps)
5398	for iexp1 in range(0,Nexps-1):
5399	exp1 = exps[iexp1]
5400	for iexp2 in range(iexp1+1,Nexps):
5401	exp2 = exps[iexp2]
5402	Sexps = exp2 + '-' + exp1
5403	owdirme = owdir + '/' + mod + '/' + Sexps
5404	print ' diffs:', mod + '/' + Sexps + ' ...'
5405	ldiffmodexps.append(mod + '/' + Sexps)
5406	for diffn in ['op', 'var']:
5407	fileplotinf = owdirme + '/diff' + diffn + 'plotsdraw.inf'
5408	if os.path.isfile(fileplotinf):
5409	otexf.write('% ' + mod + ' ' + Sexps + ' diff' + diffn + '\n')
5410	otexf.write('\\modexp{' + gen.latex_text(mod+' '+Sexps+' diff'+ \
5411	diffn)+ '}\n')
5412	listplots, Nplt = read_plot_file(fileplotinf)
5413	for plot in listplots.keys():
5414	plots = listplots[plot]
5415	ops = []
5416	for plt in plots:
5417	opn = plt.split('#')[0].split('\|')[1]
5418	if not gen.searchInlist(ops,opn): ops.append(opn)
5419	for op in ops:
5420	opS = op.replace('+','-')
5421	modexpimg = gen.files_folder_HMT(owdirme, head=plot, \
5422	middle=opS, tail=cnf['kindfig'])
5423	Nimages = len(modexpimg)
5424	if Nimages > 0:
5425	for img in range(Nimages): modexpimg[img] = owdirme +\
5426	'/' + modexpimg[img]
5427	caption = mod + ' ' + Sexps + ' ' + plot + ' ' + op +\
5428	' diff' + diffn
5429	flab = 'fig:' + caption.replace(' ', '_')
5430	try:
5431	with gen.Capturing() as output:
5432	gen.latex_fig_array(modexpimg, otexf, \
5433	gen.latex_text(caption), flab, refsize=0.5,\
5434	dist='sqr', dorest='center')
5435	except:
5436	print errmsg
5437	print 'gen.latex_fig_array(',modexpimg,', '+ \
5438	otexf+', gen.latex_text(' + caption + '), ' + \
5439	flab + ", refsize=0.5, dist='sqr', " + \
5440	"dorest='center')"
5441	for s1out in output: print s1out
5442	quit(-1)
5443
5444	otexf.write('%\\clearpage\n')
5445	print ' mods-exps diffs ...'
5446	for imod1 in range(0,Nmods-1):
5447	mod1 = mods[imod1]
5448	exps1 = modexps[mod1]
5449	for imod2 in range(imod1+1,Nmods):
5450	mod2 = mods[imod2]
5451	exps2 = modexps[mod2]
5452
5453	Smods = mod2 + '-' + mod1
5454	Nexps1 = len(exps1)
5455	Nexps2 = len(exps2)
5456	for iexp1 in range(0,Nexps1):
5457	exp1 = exps1[iexp1]
5458	for iexp2 in range(0,Nexps2):
5459	exp2 = exps2[iexp2]
5460	Sexps = exp2 + '-' + exp1
5461	print ' ' + Smods + ' ' + Sexps + ' ...'
5462	ldiffmodexps.append(Smods + '/' + Sexps)
5463	owdirme = owdir + '/' + Smods + '/' + Sexps
5464	for diffn in ['op', 'var']:
5465	fileplotinf = owdirme + '/diff' + diffn + 'plotsdraw.inf'
5466	if os.path.isfile(fileplotinf):
5467	otexf.write('% '+Smods + ' ' + Sexps + ' diff'+diffn+'\n')
5468	otexf.write('\\modexp{' + gen.latex_text(Smods+' '+Sexps+\
5469	' diff'+diffn) + '}\n')
5470	listplots, Nplt = read_plot_file(fileplotinf)
5471	for plot in listplots.keys():
5472	plots = listplots[plot]
5473	ops = []
5474	for plt in plots:
5475	opn = plt.split('#')[0].split('\|')[1]
5476	if not gen.searchInlist(ops,opn): ops.append(opn)
5477	for op in ops:
5478	opS = op.replace('+','-')
5479	modexpimg = gen.files_folder_HMT(owdirme, \
5480	head=plot, middle=opS, tail=cnf['kindfig'])
5481	Nimages = len(modexpimg)
5482	if Nimages > 0:
5483	for img in range(Nimages): modexpimg[img] = \
5484	owdirme + '/' + modexpimg[img]
5485	caption = Smods + ' ' + Sexps + ' ' + plot + \
5486	' ' + op + ' diff' + diffn
5487	flab = 'fig:' + caption.replace(' ', '_')
5488	try:
5489	with gen.Capturing() as output:
5490	gen.latex_fig_array(modexpimg, otexf,\
5491	gen.latex_text(caption), flab, \
5492	refsize=0.5, dist='sqr', \
5493	dorest='center')
5494	except:
5495	print errmsg
5496	print 'gen.latex_fig_array(',modexpimg, \
5497	', '+otexf+', gen.latex_text(' + \
5498	caption + '), '+flab+ ", refsize=0.5,"+\
5499	" dist='sqr', dorest='center')"
5500	for s1out in output: print s1out
5501	quit(-1)
5502	otexf.write('%\\clearpage\n')
5503
5504	# allmodexp
5505	owdirme = owdir + '/allmodexps'
5506	print ' allmodexps...'
5507	fileplotinf = owdirme + '/allmodexpfigures.inf'
5508	if os.path.isfile(fileplotinf):
5509	otexf.write('% allmodexps\n')
5510	otexf.write('\\modexp{allmodexps}\n')
5511	listplots, Nplt = read_plot_file(fileplotinf)
5512	for plot in listplots.keys():
5513	plots = listplots[plot]
5514	ops = []
5515	for plt in plots:
5516	opn = plt.split('\|')[1]
5517	if not gen.searchInlist(ops,opn): ops.append(opn)
5518	for op in ops:
5519	opS = op.replace('+','-')
5520	modexpimg = gen.files_folder_HMT(owdirme, head=plot, middle=opS, \
5521	tail=cnf['kindfig'])
5522	Nimages = len(modexpimg)
5523	if Nimages > 0:
5524	for img in range(Nimages): modexpimg[img] = owdirme + '/' + \
5525	modexpimg[img]
5526	caption = 'allmodexps ' + plot + ' ' + op + ' diff' + diffn
5527	flab = 'fig:' + caption.replace(' ', '_')
5528	try:
5529	with gen.Capturing() as output:
5530	gen.latex_fig_array(modexpimg,otexf, gen.latex_text(caption),\
5531	flab, refsize=0.9, dist='sqr', dorest='center')
5532	except:
5533	print errmsg
5534	print 'gen.latex_fig_array(',modexpimg,', '+otexf+ \
5535	', gen.latex_text(' + caption + '), ' +flab+ ", refsize=0.9," +\
5536	" dist='sqr', dorest='center')"
5537	for s1out in output: print s1out
5538	quit(-1)
5539
5540	otexf.write('%\\clearpage\n')
5541	#
5542	# Grouping by type of figure
5543	#
5544	Nmods = len(mods)
5545	# Figures from mod/exp pairs
5546	owsearch = owdir + '/' + mods[0] + '/' + modexps[mods[0]][0]
5547	print " Looking in '" + owsearch + "' for figures by kind and variable..."
5548	otexf.write('% figures by kind and variable from:' + owsearch + '\n')
5549	modexpimg = gen.files_folder_HMT(owsearch, tail=cnf['kindfig'])
5550	# dictionary with kind of plots
5551	dplots = {}
5552	# list with kind of plots
5553	lplots = []
5554	# dictionary with variable-statistics of each kind of plot
5555	dvarstats = {}
5556	# list with variables of each kind of plot
5557	lvars = []
5558	for plot in modexpimg:
5559	Nvars, plotk, varn, statn = figinf_figname(plot,cnf)
5560	if not gen.searchInlist(lplots,plotk):
5561	lplots.append(plotk)
5562	if not dplots.has_key(plotk+'_'+varn):
5563	if not gen.searchInlist(lvars,varn): lvars.append(varn)
5564	dplots[plotk+'_'+varn] = [statn]
5565	else:
5566	vals = dplots[plotk+'_'+varn]
5567	dplots[plotk+'_'+varn] = vals + [statn]
5568	else:
5569	if not dplots.has_key(plotk+'_'+varn):
5570	if not gen.searchInlist(lvars,varn): lvars.append(varn)
5571	dplots[plotk+'_'+varn] = [statn]
5572	else:
5573	vals = dplots[plotk+'_'+varn]
5574	dplots[plotk+'_'+varn] = vals + [statn]
5575
5576	# Figures found
5577	print ' direct figures to group:', modexpimg
5578	print ' plots:', lplots
5579	print ' variables:', lvars
5580
5581	for dplot in dplots.keys():
5582	plot = dplot.split('_')[0]
5583	var = dplot.split('_')[1]
5584	otexf.write('% ' + var + '\n')
5585	otexf.write('\\modexp{' + gen.latex_text(var) + '}\n')
5586	varn1 = var.split('-')[0]
5587	varn2 = var.split('-')[1]
5588	varn = varn1+'-'+varn2
5589	for stn12 in dplots[dplot]:
5590	stn1 = stn12.split('@')[0]
5591	stn2 = stn12.split('@')[1]
5592	stn = gen.lstring_values(stn12, '@',' & ')
5593	plotvarfigs = []
5594	caption = varn.replace('-',' & ') + ' ' + plot + ' ' + stn
5595	flab = 'fig:' + varn + '_' + plot + '_' + stn12 + '_allmodexp'
5596	for me in lmodexps:
5597	modexpn = expGC[me].label
5598	modn = me.split('/')[0]
5599	imgns = gen.files_folder_HMT(owdir+'/'+me, head=plot+'_'+varn1, \
5600	middle=stn1+'-'+varn2, tail=stn2+'.'+cnf['kindfig'])
5601	caption = caption + ', ' + modexpn
5602	imgn = owdir+'/'+me+'/'+imgns[0]
5603	if os.path.isfile(imgn):
5604	plotvarfigs.append(imgn)
5605	if dbg:
5606	print ' Grouping figures:', plotvarfigs
5607	try:
5608	with gen.Capturing() as output:
5609	gen.latex_fig_array(plotvarfigs, otexf, gen.latex_text(caption), \
5610	flab, refsize=0.9, dist='sqr', dorest='center')
5611	except:
5612	print errmsg
5613	print 'gen.latex_fig_array(',plotvarfigs,', '+otexf+', gen.latex_text(' +\
5614	caption + '), ' + flab + ", refsize=0.9, dist='sqr', dorest='center')"
5615	for s1out in output: print s1out
5616	quit(-1)
5617
5618	Nmods = len(mods)
5619	# Figures from mod/exp differences
5620	owsearch = owdir + '/' + ldiffmodexps[0]
5621	print " Looking in '" + owsearch + "' for difference figures by kind and variable..."
5622	otexf.write('% difference figures by kind and variable from:' + owsearch + '\n')
5623	modexpimg = gen.files_folder_HMT(owsearch, tail=cnf['kindfig'])
5624	# dictionary with kind of plots
5625	dplots = {}
5626	# list with kind of plots
5627	lplots = []
5628	# dictionary with variable-statistics of each kind of plot
5629	dvarstats = {}
5630	# list with variables of each kind of plot
5631	lvars = []
5632	for plot in modexpimg:
5633	Nvars, plotk, varn, statn = figinf_figname(plot,cnf)
5634	if not gen.searchInlist(lplots,plotk):
5635	lplots.append(plotk)
5636	if not dplots.has_key(plotk+'_'+varn):
5637	if not gen.searchInlist(lvars,varn): lvars.append(varn)
5638	dplots[plotk+'_'+varn] = [statn]
5639	else:
5640	vals = dplots[plotk+'_'+varn]
5641	dplots[plotk+'_'+varn] = vals + [statn]
5642	else:
5643	if not dplots.has_key(plotk+'_'+varn):
5644	if not gen.searchInlist(lvars,varn): lvars.append(varn)
5645	dplots[plotk+'_'+varn] = [statn]
5646	else:
5647	vals = dplots[plotk+'_'+varn]
5648	dplots[plotk+'_'+varn] = vals + [statn]
5649
5650	# Figures found
5651	print ' difference figures to group:', modexpimg
5652	print ' plots:', lplots
5653	print ' variables:', lvars
5654
5655	for dplot in dplots.keys():
5656	plot = dplot.split('_')[0]
5657	var = dplot.split('_')[1]
5658	otexf.write('% ' + var + '\n')
5659	otexf.write('\\modexp{diff ' + gen.latex_text(var) + '}\n')
5660	varn1 = var.split('-')[0]
5661	varn2 = var.split('-')[1]
5662	varn = varn1+'-'+varn2
5663	for stn12 in dplots[dplot]:
5664	stn1 = stn12.split('@')[0]
5665	stn2 = stn12.split('@')[1]
5666	stn = gen.lstring_values(stn12, '@',' & ')
5667	plotvarfigs = []
5668	caption = varn.replace('-',' & ') + ' ' + plot + ' ' + stn
5669	flab = 'fig:' + varn + '_' + plot + '_' + stn12 + '_alldiffmodexp'
5670	for me in ldiffmodexps:
5671	mods = me.split('/')[0]
5672	exps = me.split('/')[1]
5673	if exps.find('-') != -1:
5674	expn1 = exps.split('-')[0]
5675	expn2 = exps.split('-')[1]
5676	else:
5677	expn1 = exps
5678	expn2 = exps
5679
5680	if mods.find('-') != -1:
5681	modn1 = mods.split('-')[0]
5682	modn2 = mods.split('-')[1]
5683	else:
5684	modn1 = mods
5685	modn2 = mods
5686	modexpn1 = expGC[modn1 + '/' + expn1].label
5687	modexpn2 = expGC[modn2 + '/' + expn2].label
5688	modexpn = modexpn1 + '-' + modexpn2
5689
5690	modn = me.split('/')[0]
5691	imgns = gen.files_folder_HMT(owdir+'/'+me, head=plot+'_'+varn1, \
5692	middle=stn1+'-'+varn2, tail=stn2+'.'+cnf['kindfig'])
5693	caption = caption + ', ' + modexpn
5694	imgn = owdir+'/'+me+'/'+imgns[0]
5695	if os.path.isfile(imgn):
5696	plotvarfigs.append(imgn)
5697	if dbg:
5698	print ' Grouping figures:', plotvarfigs
5699	try:
5700	with gen.Capturing() as output:
5701	gen.latex_fig_array(plotvarfigs, otexf, gen.latex_text(caption), \
5702	flab, refsize=0.9, dist='sqr', dorest='center')
5703	except:
5704	print errmsg
5705	print 'gen.latex_fig_array(',plotvarfigs,', '+otexf+', gen.latex_text('+ \
5706	caption + '), ' + flab + ", refsize=0.9, dist='sqr', dorest='center')"
5707	for s1out in output: print s1out
5708	quit(-1)
5709
5710	otexf.write('\\end{document}\n')
5711	otexf.close()
5712
5713	try:
5714	with gen.Capturing() as output:
5715	ins = 'pdflatex ' + owdir + '/' + texout
5716	sout = sub.call(ins, shell=True)
5717	except:
5718	print errormsg
5719	print ' ' + ins
5720	print sout
5721	for s1out in output: print s1out
5722	quit(-1)
5723
5724	with gen.Capturing() as output:
5725	sout = sub.call(ins + '>& /dev/null', shell=True)
5726	with gen.Capturing() as output:
5727	sout = sub.call(ins + '>& /dev/null', shell=True)
5728	with gen.Capturing() as output:
5729	sout = sub.call(ins + '>& /dev/null', shell=True)
5730	with gen.Capturing() as output:
5731	sout = sub.call(ins, shell=True)
5732	if dbg:
5733	print sout
5734	for s1out in output: print s1out
5735
5736	sub.call('evince ' + owdir + '/' + texout + '.pdf &', shell=True)
5737

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

Download in other formats: