Index: trunk/tools/drawing.py
===================================================================
--- trunk/tools/drawing.py	(revision 192)
+++ trunk/tools/drawing.py	(revision 192)
@@ -0,0 +1,2300 @@
+import numpy as np
+import os
+from netCDF4 import Dataset as NetCDFFile
+import drawing_tools as drw
+from optparse import OptionParser
+import sys
+from cStringIO import StringIO
+
+## g.e. # drawing.py -f /media/data2/etudes/WRF_LMDZ/WL_HyMeX/IIphase/medic950116/wlmdza/wrfout/wrfout_d01_1995-01-13_00:00:00 -o create_movie -S 'draw_2D_shad#Time@WRFTimes@10@95@191@1#tas:East_West|-1,North_South|-1,Time|2:longitude:latitude:Summer:270.,300.:tas|at|t=0:pdf:None:None' -v T2
+## g.e. # drawing.py -f wrfout_d01_1980-03-01_00\:00\:00_Time_B0-E48-I1.nc -o draw_2D_shad -S 'tas:East_West|-1,North_South|-1,Time|2:longitude:latitude:Summer:270.,300.:tas|at|t=0:pdf:None:cyl,i' -v T2
+## g.e. # drawing.py -f ~/etudes/domains/MEDCORDEX/geo_em.d01.nc -o draw_2D_shad_cont -S 'landmask,height:Time|0:Time|0:XLONG_M:XLAT_M:rainbow:fixc,k:%.2f:0,1:0.,3000.,10:landmask & height:pdf:False:lcc,i' -v LANDMASK,HGT_M
+## g.e. # drawing.py -f ~/etudes/domains/MEDCORDEX/geo_em.d01.nc -o draw_2D_shad_cont -S 'height,landmask:Time|0:Time|0:XLONG_M:XLAT_M:terrain:fixc,k:None:0.,3000.:0,1,10:MEDCORDEX height & landmask:pdf:False:lcc,i' -v HGT_M,LANDMASK
+## g.e. # drawing.py -o draw_2D_shad_line -f 'mean_dtcon-pluc-pres_lat.nc,mean_dtcon-pluc-pres_lat.nc' -S 'dtcon,prc:bottom_top|-1,south_north|-1:latmean:presmean:seismic,k:-5.,5.:monthly|dtcon|&|prc:pdf:flip@y:None:True' -v 'dtconmean,prcmean'
+## g.e. # drawing.py -f 'geo_em.d02.nc' -o draw_topo_geogrid -S '0.,3000.:None:FF_3dom d02:png:cyl,i'
+## g.e. # drawing.py -o draw_topo_geogrid_boxes -S '0.,3000.:None:FF domains:pdf:lcc,i:d01,d02,d03' -f geo_em.d01.nc,geo_em.d02.nc,geo_em.d03.nc
+## g.e. # drawing.py -o draw_trajectories -f 'WRF/control/trajectory.dat@-1@/home/lluis/etudes/domains/WL_HyMeX_HighRes_C/geo_em.d03.nc#XLONG_M#XLAT_M,WRF_LMDZ/wlmdza/trajectory.dat@-1@/home/lluis/etudes/domains/WL_HyMeX_C/geo_em.d01.nc#XLONG_M#XLAT_M,WRF_LMDZ/wlmdzb/trajectory.dat@-1@/home/lluis/etudes/domains/WL_HyMeX_C/geo_em.d01.nc#XLONG_M#XLAT_M,WRF_LMDZ/wlmdzb_ii/trajectory.dat@-1@/home/lluis/etudes/domains/WL_HyMeX_C/geo_em.d01.nc#XLONG_M#XLAT_M' -S '$WRF_{CRM}$,$LMDZ_{AR4.0}$,$LMDZ_{NPv3.1}$,$LMDZ_{NPv3.1b}$|None|medicane trajectories|pdf|cyl,i' -v obs/trajectory.dat,satellite,-1
+## g.e. # drawing.py -o draw_vals_trajectories -f WRF_LMDZ/wlmdza/tevolboxtraj_T2.nc,WRF_LMDZ/wlmdzb/tevolboxtraj_T2.nc,WRF/control/tevolboxtraj_T2.nc -S 'mean:-1:$WRF_{CRM}$,$LMDZ_{AR4.0}$,$LMDZ_{NPv3.1}$@4:tas:time|($[DD]^[HH]$):exct,6,h:$%d^{%H}$:trajectory|following|mean:pdf' -v T2
+## g.e. # drawing.py -o draw_2D_shad_time -f 'netcdf_concatenated.nc' -S 'dtcon:Time|-1,bottom_top|-1:presmean:time:seismic:-3.e-6,3.e-6:monthly|dtcon:pdf:transpose:time|hours!since!1949-12-01|exct,2,d|%d|date!([DD])|x:True' -v 'dtconmean'
+## g.e. # drawing.py -o variable_values -S PSFC
+## g.e. # drawing.py -o draw_timeSeries -f wrfout_d01_1979-12-01_00:00:00_bottom_top_B6-E6-I1_south_north_B3-E3-I1_west_east_B26-E26-I1.nc -S 'dt_con:time|($[DD]^{[HH]}$):exct,12,h:$%d^{%H}$:time|evolution|at|-1|6|3|26:1:pdf' -v 'LDQCON,time'
+## g.e. # drawing.py -f wrfout_d01_1979-12-01_00:00:00 -o draw_Neighbourghood_evol -S 'q:Time|-1|Times,bottom_top|6|ZNU,south_north|3|XLAT,west_east|26|XLONG:south_north,west_east:5:auto:time|($[DD]^{[HH]}$),time|($[DD]^{[HH]}$):exct,2,h|exct,1,d:$%d^{%H}$,$%d^{%H}$:5|pts|neighbourghood|temporal|evolution:0.0,0.004:BuPu:pdf:True' -v QVAPOR
+
+main = 'drawing.py'
+
+errormsg = 'ERROR -- error -- ERROR -- error'
+warnmsg = 'WARNING -- waring -- WARNING -- warning'
+fillValue=1.e20
+
+namegraphics = ['create_movie', 'draw_2D_shad', 'draw_2D_shad_time',                 \
+  'draw_2D_shad_cont', 'draw_2D_shad_cont_time', 'draw_2D_shad_line',                \
+  'draw_2D_shad_line_time', 'draw_timeSeries', 'draw_topo_geogrid',                  \
+  'draw_topo_geogrid_boxes', 'draw_trajectories', 'draw_vals_trajectories',          \
+  'draw_lines', 'draw_Neighbourghood_evol', 'list_graphics', 'variable_values']
+
+def draw_2D_shad(ncfile, values, varn):
+    """ plotting a fields with shading
+    draw_2D_shad(ncfile, values, varn)
+      ncfile= file to use
+      values=[vnamefs]:[dimvals]:[dimxvn]:[dimyvn]:[colorbar]:[sminv],[smaxv]:[figt]:
+       [kindfig]:[reverse]:[mapv]:[close]
+        [vnamefs]: Name in the figure of the variable to be shaded
+        [dimvals]: ',' list of [dimname]|[value] telling at which dimension of the 
+          variable a given value is required (-1, all the length)
+        [dimx/yvn]: name of the variables with the values of the final dimensions (x,y)
+        [colorbar]: name of the color bar
+        [smin/axv]: minimum and maximum value for the shading or:
+          'Srange': for full range
+          'Saroundmean@val': for mean-xtrm,mean+xtrm where xtrm = np.min(mean-min@val,max@val-mean)
+          'Saroundminmax@val': for min*val,max*val
+          'Saroundpercentile@val': for median-xtrm,median+xtrm where xtrm = np.min(median-percentile_(val),
+            percentile_(100-val)-median)
+          'Smean@val': for -xtrm,xtrm where xtrm = np.min(mean-min*@val,max*@val-mean)
+          'Smedian@val': for -xtrm,xtrm where xtrm = np.min(median-min@val,max@val-median)
+          'Spercentile@val': for -xtrm,xtrm where xtrm = np.min(median-percentile_(val),
+             percentile_(100-val)-median)
+        [figt]: title of the figure ('|' for spaces)
+        [kindfig]: kind of figure
+        [reverse]: Transformation of the values
+          * 'transpose': reverse the axes (x-->y, y-->x)
+          * 'flip'@[x/y]: flip the axis x or y
+        [mapv]: map characteristics: [proj],[res]
+          see full documentation: http://matplotlib.org/basemap/
+          [proj]: projection
+            * 'cyl', cilindric
+            * 'lcc', lamvbert conformal
+          [res]: resolution:
+            * 'c', crude
+            * 'l', low
+            * 'i', intermediate
+            * 'h', high
+            * 'f', full
+      valules= 'rh:z|-1,x|-1:z|-1,x|-1:lat:pressure:BuPu:0.,100.:rh:pdf:flip@y:None'
+      varn= [varsn] name of the variable to plot with shading
+    """
+
+    fname = 'draw_2D_shad'
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print draw_2D_shad.__doc__
+        quit()
+
+    expectargs = ['[vnamefs]', '[dimvals]', '[dimxvn]', '[dimyvn]', '[colorbar]',    \
+      '[sminv],[smaxv]', '[figt]', '[kindfig]', '[reverse]', '[mapv]', '[close]']
+ 
+    drw.check_arguments(fname,len(expectargs),values,':',expectargs)
+
+    vnamesfig = values.split(':')[0]
+    dimvals= values.split(':')[1].replace('|',':')
+    vdimxn = values.split(':')[2]
+    vdimyn = values.split(':')[3]
+    colbarn = values.split(':')[4]
+    shadminmax = values.split(':')[5]
+    figtitle = values.split(':')[6].replace('|',' ')
+    figkind = values.split(':')[7]
+    revals = values.split(':')[8]
+    mapvalue = values.split(':')[9]
+#    varn = values.split(':')[10]
+
+    ncfiles = ncfile
+    
+    if not os.path.isfile(ncfiles):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles + '" does not exist !!'
+        quit(-1)    
+
+    objsf = NetCDFFile(ncfiles, 'r')
+    
+    varns = varn.split(',')[0]
+
+    if  not objsf.variables.has_key(varns):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have variable "' +  varns + '" !!'
+        quit(-1)
+
+# Variables' values
+    objvars = objsf.variables[varns]
+
+    valshad, dimsshad = drw.slice_variable(objvars, dimvals.replace(',','|'))
+
+# Dimensions names
+##    print fname + ' obj dimnames: ', objvars.dimensions, dimvals, len(dimvals.split(','))
+##    dimnamesv = []
+##    for idd in range(len(objvars.dimensions)):
+##        cutdim = False
+##        for idc in range(len(dimvals.split(','))):
+##            dimcutn = dimvals.split(',')[idc].split(':')[0]
+##            print objvars.dimensions[idd], dimcutn
+##            if objvars.dimensions[idd] == dimcutn: 
+##                cutdim = True
+##                break
+##        if not cutdim: dimnamesv.append(objvars.dimensions[idd])
+    dimnamesv = [vdimyn, vdimxn]
+
+    if drw.searchInlist(objvars.ncattrs(),'units'):
+        varunits = objvars.getncattr('units')
+    else:
+        print warnmsg
+        print '  ' + fname + ": variable '" + varn + "' without units!!"
+        varunits = '-'
+
+    if  not objsf.variables.has_key(vdimxn):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have dimension variable "' +  vdimxn + '" !!'
+        quit(-1)
+    if  not objsf.variables.has_key(vdimyn):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have dimension variable "' +  vdimyn + '" !!'
+        quit(-1)
+
+    objdimx = objsf.variables[vdimxn]
+    objdimy = objsf.variables[vdimyn]
+    if drw.searchInlist(objdimx.ncattrs(),'units'):
+        odimxu = objdimx.getncattr('units')
+    else:
+        print warnmsg
+        print '  ' + fname + ": variable dimension '" + vdimxn + "' without units!!"
+        odimxu = '-'
+
+    if drw.searchInlist(objdimy.ncattrs(),'units'):
+        odimyu = objdimy.getncattr('units')
+    else:
+        print warnmsg
+        print '  ' + fname + ": variable dimension '" + vdimyn + "' without units!!"
+        odimyu = '-'
+
+    if len(objdimx.shape) <= 2:
+#        odimxv = objdimx[valshad.shape]
+#        odimyv = objdimy[valshad.shape]
+        odimxv = objdimx[:]
+        odimyv = objdimy[:]
+
+    elif len(objdimx.shape) == 3:
+#        dimcut = [0, slice(0,valshad.shape[0]), slice(0,valshad.shape[1])]
+#        odimxv = objdimx[tuple(dimcut)]
+#        odimyv = objdimy[tuple(dimcut)]
+        odimxv = objdimx[0,:]
+        odimyv = objdimy[0,:]
+    else:
+        print errormsg
+        print '  ' + fname + ': shape of dimension variable:', objdimx.shape,        \
+          ' not ready!!'
+        quit(-1)
+
+    shading_nx = []
+    if shadminmax.split(',')[0][0:1] != 'S':
+            shading_nx.append(np.float(shadminmax.split(',')[0]))
+    else:
+        shading_nx.append(shadminmax.split(',')[0])
+
+    if shadminmax.split(',')[1][0:1] != 'S':
+        shading_nx.append(np.float(shadminmax.split(',')[1]))
+    else:
+        shading_nx.append(shadminmax.split(',')[1])
+
+    if mapvalue == 'None': mapvalue = None
+
+    drw.plot_2D_shadow(valshad, vnamesfig, odimxv, odimyv, odimxu, odimyu, dimnamesv,\
+      colbarn, shading_nx, varunits, figtitle, figkind, revals, mapvalue, True)
+
+    return
+
+def draw_2D_shad_time(ncfile, values, varn):
+    """ plotting a fields with shading with time values
+    draw_2D_shad(ncfile, values, varn)
+      ncfile= file to use
+      values=[vnamefs]:[dimvals]:[dimxvn]:[dimyvn]:[colorbar]:[sminv],[smaxv]:[figt]:
+       [kindfig]:[reverse]:[timevals]:[close]
+        [vnamefs]: Name in the figure of the variable to be shaded
+        [dimvals]: ',' list of [dimname]|[value] telling at which dimension of the 
+          variable a given value is required (-1, all the length)
+        [dimx/yvn]: name of the variables with the values of the final dimensions (x,y)
+        [colorbar]: name of the color bar
+        [smin/axv]: minimum and maximum value for the shading or:
+          'Srange': for full range
+          'Saroundmean@val': for mean-xtrm,mean+xtrm where xtrm = np.min(mean-min@val,max@val-mean)
+          'Saroundminmax@val': for min*val,max*val
+          'Saroundpercentile@val': for median-xtrm,median+xtrm where xtrm = np.min(median-percentile_(val),
+            percentile_(100-val)-median)
+          'Smean@val': for -xtrm,xtrm where xtrm = np.min(mean-min*@val,max*@val-mean)
+          'Smedian@val': for -xtrm,xtrm where xtrm = np.min(median-min@val,max@val-median)
+          'Spercentile@val': for -xtrm,xtrm where xtrm = np.min(median-percentile_(val),
+             percentile_(100-val)-median)
+        [figt]: title of the figure ('|' for spaces)
+        [kindfig]: kind of figure
+        [reverse]: Transformation of the values
+          * 'transpose': reverse the axes (x-->y, y-->x)
+          * 'flip'@[x/y]: flip the axis x or y
+        [timevals]: [timen]|[units]|[kind]|[tfmt]|[label]|[timeaxis] time labels characteristics
+           [timen]; name of the time variable
+           [units]; units string according to CF conventions ([tunits] since 
+             [YYYY]-[MM]-[DD] [[HH]:[MI]:[SS]], '!' for spaces)
+           [kind]; kind of output
+             'Nval': according to a given number of values as 'Nval',[Nval]
+             'exct': according to an exact time unit as 'exct',[tunit]; 
+               tunit= [Nunits],[tu]; [tu]= 'c': centuries, 'y': year, 'm': month,
+                'w': week, 'd': day, 'h': hour, 'i': minute, 's': second, 
+                'l': milisecond
+           [tfmt]; desired format
+           [label]; label at the graph ('!' for spaces)
+        [close]: should figure be closed (finished)
+      values='dtcon:Time|-1,bottom_top|-1:presmean:time:seismic:-3.e-6,3.e-6:monthly|'
+        'dtcon:pdf:transpose:time|hours!since!1949-12-01|exct,2,d|%d|date!([DD])|x:True
+      varn= [varsn] name of the variable to plot with shading
+    """
+    fname = 'draw_2D_shad_time'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print draw_2D_shad_time.__doc__
+        quit()
+
+    farguments = ['[vnamefs]', '[dimvals]', '[dimxvn]', '[dimyvn]', '[colorbar]',     \
+      '[sminv],[smaxv]', '[figt]', '[kindfig]', '[reverse]', '[timevals]', '[close]']
+    drw.check_arguments(fname,11,values,':',farguments)
+
+    vnamesfig = values.split(':')[0]
+    dimvals= values.split(':')[1].replace('|',':')
+    vdimxn = values.split(':')[2]
+    vdimyn = values.split(':')[3]
+    colbarn = values.split(':')[4]
+    shadminmax = values.split(':')[5]
+    figtitle = values.split(':')[6].replace('|',' ')
+    figkind = values.split(':')[7]
+    revals = values.split(':')[8]
+    timevals = values.split(':')[9]
+    close = values.split(':')[10]
+
+    ncfiles = ncfile
+    
+    if not os.path.isfile(ncfiles):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles + '" does not exist !!'
+        quit(-1)    
+
+    objsf = NetCDFFile(ncfiles, 'r')
+    
+    varns = varn.split(',')[0]
+
+    if  not objsf.variables.has_key(varns):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have variable "' +  varns + '" !!'
+        quit(-1)
+
+# Variables' values
+    objvars = objsf.variables[varns]
+
+    valshad, dimsshad = drw.slice_variable(objvars, dimvals.replace(',','|'))
+
+    dimnamesv = [vdimyn, vdimxn]
+
+    varunits = objvars.getncattr('units')
+
+    if  not objsf.variables.has_key(vdimxn):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have dimension variable "' +  vdimxn + '" !!'
+        quit(-1)
+    if  not objsf.variables.has_key(vdimyn):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have dimensino variable "' +  vdimyn + '" !!'
+        quit(-1)
+
+    objdimx = objsf.variables[vdimxn]
+    objdimy = objsf.variables[vdimyn]
+    odimxu = objdimx.getncattr('units')
+    odimyu = objdimy.getncattr('units')
+
+    if len(objdimx.shape) <= 2:
+        odimxv = objdimx[:]
+        odimyv = objdimy[:]
+
+    elif len(objdimx.shape) == 3:
+        odimxv = objdimx[0,:]
+        odimyv = objdimy[0,:]
+    else:
+        print errormsg
+        print '  ' + fname + ': shape of dimension variable:', objdimx.shape,        \
+          ' not ready!!'
+        quit(-1)
+
+    timename = timevals.split('|')[0]
+    timeunit = timevals.split('|')[1].replace('!',' ')
+    timekind = timevals.split('|')[2]
+    timefmt = timevals.split('|')[3]
+    timelabel = timevals.split('|')[4].replace('!',' ')
+
+    if vdimxn == timename:
+        odimxv = objsf.variables[vdimxn][:]
+        odimxu = timelabel
+        timeaxis = 'x'
+        odimyv = objsf.variables[vdimyn]
+        odimyu = odimyv.getncattr('units')
+        timepos, timelabels = drw.CFtimes_plot(odimxv, timeunit, timekind, timefmt)
+    elif vdimyn == timename:
+        odimyv = objsf.variables[vdimyn][:]
+        odimyu = timelabel
+        timeaxis = 'y'
+        odimxv = objsf.variables[vdimxn]
+        odimxu = odimxv.getncattr('units')
+        timepos, timelabels = drw.CFtimes_plot(odimyv, timeunit, timekind, timefmt)
+    else:
+        print errormsg
+        print '  ' + fname + ": time variable '" + timename + "' not found!!"
+        quit(-1)
+
+    shading_nx = []
+    if shadminmax.split(',')[0][0:1] != 'S':
+        shading_nx.append(np.float(shadminmax.split(',')[0]))
+    else:
+        shading_nx.append(shadminmax.split(',')[0])
+
+    if shadminmax.split(',')[1][0:1] != 'S':
+        shading_nx.append(np.float(shadminmax.split(',')[1]))
+    else:
+        shading_nx.append(shadminmax.split(',')[1])
+
+    closeval = drw.Str_Bool(close)
+
+    drw.plot_2D_shadow_time(valshad, vnamesfig, odimxv, odimyv, odimxu, odimyu,      \
+      dimnamesv, colbarn, shading_nx, varunits, figtitle, figkind, revals, timeaxis, \
+      timepos, timelabels, closeval)
+
+    return
+
+def draw_2D_shad_cont(ncfile, values, varn):
+    """ plotting two fields, one with shading and the other with contour lines
+    draw_2D_shad_cont(ncfile, values, varn)
+      ncfile= [ncfilevars],[ncfilevarc] files to use (one value, same file)
+      values=[vnamefs]:[dimvals]:[dimvalc]:[dimxvn]:[dimyvn]:[colorbar]:[ckind]:[clabfmt]:[sminv],[smaxv]:[sminc],[smaxv],[Nlev]:[figt]:[kindfig]:[reverse]:[mapv]
+        [vnamefs],[vnamefc]: Name in the figure of the shaded and the contour variables
+        [dimvals/c]: list of [dimname]|[value] telling at which dimension of the 
+          variable a given value is required (no dimension name, all the length)
+        [dimx/yvn]: ',' list with the name of the variables with the values of the dimensions
+        [colorbar]: name of the color bar
+        [ckind]: kind of contours 
+          'cmap': as it gets from colorbar
+          'fixc,[colname]': fixed color [colname], all stright lines
+          'fixsigc,[colname]': fixed color [colname], >0 stright, <0 dashed  line
+        [clabfmt]: format of the labels in the contour (None, also possible)
+        [smin/axv]: minimum and maximum value for the shading
+        [sminc]:[smaxv]:[Nlev]: minimum, maximum and number of values for the contour
+        [figt]: title of the figure ('|' for spaces)
+        [kindfig]: kind of figure
+        [reverse]: does the values be transposed? 'True/False', 
+        [mapv]: map characteristics: [proj],[res]
+          see full documentation: http://matplotlib.org/basemap/
+          [proj]: projection
+            * 'cyl', cilindric
+            * 'lcc', lamvbert conformal
+          [res]: resolution:
+            * 'c', crude
+            * 'l', low
+            * 'i', intermediate
+            * 'h', high
+            * 'f', full
+      valules= 'rh,ta:z|-1,x|-1:z|-1,x|-1:lat:pressure:BuPu:fixsigc,black:%d:0.,100.:195.,305.,7:Meridonal|average|of|rh|&|ta:pdf:flip@y:None'
+      varn= [varsn],[varcn] name of the variable to plot with shading variable with contour
+    """
+
+    fname = 'draw_2D_shad_cont'
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print draw_2D_shad_cont.__doc__
+        quit()
+
+    vnamesfig = values.split(':')[0].split(',')
+    dimvals= values.split(':')[1].replace('|',':')
+    dimvalc= values.split(':')[2].replace('|',':')
+    vdimxn = values.split(':')[3]
+    vdimyn = values.split(':')[4]
+    colbarn = values.split(':')[5]
+    countkind = values.split(':')[6]
+    countlabelfmt = values.split(':')[7]
+    shadminmax = values.split(':')[8]
+    contlevels = values.split(':')[9]
+    figtitle = values.split(':')[10].replace('|',' ')
+    figkind = values.split(':')[11]
+    revals = values.split(':')[12]
+    mapvalue = values.split(':')[13]
+
+    if2filenames = ncfile.find(',')
+
+    if if2filenames != -1:
+        ncfiles = ncfile.split(',')[0]
+        ncfilec = ncfile.split(',')[1]
+    else:
+        ncfiles = ncfile
+        ncfilec = ncfile
+
+    if not os.path.isfile(ncfiles):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles + '" does not exist !!'
+        quit(-1)    
+
+    if not os.path.isfile(ncfilec):
+        print errormsg
+        print '  ' + fname + ': contour file "' + ncfilec + '" does not exist !!'
+        quit(-1)    
+
+    objsf = NetCDFFile(ncfiles, 'r')
+    objcf = NetCDFFile(ncfilec, 'r')
+    
+    varns = varn.split(',')[0]
+    varnc = varn.split(',')[1]
+
+    if  not objsf.variables.has_key(varns):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have variable "' +  varns + '" !!'
+        quit(-1)
+
+    if  not objcf.variables.has_key(varnc):
+        print errormsg
+        print '  ' + fname + ': contour file "' + ncfilec +                          \
+          '" does not have variable "' +  varnc + '" !!'
+        quit(-1)
+
+# Variables' values
+    objvars = objsf.variables[varns]
+    objvarc = objcf.variables[varnc]
+
+    if len(objvars.shape) != len(objvarc.shape):
+        print errormsg
+        print '  ' + fname + ': shading variable "' + varns + '" has a shape: ',     \
+          objvars.shape,  'different than contour variable "' +  varnc + '": ',      \
+          objvarc.shape,' !!!'
+        quit(-1)
+
+    for idim in range(len(objvars.shape)):
+        if objvars.shape[idim] != objvarc.shape[idim]:
+            print errormsg
+            print '  ' + fname + ': shading variable "' + varns + '" has a shape: ', \
+              objvars.shape,  'different than contour variable "' +  varnc + '": ',  \
+              objvarc.shape,' !!!'
+            quit(-1)
+
+    valshad, dimsshad = drw.slice_variable(objvars, dimvals.replace(',','|'))
+    valcont, dimscont = drw.slice_variable(objvarc, dimvalc.replace(',','|'))
+
+# Dimensions names
+##    print fname + ' obj dimnames: ', objvars.dimensions, dimvals, len(dimvals.split(','))
+##    dimnamesv = []
+##    for idd in range(len(objvars.dimensions)):
+##        cutdim = False
+##        for idc in range(len(dimvals.split(','))):
+##            dimcutn = dimvals.split(',')[idc].split(':')[0]
+##            print objvars.dimensions[idd], dimcutn
+##            if objvars.dimensions[idd] == dimcutn: 
+##                cutdim = True
+##                break
+##        if not cutdim: dimnamesv.append(objvars.dimensions[idd])
+    dimnamesv = [vdimyn, vdimxn]
+
+    varunits = []
+    varunits.append(objvars.getncattr('units'))
+    varunits.append(objvarc.getncattr('units'))
+
+    if  not objsf.variables.has_key(vdimxn):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have dimension variable "' +  vdimxn + '" !!'
+        quit(-1)
+    if  not objsf.variables.has_key(vdimyn):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have dimensino variable "' +  vdimyn + '" !!'
+        quit(-1)
+
+    objdimx = objsf.variables[vdimxn]
+    objdimy = objsf.variables[vdimyn]
+    odimxu = objdimx.getncattr('units')
+    odimyu = objdimy.getncattr('units')
+
+    if len(objdimx.shape) <= 2:
+#        odimxv = objdimx[valshad.shape]
+#        odimyv = objdimy[valshad.shape]
+        odimxv = objdimx[:]
+        odimyv = objdimy[:]
+
+    elif len(objdimx.shape) == 3:
+#        dimcut = [0, slice(0,valshad.shape[0]), slice(0,valshad.shape[1])]
+#        odimxv = objdimx[tuple(dimcut)]
+#        odimyv = objdimy[tuple(dimcut)]
+        odimxv = objdimx[0,:]
+        odimyv = objdimy[0,:]
+    else:
+        print errormsg
+        print '  ' + fname + ': shape of dimension variable:', objdimx.shape,        \
+          ' not ready!!'
+        quit(-1)
+
+    if countlabelfmt == 'None': 
+        countlfmt = None
+    else:
+        countlfmt = countlabelfmt
+
+    shading_nx = np.zeros((2), dtype=np.float)
+    shading_nx[0] = np.float(shadminmax.split(',')[0])
+    shading_nx[1] = np.float(shadminmax.split(',')[1])
+
+    clevmin = np.float(contlevels.split(',')[0])
+    clevmax = np.float(contlevels.split(',')[1])
+    Nclevels = int(contlevels.split(',')[2])
+
+    levels_cont = drw.pretty_int(clevmin, clevmax, Nclevels)
+
+    if len(levels_cont) <= 1: 
+        print warnmsg
+        print '  ' + fname + ': wrong contour levels:', levels_cont,' !!'
+        del(levels_cont)
+        levels_cont = np.zeros((Nclevels), dtype=np.float)
+        levels_cont = np.arange(7)*(clevmax - clevmin)/(Nclevels-1)
+        print '    generating default ones: ',levels_cont
+
+    if mapvalue == 'None': mapvalue = None
+
+    drw.plot_2D_shadow_contour(valshad, valcont, vnamesfig, odimxv, odimyv, odimxu,  \
+      odimyu, dimnamesv, colbarn, countkind, countlfmt, shading_nx, levels_cont,     \
+      varunits, figtitle, figkind, revals, mapvalue)
+
+    return
+
+def draw_2D_shad_cont_time(ncfile, values, varn):
+    """ plotting two fields, one with shading and the other with contour lines being
+    one of the dimensions of time characteristics
+    draw_2D_shad_cont(ncfile, values, varn)
+      ncfile= [ncfilevars],[ncfilevarc] files to use (one value, same file)
+      values=[vnamefs]:[dimvals]:[dimvalc]:[dimxvn]:[dimyvn]:[colorbar]:[ckind]:[clabfmt]:[sminv],[smaxv]:[sminc],[smaxv],[Nlev]:[figt]:[kindfig]:[reverse]:[timevals]:[mapv]
+        [vnamefs],[vnamefc]: Name in the figure of the shaded and the contour variables
+        [dimvals/c]: list of [dimname]|[value] telling at which dimension of the 
+          variable a given value is required (no dimension name, all the length)
+        [dimx/yvn]: ',' list with the name of the variables with the values of the dimensions
+        [colorbar]: name of the color bar
+        [ckind]: kind of contours 
+          'cmap': as it gets from colorbar
+          'fixc,[colname]': fixed color [colname], all stright lines
+          'fixsigc,[colname]': fixed color [colname], >0 stright, <0 dashed  line
+        [clabfmt]: format of the labels in the contour (None, also possible)
+        [smin/axv]: minimum and maximum value for the shading
+        [sminc]:[smaxv]:[Nlev]: minimum, maximum and number of values for the contour
+        [figt]: title of the figure ('|' for spaces)
+        [kindfig]: kind of figure
+        [reverse]: modification to the dimensions:
+          'transposed': transpose matrices
+          'flip',[x/y]: flip only the dimension [x] or [y]
+        [timevals]: [timen]|[units]|[kind]|[tfmt]|[label] time labels characteristics
+           [timen]; name of the time variable
+           [units]; units string according to CF conventions ([tunits] since 
+             [YYYY]-[MM]-[DD] [[HH]:[MI]:[SS]], '!' for spaces)
+           [kind]; kind of output
+             'Nval': according to a given number of values as 'Nval',[Nval]
+             'exct': according to an exact time unit as 'exct',[tunit]; 
+               tunit= [Nunits],[tu]; [tu]= 'c': centuries, 'y': year, 'm': month,
+                'w': week, 'd': day, 'h': hour, 'i': minute, 's': second, 
+                'l': milisecond
+           [tfmt]; desired format
+           [label]; label at the graph ('!' for spaces)
+        [mapv]: map characteristics: [proj],[res]
+          see full documentation: http://matplotlib.org/basemap/
+          [proj]: projection
+            * 'cyl', cilindric
+            * 'lcc', lamvbert conformal
+          [res]: resolution:
+            * 'c', crude
+            * 'l', low
+            * 'i', intermediate
+            * 'h', high
+            * 'f', full
+      valules= 'rh,ta:z|-1,x|-1:z|-1,x|-1:lat:pressure:BuPu:fixsigc,black:%d:0.,100.:195.,305.,7:Meridonal|average|of|rh|&|ta:pdf:flip@y:time!hours!since!1949/12/01|exct,5d|%d|date!([DD]):None'
+      varn= [varsn],[varcn] name of the variable to plot with shading variable with contour
+    """
+
+    fname = 'draw_2D_shad_cont_time'
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print draw_2D_shad_cont_time.__doc__
+        quit()
+
+    expectargs = ['[vnamefs]', '[dimvals]', '[dimvalc]', '[dimxvn]', '[dimyvn]',     \
+      '[colorbar]', '[ckind]', '[clabfmt]', '[sminv],[smaxv]',                       \
+      '[sminc],[smaxv],[Nlev]', '[figt]', '[kindfig]', '[reverse]', '[timevals]',    \
+      '[mapv]']
+ 
+    drw.check_arguments(fname,len(expectargs),values,':',expectargs)
+
+    vnamesfig = values.split(':')[0].split(',')
+    dimvals= values.split(':')[1].replace('|',':')
+    dimvalc= values.split(':')[2].replace('|',':')
+    vdimxn = values.split(':')[3]
+    vdimyn = values.split(':')[4]
+    colbarn = values.split(':')[5]
+    countkind = values.split(':')[6]
+    countlabelfmt = values.split(':')[7]
+    shadminmax = values.split(':')[8]
+    contlevels = values.split(':')[9]
+    figtitle = values.split(':')[10].replace('|',' ')
+    figkind = values.split(':')[11]
+    revals = values.split(':')[12]
+    timevals = values.split(':')[13]
+    mapvalue = values.split(':')[14]
+
+    if2filenames = ncfile.find(',')
+
+    if if2filenames != -1:
+        ncfiles = ncfile.split(',')[0]
+        ncfilec = ncfile.split(',')[1]
+    else:
+        ncfiles = ncfile
+        ncfilec = ncfile
+
+    if not os.path.isfile(ncfiles):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles + '" does not exist !!'
+        quit(-1)    
+
+    if not os.path.isfile(ncfilec):
+        print errormsg
+        print '  ' + fname + ': contour file "' + ncfilec + '" does not exist !!'
+        quit(-1)    
+
+    objsf = NetCDFFile(ncfiles, 'r')
+    objcf = NetCDFFile(ncfilec, 'r')
+    
+    varns = varn.split(',')[0]
+    varnc = varn.split(',')[1]
+
+    if  not objsf.variables.has_key(varns):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have variable "' +  varns + '" !!'
+        quit(-1)
+
+    if  not objcf.variables.has_key(varnc):
+        print errormsg
+        print '  ' + fname + ': contour file "' + ncfilec +                          \
+          '" does not have variable "' +  varnc + '" !!'
+        quit(-1)
+
+# Variables' values
+    objvars = objsf.variables[varns]
+    objvarc = objcf.variables[varnc]
+
+    if len(objvars.shape) != len(objvarc.shape):
+        print errormsg
+        print '  ' + fname + ': shading variable "' + varns + '" has a shape: ',     \
+          objvars.shape,  'different than contour variable "' +  varnc + '": ',      \
+          objvarc.shape,' !!!'
+        quit(-1)
+
+    for idim in range(len(objvars.shape)):
+        if objvars.shape[idim] != objvarc.shape[idim]:
+            print errormsg
+            print '  ' + fname + ': shading variable "' + varns + '" has a shape: ', \
+              objvars.shape,  'different than contour variable "' +  varnc + '": ',  \
+              objvarc.shape,' !!!'
+            quit(-1)
+
+    valshad, dimsshad = drw.slice_variable(objvars, dimvals.replace(',','|'))
+    valcont, dimscont = drw.slice_variable(objvarc, dimvalc.replace(',','|'))
+
+# Dimensions names
+##    print fname + ' obj dimnames: ', objvars.dimensions, dimvals, len(dimvals.split(','))
+##    dimnamesv = []
+##    for idd in range(len(objvars.dimensions)):
+##        cutdim = False
+##        for idc in range(len(dimvals.split(','))):
+##            dimcutn = dimvals.split(',')[idc].split(':')[0]
+##            print objvars.dimensions[idd], dimcutn
+##            if objvars.dimensions[idd] == dimcutn: 
+##                cutdim = True
+##                break
+##        if not cutdim: dimnamesv.append(objvars.dimensions[idd])
+    dimnamesv = [vdimyn, vdimxn]
+
+    varunits = []
+    varunits.append(objvars.getncattr('units'))
+    varunits.append(objvarc.getncattr('units'))
+
+    if  not objsf.variables.has_key(vdimxn):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have dimension variable "' +  vdimxn + '" !!'
+        quit(-1)
+    if  not objsf.variables.has_key(vdimyn):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have dimension variable "' +  vdimyn + '" !!'
+        quit(-1)
+
+    timename = timevals.split('|')[0]
+    timeunit = timevals.split('|')[1].replace('!',' ')
+    timekind = timevals.split('|')[2]
+    timefmt = timevals.split('|')[3]
+    timelabel = timevals.split('|')[4].replace('!',' ')
+
+    if vdimxn == timename:
+        timevals = objsf.variables[vdimxn][:]
+        dimt = 'x'
+        ovalaxis = objsf.variables[vdimyn]
+        ovalu = ovalaxis.getncattr('units')
+    elif vdimyn == timename:
+        timevals = objsf.variables[vdimyn][:]
+        dimt = 'y'
+        ovalaxis = objsf.variables[vdimxn]
+        ovalu = ovalaxis.getncattr('units')
+    else:
+        print errormsg
+        print '  ' + fname + ": time variable '" + timename + "' not found!!"
+        quit(-1)
+
+    timepos, timelabels = drw.CFtimes_plot(timevals, timeunit, timekind, timefmt)
+
+    if len(ovalaxis.shape) <= 2:
+        ovalaxisv = ovalaxis[:]
+
+    elif len(ovalaxis.shape) == 3:
+        ovalaxisv = ovalaxis[0,:]
+    else:
+        print errormsg
+        print '  ' + fname + ': shape of dimension variable:', ovalaxis.shape,       \
+          ' not ready!!'
+        quit(-1)
+
+    if countlabelfmt == 'None': 
+        countlfmt = None
+    else:
+        countlfmt = countlabelfmt
+
+    shading_nx = np.zeros((2), dtype=np.float)
+    shading_nx[0] = np.float(shadminmax.split(',')[0])
+    shading_nx[1] = np.float(shadminmax.split(',')[1])
+
+    clevmin = np.float(contlevels.split(',')[0])
+    clevmax = np.float(contlevels.split(',')[1])
+    Nclevels = int(contlevels.split(',')[2])
+
+    levels_cont = drw.pretty_int(clevmin, clevmax, Nclevels)
+
+    if len(levels_cont) <= 1: 
+        print warnmsg
+        print '  ' + fname + ': wrong contour levels:', levels_cont,' !!'
+        del(levels_cont)
+        levels_cont = np.zeros((Nclevels), dtype=np.float)
+        levels_cont = np.arange(7)*(clevmax - clevmin)/(Nclevels-1)
+        print '    generating default ones: ',levels_cont
+
+    if mapvalue == 'None': mapvalue = None
+
+    drw.plot_2D_shadow_contour_time(valshad, valcont, vnamesfig, ovalaxisv,         \
+      timevals, timepos, timelabels, ovalu, timelabel, dimt, dimnamesv, colbarn,    \
+      countkind, countlfmt, shading_nx, levels_cont, varunits, figtitle, figkind,   \
+      revals, mapvalue)
+
+    return
+
+def draw_2D_shad_line(ncfile, values, varn):
+    """ plotting a fields with shading and another with line
+    draw_2D_shad_line(ncfile, values, varn)
+      ncfile= [ncfiles],[ncfilel] file to use for the shading and for the line
+      values=[vnamefs],[vnamefl]:[dimvals]:[dimxvn]:[dimyvn]:[colorbar],[colline]:[sminv],[smaxv]:[figt]:
+       [kindfig]:[reverse]:[mapv]:[close]
+        [vnamefs]: Name in the figure of the variable to be shaded
+        [vnamefl]: Name in the figure of the variable to be lined
+        [dimvals]: ',' list of [dimname]|[value] telling at which dimension of the 
+          variable a given value is required (-1, all the length)
+        [dimx/yvn]: name of the variables with the values of the final dimensions (x,y)
+        [colorbar]: name of the color bar
+        [colline]: name of the color for the line
+        [smin/axv]: minimum and maximum value for the shading
+        [figt]: title of the figure ('|' for spaces)
+        [kindfig]: kind of figure
+        [reverse]: Transformation of the values
+          * 'transpose': reverse the axes (x-->y, y-->x)
+          * 'flip'@[x/y]: flip the axis x or y
+        [mapv]: map characteristics: [proj],[res]
+          see full documentation: http://matplotlib.org/basemap/
+          [proj]: projection
+            * 'cyl', cilindric
+            * 'lcc', lamvbert conformal
+          [res]: resolution:
+            * 'c', crude
+            * 'l', low
+            * 'i', intermediate
+            * 'h', high
+            * 'f', full
+      valules= 'rh:z|-1,x|-1:z|-1,x|-1:lat:pressure:BuPu:0.,100.:rh:pdf:flip@y:None'
+      varn= [varsn],[varnl] name of the variable to plot with shading and with line
+    """
+
+    fname = 'draw_2D_shad_line'
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print draw_2D_shad_line.__doc__
+        quit()
+
+    farguments = ['[vnamefs],[vnamefl]', '[dimvals]', '[dimxvn]', '[dimyvn]',        \
+      '[colorbar],[colline]', '[sminv],[smaxv]', '[figt]', '[kindfig]', '[reverse]', \
+      '[mapv]', '[close]']
+    drw.check_arguments(fname,11,values,':',farguments)
+
+    vnamesfig = values.split(':')[0].split(',')[0]
+    dimvals= values.split(':')[1].replace('|',':')
+    vdimxn = values.split(':')[2]
+    vdimyn = values.split(':')[3]
+    colbarn = values.split(':')[4].split(',')[0]
+    shadminmax = values.split(':')[5]
+    figtitle = values.split(':')[6].replace('|',' ')
+    figkind = values.split(':')[7]
+    revals = values.split(':')[8]
+    mapvalue = values.split(':')[9]
+#    varn = values.split(':')[10]
+
+    ncfiles = ncfile.split(',')[0]
+    
+    if not os.path.isfile(ncfiles):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles + '" does not exist !!'
+        quit(-1)    
+
+    objsf = NetCDFFile(ncfiles, 'r')
+    
+    varns = varn.split(',')[0]
+
+    if  not objsf.variables.has_key(varns):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have variable "' +  varns + '" !!'
+        quit(-1)
+
+# Variables' values
+    objvars = objsf.variables[varns]
+
+    valshad, dimsshad = drw.slice_variable(objvars, dimvals.replace(',','|'))
+
+# Dimensions names
+##    print fname + ' obj dimnames: ', objvars.dimensions, dimvals, len(dimvals.split(','))
+##    dimnamesv = []
+##    for idd in range(len(objvars.dimensions)):
+##        cutdim = False
+##        for idc in range(len(dimvals.split(','))):
+##            dimcutn = dimvals.split(',')[idc].split(':')[0]
+##            print objvars.dimensions[idd], dimcutn
+##            if objvars.dimensions[idd] == dimcutn: 
+##                cutdim = True
+##                break
+##        if not cutdim: dimnamesv.append(objvars.dimensions[idd])
+    dimnamesv = [vdimyn, vdimxn]
+
+    varunits = objvars.getncattr('units')
+
+    if  not objsf.variables.has_key(vdimxn):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have dimension variable "' +  vdimxn + '" !!'
+        quit(-1)
+    if  not objsf.variables.has_key(vdimyn):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have dimensino variable "' +  vdimyn + '" !!'
+        quit(-1)
+
+    objdimx = objsf.variables[vdimxn]
+    objdimy = objsf.variables[vdimyn]
+    odimxu = objdimx.getncattr('units')
+    odimyu = objdimy.getncattr('units')
+
+    if len(objdimx.shape) <= 2:
+#        odimxv = objdimx[valshad.shape]
+#        odimyv = objdimy[valshad.shape]
+        odimxv = objdimx[:]
+        odimyv = objdimy[:]
+
+    elif len(objdimx.shape) == 3:
+#        dimcut = [0, slice(0,valshad.shape[0]), slice(0,valshad.shape[1])]
+#        odimxv = objdimx[tuple(dimcut)]
+#        odimyv = objdimy[tuple(dimcut)]
+        odimxv = objdimx[0,:]
+        odimyv = objdimy[0,:]
+    else:
+        print errormsg
+        print '  ' + fname + ': shape of dimension variable:', objdimx.shape,        \
+          ' not ready!!'
+        quit(-1)
+
+    shading_nx = np.zeros((2), dtype=np.float)
+    shading_nx[0] = np.float(shadminmax.split(',')[0])
+    shading_nx[1] = np.float(shadminmax.split(',')[1])
+
+    if mapvalue == 'None': mapvalue = None
+
+# line plot
+##
+    ncfilel = ncfile.split(',')[1]
+    vnamelfig = values.split(':')[0].split(',')[1]
+    varnl = varn.split(',')[1]
+    colline = values.split(':')[4].split(',')[1]
+
+    objlf = NetCDFFile(ncfilel,'r')
+    objlvar = objlf.variables[varnl]
+
+    linevals = objlvar[:]
+    varlunits = objlvar.units
+
+    drw.plot_2D_shadow_line(valshad, linevals, vnamesfig, vnamelfig, odimxv, odimyv, \
+      odimxu, odimyu, dimnamesv, colbarn, colline, shading_nx, varunits, varlunits,  \
+      figtitle, figkind, revals, mapvalue, True)
+
+    objsf.close()
+    objlf.close()
+
+    return
+
+def draw_2D_shad_line_time(ncfile, values, varn):
+    """ plotting a fields with shading and a line with time values
+    draw_2D_shad_line(ncfile, values, varn)
+      ncfile= [ncfiles],[ncfilel] files to use to draw with shading and the line
+      values= [vnamefs],[vanemefl]:[dimvals]:[dimxvn]:[dimyvn]:[colorbar]:[sminv],[smaxv]:[figt]:
+       [kindfig]:[reverse]:[timevals]:[close]
+        [vnamefs]: Name in the figure of the variable to be shaded
+        [vnamefl]: Name in the figure of the variable to be lined
+        [dimvals]: ',' list of [dimname]|[value] telling at which dimension of the 
+          variable a given value is required (-1, all the length)
+        [dimx/yvn]: name of the variables with the values of the final dimensions (x,y)
+        [colorbar]: name of the color bar
+        [smin/axv]: minimum and maximum value for the shading
+        [figt]: title of the figure ('|' for spaces)
+        [kindfig]: kind of figure
+        [reverse]: Transformation of the values
+          * 'transpose': reverse the axes (x-->y, y-->x)
+          * 'flip'@[x/y]: flip the axis x or y
+        [timevals]: [timen]|[units]|[kind]|[tfmt]|[label]|[timeaxis] time labels characteristics
+           [timen]; name of the time variable
+           [units]; units string according to CF conventions ([tunits] since 
+             [YYYY]-[MM]-[DD] [[HH]:[MI]:[SS]], '!' for spaces)
+           [kind]; kind of output
+             'Nval': according to a given number of values as 'Nval',[Nval]
+             'exct': according to an exact time unit as 'exct',[tunit]; 
+               tunit= [Nunits],[tu]; [tu]= 'c': centuries, 'y': year, 'm': month,
+                'w': week, 'd': day, 'h': hour, 'i': minute, 's': second, 
+                'l': milisecond
+           [tfmt]; desired format
+           [label]; label at the graph ('!' for spaces)
+        [close]: should figure be closed (finished)
+      values='dtcon,prc:Time|-1,bottom_top|-1:presmean:time:seismic:-3.e-6,3.e-6:monthly|'
+        'dtcon:pdf:transpose:time|hours!since!1949-12-01|exct,2,d|%d|date!([DD])|x:True
+      varn= [varsn].[varln] name of the variable to plot with shading and to plot with line
+    """
+    fname = 'draw_2D_shad_line_time'
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print draw_2D_shad__line_time.__doc__
+        quit()
+
+    farguments = ['[vnamefs],[vanemefl]', '[dimvals]', '[dimxvn]', '[dimyvn]',       \
+      '[colorbar]', '[sminv],[smaxv]', '[figt]', '[kindfig]', '[reverse]',           \
+      '[timevals]', '[close]']
+    drw.check_arguments(fname,11,values,':',farguments)
+
+    vnamesfig = values.split(':')[0].split(',')[0]
+    dimvals= values.split(':')[1].replace('|',':')
+    vdimxn = values.split(':')[2]
+    vdimyn = values.split(':')[3]
+    colbarn = values.split(':')[4]
+    shadminmax = values.split(':')[5]
+    figtitle = values.split(':')[6].replace('|',' ')
+    figkind = values.split(':')[7]
+    revals = values.split(':')[8]
+    timevals = values.split(':')[9]
+    close = values.split(':')[10]
+
+    ncfiles = ncfile.split(',')[0]
+    
+    if not os.path.isfile(ncfiles):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles + '" does not exist !!'
+        quit(-1)    
+
+    objsf = NetCDFFile(ncfiles, 'r')
+    
+    varns = varn.split(',')[0]
+
+    if  not objsf.variables.has_key(varns):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have variable "' +  varns + '" !!'
+        quit(-1)
+
+# Variables' values
+    objvars = objsf.variables[varns]
+
+    valshad, dimsshad = drw.slice_variable(objvars, dimvals.replace(',','|'))
+
+    dimnamesv = [vdimyn, vdimxn]
+
+    varunits = objvars.getncattr('units')
+
+    if  not objsf.variables.has_key(vdimxn):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have dimension variable "' +  vdimxn + '" !!'
+        quit(-1)
+    if  not objsf.variables.has_key(vdimyn):
+        print errormsg
+        print '  ' + fname + ': shading file "' + ncfiles +                          \
+          '" does not have dimensino variable "' +  vdimyn + '" !!'
+        quit(-1)
+
+    objdimx = objsf.variables[vdimxn]
+    objdimy = objsf.variables[vdimyn]
+    odimxu = objdimx.getncattr('units')
+    odimyu = objdimy.getncattr('units')
+
+    if len(objdimx.shape) <= 2:
+        odimxv = objdimx[:]
+        odimyv = objdimy[:]
+
+    elif len(objdimx.shape) == 3:
+        odimxv = objdimx[0,:]
+        odimyv = objdimy[0,:]
+    else:
+        print errormsg
+        print '  ' + fname + ': shape of dimension variable:', objdimx.shape,        \
+          ' not ready!!'
+        quit(-1)
+
+    timename = timevals.split('|')[0]
+    timeunit = timevals.split('|')[1].replace('!',' ')
+    timekind = timevals.split('|')[2]
+    timefmt = timevals.split('|')[3]
+    timelabel = timevals.split('|')[4].replace('!',' ')
+
+    if vdimxn == timename:
+        odimxv = objsf.variables[vdimxn][:]
+        odimxu = timelabel
+        timeaxis = 'x'
+        odimyv = objsf.variables[vdimyn]
+        odimyu = odimyv.getncattr('units')
+        timepos, timelabels = drw.CFtimes_plot(odimxv, timeunit, timekind, timefmt)
+    elif vdimyn == timename:
+        odimyv = objsf.variables[vdimyn][:]
+        odimyu = timelabel
+        timeaxis = 'y'
+        odimxv = objsf.variables[vdimxn]
+        odimxu = odimxv.getncattr('units')
+        timepos, timelabels = drw.CFtimes_plot(odimyv, timeunit, timekind, timefmt)
+    else:
+        print errormsg
+        print '  ' + fname + ": time variable '" + timename + "' not found!!"
+        quit(-1)
+
+    shading_nx = np.zeros((2), dtype=np.float)
+    shading_nx[0] = np.float(shadminmax.split(',')[0])
+    shading_nx[1] = np.float(shadminmax.split(',')[1])
+
+    closeval = drw.Str_Bool(close)
+
+    drw.plot_2D_shadow_time(valshad, vnamesfig, odimxv, odimyv, odimxu, odimyu,      \
+      dimnamesv, colbarn, shading_nx, varunits, figtitle, figkind, revals, timeaxis, \
+      timepos, timelabels, False)
+
+# Line values
+## 
+    ncfilel = ncfile.split(',')[1]
+
+    vnamelfig = values.split(':')[0].split(',')[1]
+    varnl = varn.split(',')[1]
+
+    objlf = NetCDFFile(ncfilel,'r')
+    objlvar = objlf.variables[varnl]
+
+    linevals = objlvar[:]
+    if reva0 == 'tranpose':
+        plt.plot (linevals, odimxv, '-', color='k')
+    else:
+        plt.plot (odimxv, linevals, '-', color='k')
+
+    objsf.close()
+    objsl.close()
+
+    return
+
+def draw_topo_geogrid(ncfile, values):
+    """ plotting geo_em.d[nn].nc topography from WPS files
+    draw_topo_geogrid(ncfile, values)
+      ncfile= geo_em.d[nn].nc file to use
+      values= [minTopo],[maxTopo]:[lonlatL]:[title]:[graphic_kind]:[mapvalues]
+        [min/max]Topo: minimum and maximum values of topography to draw
+        lonlatL: limits of longitudes and latitudes [lonmin, latmin, lonmax, latmax] or None
+        title: title of the graph
+        graphic_kind: kind of figure (jpg, pdf, png)
+        mapvalues: map characteristics [proj],[res]
+          see full documentation: http://matplotlib.org/basemap/
+          [proj]: projection
+            * 'cyl', cilindric
+            * 'lcc', lambert conformal
+          [res]: resolution:
+            * 'c', crude
+            * 'l', low
+            * 'i', intermediate
+            * 'h', high
+            * 'f', full
+    """
+    fname = 'draw_topo_geogrid'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print draw_topo_geogrid.__doc__
+        quit()
+
+    expectargs = ['[minTopo]','[maxTopo]', '[lonlatL]', '[title]', '[graphic_kind]', \
+      '[mapvalues]']
+ 
+    drw.check_arguments(fname,5,values,':',expectargs)
+
+    mintopo = values.split(':')[0].split(',')[0]
+    maxtopo = values.split(':')[0].split(',')[1]
+
+    lonlatLS = values.split(':')[1]
+    lonlatLv = lonlatLS.split(',')[0]
+
+    if lonlatLv == 'None':
+        lonlatL = None
+    else:
+        lonlatL = np.zeros((4), dtype=np.float)
+        lonlatL[0] = np.float(lonlatLS.split(',')[0])
+        lonlatL[1] = np.float(lonlatLS.split(',')[1])
+        lonlatL[2] = np.float(lonlatLS.split(',')[2])
+        lonlatL[3] = np.float(lonlatLS.split(',')[3])
+
+    grtit = values.split(':')[2]
+    kindfig = values.split(':')[3]
+    mapvalues = values.split(':')[4]
+
+    if not os.path.isfile(ncfile):
+        print errormsg
+        print '  ' + fname + ': domain file "' + ncfile + '" does not exist !!'
+        quit(-1)    
+
+    objdomf = NetCDFFile(ncfile, 'r')
+    
+    objhgt = objdomf.variables['HGT_M']
+    objlon = objdomf.variables['XLONG_M']
+    objlat = objdomf.variables['XLAT_M']
+
+    topography = objhgt[0,:,:]
+
+    drw.plot_topo_geogrid(topography, objlon, objlat, mintopo, maxtopo, lonlatL,     \
+      grtit, kindfig, mapvalues, True)
+
+    objdomf.close()
+
+    return
+
+def draw_topo_geogrid_boxes(ncfiles, values):
+    """ plotting different geo_em.d[nn].nc topography from WPS files
+    draw_topo_geogrid_boxes(ncfile, values)
+      ncfiles= ',' list of geo_em.d[nn].nc files to use (fisrt as topographyc reference)
+      values= [minTopo],[maxTopo]:[lonlatL]:[title]:[graphic_kind]:[mapvalues]:[labels]
+        [min/max]Topo: minimum and maximum values of topography to draw
+        lonlatL: limits of longitudes and latitudes [lonmin, latmin, lonmax, latmax] or None
+        title: title of the graph
+        graphic_kind: kind of figure (jpg, pdf, png)
+        mapvalues: map characteristics [proj],[res]
+          see full documentation: http://matplotlib.org/basemap/
+          [proj]: projection
+            * 'cyl', cilindric
+            * 'lcc', lambert conformal
+          [res]: resolution:
+            * 'c', crude
+            * 'l', low
+            * 'i', intermediate
+            * 'h', high
+            * 'f', full
+        labels= labels to write in the graph
+    """
+#    import matplotlib as mpl
+#    mpl.use('Agg')
+    import matplotlib.pyplot as plt
+
+    fname = 'draw_topo_geogrid_boxes'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print draw_topo_geogrid_boxes.__doc__
+        quit()
+
+    mintopo = values.split(':')[0].split(',')[0]
+    maxtopo = values.split(':')[0].split(',')[1]
+
+    lonlatLS = values.split(':')[1]
+    lonlatLv = lonlatLS.split(',')[0]
+
+    if lonlatLv == 'None':
+        lonlatL = None
+    else:
+        lonlatL = np.zeros((4), dtype=np.float)
+        lonlatL[0] = np.float(lonlatLS.split(',')[0])
+        lonlatL[1] = np.float(lonlatLS.split(',')[1])
+        lonlatL[2] = np.float(lonlatLS.split(',')[2])
+        lonlatL[3] = np.float(lonlatLS.split(',')[3])
+
+    grtit = values.split(':')[2]
+    kindfig = values.split(':')[3]
+    mapvalues = values.split(':')[4]
+    labels = values.split(':')[5]
+
+    ncfile = ncfiles.split(',')[0]
+    if not os.path.isfile(ncfile):
+        print errormsg
+        print '  ' + fname + ': domain file "' + ncfile + '" does not exist !!'
+        quit(-1)    
+
+    objdomf = NetCDFFile(ncfile, 'r')
+    
+    objhgt = objdomf.variables['HGT_M']
+    objlon0 = objdomf.variables['XLONG_M']
+    objlat0 = objdomf.variables['XLAT_M']
+
+    topography = objhgt[0,:,:]
+
+    Nfiles = len(ncfiles.split(','))
+    boxlabels = labels.split(',')
+
+    Xboxlines = []
+    Yboxlines = []
+
+    for ifile in range(Nfiles):
+        ncfile = ncfiles.split(',')[ifile]
+#        print ifile, ncfile
+        if not os.path.isfile(ncfile):
+            print errormsg
+            print '  ' + fname + ': domain file "' + ncfile + '" does not exist !!'
+            quit(-1)    
+
+        objdomfi = NetCDFFile(ncfile, 'r')
+    
+        objlon = objdomfi.variables['XLONG_M']
+        objlat = objdomfi.variables['XLAT_M']
+
+        dx = objlon.shape[2]
+        dy = objlon.shape[1]
+
+        Xboxlines.append(objlon[0,0,:])
+        Yboxlines.append(objlat[0,0,:])
+        Xboxlines.append(objlon[0,dy-1,:])
+        Yboxlines.append(objlat[0,dy-1,:])
+        Xboxlines.append(objlon[0,:,0])
+        Yboxlines.append(objlat[0,:,0])
+        Xboxlines.append(objlon[0,:,dx-1])
+        Yboxlines.append(objlat[0,:,dx-1])
+
+        objdomfi.close()
+
+    drw.plot_topo_geogrid_boxes(topography, Xboxlines, Yboxlines, boxlabels,         \
+      objlon0, objlat0, mintopo, maxtopo, lonlatL, grtit, kindfig, mapvalues, True)
+
+    objdomf.close()
+
+    return
+
+def movievalslice(origslice, dimmovien, framenum):
+    """ Function to provide variable slice according to a geneation of a movie
+    movievals(origslice, dimmovien, framenum)
+      [origslice]= slice original as [dimname1]|[val1],[...,[dimnameN]|[valN]] 
+        ([val] = -1, full length) 
+      [dimmovien]= name of the dimension to produce the movie
+      [framenum]= value of the frame to substitue in [origslice] as 
+        [dimmovien]|[framenum]
+    >>> movievalslice('East_West|-1,North_South|-1,Time|2','Time',0)
+    East_West|-1,North_South|-1,Time|0
+    """
+
+    fname = 'movievalslice'
+
+    if origslice == 'h':
+        print fname + '_____________________________________________________________'
+        print movievalslice.__doc__
+        quit()
+    
+    dims = origslice.split(',')
+
+    movieslice = ''
+    idim = 0
+
+    for dimn in dims:
+        dn = dimn.split('|')[0]
+        if dn == dimmovien:
+            movieslice = movieslice + dn + '|' + str(framenum)
+        else:
+            movieslice = movieslice + dimn
+        if idim < len(dims)-1: movieslice = movieslice + ','
+
+        idim = idim + 1
+
+    return movieslice
+
+class Capturing(list):
+    """ Class to capture function output as a list
+    from: http://stackoverflow.com/questions/16571150/how-to-capture-stdout-output-from-a-python-function-call
+    """
+#    from cStringIO import StringIO
+
+    def __enter__(self):
+        self._stdout = sys.stdout
+        sys.stdout = self._stringio = StringIO()
+        return self
+    def __exit__(self, *args):
+        self.extend(self._stringio.getvalue().splitlines())
+        sys.stdout = self._stdout
+
+def create_movie(netcdfile, values, variable):
+    """ Function to create a movie assuming ImageMagick installed!
+      values= [graph]#[movie_dimension]#[graph_values]
+        [graph]: which graphic
+        [movie_dimension]: [dimnmovie]@[dimvmovie]@[moviedelay]@[interval]
+          [dimnmovie]; name of the dimension from which make the movie
+          [dimvmovie]; name of the variable with the values of the dimension
+          [moviedelay]; delay between frames
+          [interval]; [beg]@[end]@[freq] or -1 (all)
+        [graph_values]: values to generate the graphic
+      netcdfile= netCDF file
+      variable= variable to use (when applicable)
+    """ 
+    fname = 'create_movie'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print create_movie.__doc__
+        quit()
+
+    graph = values.split('#')[0]
+    movie_dim = values.split('#')[1]
+    graph_vals = values.split('#')[2]
+
+    ncobj = NetCDFFile(netcdfile, 'r')
+
+# Movie dimension
+##
+    dimnmovie = movie_dim.split('@')[0]
+    dimvmovie = movie_dim.split('@')[1]
+    moviedelay = movie_dim.split('@')[2]
+    moviebeg = int(movie_dim.split('@')[3])
+
+    if not drw.searchInlist(ncobj.dimensions.keys(),dimnmovie):
+        print errormsg
+        print '  ' + fname + ": file '" + netcdfile + "' has not dimension '" +      \
+          dimnmovie + "' !!!"
+        quit(-1)
+
+    objdmovie = ncobj.dimensions[dimnmovie]
+    dmovie = len(objdmovie)
+    if moviebeg != -1:
+        moviend = int(movie_dim.split('@')[4])
+        moviefreq = int(movie_dim.split('@')[5])
+    else:
+        moviebeg = 0
+        moviend = dmovie
+        moviefreq = 1
+
+    if dimvmovie == 'WRFTimes':
+        objvdmovie = ncobj.variables['Times']
+        vdmovieunits = ''
+        valsdmovie = []
+        for it in range(objvdmovie.shape[0]):
+            valsdmovie.append(drw.datetimeStr_conversion(objvdmovie[it,:],           \
+              'WRFdatetime', 'Y/m/d H-M-S'))
+    elif dimvmovie == 'CFtime':
+        objvdmovie = ncobj.variables['time']
+        vdmovieunits = ''
+        print objvdmovie.units
+        valsdmovie0 = drw.netCDFdatetime_realdatetime(objvdmovie.units, 'standard',  \
+          objvdmovie[:])
+        valsdmovie = []
+        for it in range(objvdmovie.shape[0]):
+            valsdmovie.append(drw.datetimeStr_conversion(valsdmovie0[it,:],          \
+              'matYmdHMS', 'Y/m/d H-M-S'))
+    else:
+        if  not drw.searchInlist(ncobj.variables.keys(),dimvmovie):
+            print errormsg
+            print '  ' + fname + ": file '" + netcdfile + "' has not variable '" +   \
+              dimvmovie + "' !!!"
+            quit(-1)
+        vdmovieunits = objvdmovie.getncattr('units')
+        objvdmovie = ncobj.variables[dimvmovie]
+        if len(objvdmovie.shape) == 1:
+            vasldmovie = objvdmovie[:]
+        else:
+            print errormsg
+            print '  ' + fname + ': shape', objvdmovie.shape, 'of variable with ' +  \
+              'dimension movie values not ready!!!'
+            quit(-1)
+
+    ncobj.close()
+    os.system('rm frame_*.png > /dev/null')
+
+# graphic
+##
+    if graph == 'draw_2D_shad':
+        graphvals = graph_vals.split(':')
+
+        for iframe in range(moviebeg,moviend,moviefreq):
+            iframeS = str(iframe).zfill(4)
+
+            drw.percendone((iframe-moviebeg)/moviefreq,(moviend-moviebeg)/moviefreq, \
+              5, 'frames')
+            titgraph = dimnmovie + '|=|' + str(valsdmovie[iframe]) + '|' +           \
+              vdmovieunits
+
+            graphvals[1] = movievalslice(graphvals[1],dimnmovie,iframe)
+            graphvals[6] = titgraph
+            graphvals[7] = 'png'
+
+            graphv = drw.numVector_String(graphvals, ":")
+
+            with Capturing() as output:
+                draw_2D_shad(netcdfile, graphv, variable)
+
+            os.system('mv 2Dfields_shadow.png frame_' + iframeS + '.png')
+    else:
+        print errormsg
+        print '  ' + fname + ": graphic '" +  graph + "' not defined !!!"
+        quit(-1)
+
+    os.system('convert -delay ' + moviedelay + ' -loop 0 frame_*.png create_movie.gif')
+
+    print "Succesfuly creation of movie file 'create_movie.gif' !!!"
+
+    return
+
+def draw_lines(ncfilens, values, varname):
+    """ Function to draw different lines at the same time from different files
+    draw_trajectories(ncfilens, values, varname):
+      ncfilens= [filen] ',' separated list of netCDF files
+      values= [dimvname]:[valuesaxis]:[dimtit]:[leglabels]:[vtit]:[title]:[graphk]
+        [dimvname]: name of the variable with he values of the common dimension
+        [valuesaxis]: which axis will be used for the values ('x', or 'y')
+        [dimtit]: title for the common dimension
+        [leglabels]: ',' separated list of names for the legend
+        [vartit]: name of the variable in the graph
+        [title]: title of the plot
+        [graphk]: kind of the graphic
+      varname= variable to plot
+      values= 'XLAT:x:latitude:32x32:$wss^{*}$:wss Taylor's turbulence term:pdf'
+    """
+
+    fname = 'draw_lines'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print draw_lines.__doc__
+        quit()
+
+    expectargs = '[dimvname]:[valuesaxis]:[dimtit]:[leglabels]:[vtit]:[title]:[graphk]'
+    drw.check_arguments(fname,len(expectargs.split(':')),values,':',expectargs)
+
+    ncfiles = ncfilens.split(',')
+    dimvname = values.split(':')[0]
+    valuesaxis = values.split(':')[1]
+    dimtit = values.split(':')[2]
+    leglabels = values.split(':')[3]
+    vartit = values.split(':')[4]
+    title = values.split(':')[5]
+    graphk = values.split(':')[6]
+
+    Nfiles = len(ncfiles)
+
+# Getting trajectotries 
+##
+
+    varvalues = []
+    dimvalues = []
+
+    print '  ' + fname
+    ifn = 0
+    for ifile in ncfiles:
+        filen = ifile.split('@')[0]
+
+        print '    filen:',filen
+
+        if not os.path.isfile(filen):
+            print errormsg
+            print '  ' + fname + ": netCDF file '" + filen + "' does not exist !!"
+            quit(-1)
+
+        objfile = NetCDFFile(filen, 'r')
+
+        if not objfile.variables.has_key(dimvname):
+            print errormsg
+            print '  ' + fname + ": netCDF file '" + filen +                         \
+              "' does not have variable '" + dimvname + "' !!"
+            quit(-1)
+
+        if not objfile.variables.has_key(varname):
+            print errormsg
+            print '  ' + fname + ": netCDF file '" + filen +                         \
+              "' does not have variable '" + varname + "' !!"
+            quit(-1)
+
+        vvobj = objfile.variables[varname]
+        if len(vvobj.shape) != 1:
+            print errormsg
+            print '  ' + fname + ': wrong shape:',vvobj.shape," of variable '" +     \
+              varname +  "' !!"
+            quit(-1)
+
+        vdobj = objfile.variables[dimvname]
+        if len(vdobj.shape) != 1:
+            print errormsg
+            print '  ' + fname + ': wrong shape:',vdobj.shape," of variable '" +     \
+              dimvname +  "' !!"
+            quit(-1)
+
+        varvalues.append(vvobj[:])
+        dimvalues.append(vdobj[:])
+
+        if ifn == 0:
+            varunits = vvobj.units
+
+        objfile.close()
+
+        ifn = ifn + 1
+
+
+    drw.plot_lines(dimvalues, varvalues, valuesaxis, dimtit, leglabels.split(','),   \
+      vartit, varunits, title, graphk)
+
+    return
+
+def draw_Neighbourghood_evol(filen, values, variable):
+    """ Function to draw the temporal evolution of a neighbourghood around a point
+    draw_Neighbourghood_evol(filen, values, variable)
+      filen= netCDF file name
+      values= [gvarname]:[dimsval]:[neigdims]:[Nneig]:[Ncol]:[timetits]:[tkinds]:
+       [timefmts]:[gtitle]:[shadxtrms]:[cbar]:[gkind]:[ofile]
+        [dimsval]: [dimn1]|[val1]|[dimv1],...,[dimnN]|[valN]|[dimvN] dimension names, values to get 
+          (-1, for all; no name/value pair given full length) and variable with values of the dimension
+          NOTE: when dimsval[X,Y] == neigdims[X,Y], valX,valY --> valX,valY-Nneig/2, valX,valY+Nneig/2
+        [neigdims]: [dimnX],[dimnY] dimensions mnames along which the neigbourghood should be defined
+        [Nneig]: Number of grid points of the full side of the box (odd value)
+        [Ncol]: Number of columns ('auto': square final plot)
+        [gvarname]: name of the variable to appear in the graph
+        [timetits]: [titX],[titY] titles of the axes ('|' for spaces)
+        [tkinds]: [tkindX]|[tkindY] kinds of time to appear in the graph
+          'Nval': according to a given number of values as 'Nval',[Nval]
+          'exct': according to an exact time unit as 'exct',[tunit]; 
+            tunit= [Nunits],[tu]; [tu]= 'c': centuries, 'y': year, 'm': month,
+              'w': week, 'd': day, 'h': hour, 'i': minute, 's': second, 
+              'l': milisecond
+        [timefmts]: [tfmtX],[tfmtY] format of the time labels
+        [gtitle]: title of the graphic ('|' for spaces)
+        [shadxtrms]: Extremes for the shading
+        [cbar]: colorbar to use
+        [gkind]: kind of graphical output
+        [ofile]: True/False whether the netcdf with data should be created or not
+      variable= name of the variable
+      values = 'q:Time|-1|Times,bottom_top|6|ZNU,south_north|3|XLAT,west_east|26|XLONG:south_north,west_east:5:auto:time|($[DD]^{[HH]}$),time|($[DD]^{[HH]}$):exct,2,h|exct,1,d:$%d^{%H}$,$%d^{%H}$:5|pts|neighbourghood|temporal|evolution:0.0,0.004:BuPu:pdf:True'
+    """ 
+
+    fname = 'draw_Neighbourghood_evol'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print draw_Neighbourghood_evol.__doc__
+        quit()
+
+    expectargs = ['[gvarname]', '[dimsval]', '[neigdims]', '[Nneig]', '[Ncol]',      \
+      '[timetits]', '[tkinds]', '[timefmts]', '[gtitle]', '[shadxtrms]', '[cbar]',   \
+      '[gkind]', '[ofile]']
+ 
+    drw.check_arguments(fname,len(expectargs),values,':',expectargs)
+
+    gvarname = values.split(':')[0]
+    dimsval = values.split(':')[1].split(',')
+    neigdims = values.split(':')[2].split(',')
+    Nneig = int(values.split(':')[3])
+    Ncol0 = values.split(':')[4]
+    timetits = values.split(':')[5].split(',')
+    timekinds = values.split(':')[6].split('|')
+    timefmts = values.split(':')[7].split(',')
+    gtitle = values.split(':')[8].replace('|',' ')
+    shadxtrms = values.split(':')[9].split(',')
+    cbar = values.split(':')[10]
+    gkind = values.split(':')[11]
+    ofile = values.split(':')[12]
+
+    if Ncol0 != 'auto': 
+        Ncol = int(Ncol0)
+    else:
+        Ncol = Ncol0
+
+    timetits[0] = timetits[0].replace('|',' ')
+    timetits[1] = timetits[1].replace('|',' ')
+
+    if np.mod(Nneig,2) == 0:
+        print errormsg
+        print '  ' + fname + ": an odd value for 'Nneig':",Nneig,'is required !!!'
+        quit(-1)
+
+    Nneig2 = int(Nneig/2)
+
+# Values to slice the variable
+    dimvslice = {}
+    dimvvalues = {}
+    for dimvs in dimsval:
+        dimn = dimvs.split('|')[0]
+        dimv = int(dimvs.split('|')[1])
+        dimnv = dimvs.split('|')[2]
+
+        dimvvalues[dimn] = dimnv
+        dimvslice[dimn] = dimv
+
+    ncobj = NetCDFFile(filen, 'r')
+
+    varobj = ncobj.variables[variable]
+
+    slicevar = []
+    newdimn = []
+    newdimsvar = {}
+
+    for dimn in varobj.dimensions:
+        if not drw.searchInlist(dimvslice.keys(), dimn):
+            dimsize = len(ncobj.dimensions[dimn])
+            slicevar.append(slice(0, dimsize+1))
+            newdimn.append(dimn)
+            newdimsvar[dimn] = dimseize
+
+        for dimslicen in dimvslice.keys():
+            if dimn == dimslicen:
+                if dimvslice[dimn] != -1:
+                    if drw.searchInlist(neigdims, dimn):
+                        slicevar.append(slice(dimvslice[dimn]-Nneig2,                \
+                          dimvslice[dimn]+Nneig2+1))
+                        newdimn.append(dimn)
+                        newdimsvar[dimn] = Nneig
+                        break
+                    else:
+                        slicevar.append(slice(dimvslice[dimn], dimvslice[dimn]+1))
+                        break
+                else:
+                    dimsize = len(ncobj.dimensions[dimn])
+                    slicevar.append(slice(0, dimsize+1))
+                    newdimn.append(dimn)
+                    newdimsvar[dimn] = dimsize
+                    break
+ 
+    varv = varobj[tuple(slicevar)]
+
+    if len(newdimn) != 3:
+        print errormsg
+        print '  ' + fname + ': sliced variable with shape=', varv.shape,            \
+          ' must have three dimensions',len(varv.shape),'given !!'
+        quit(-1)
+
+    newdims = []
+    for nwdims in newdimn:
+        newdims.append(newdimsvar[nwdims])
+
+# The dimension which is not in the neighbourhood dimensions must be time!
+    for dim1 in newdimn:
+        if not drw.searchInlist(neigdims, dim1):
+            dimt = newdimsvar[dim1]
+            dimtime = dim1
+
+    if Ncol == 'auto':
+        dimtsqx = int(np.sqrt(dimt)) + 1
+        dimtsqy = int(np.sqrt(dimt)) + 1
+    else:
+        dimtsqx = int(Ncol)
+        dimtsqy = dimt/dimtsqx + 1
+
+    neighbourghood = np.ones((dimtsqy*Nneig,dimtsqx*Nneig), dtype=np.float)*fillValue
+
+    for it in range(dimt):
+        ity = int(it/dimtsqx)
+        itx = it-ity*dimtsqx
+
+        itty = (dimtsqy - ity - 1)*Nneig + Nneig2
+        ittx = itx*Nneig + Nneig2
+
+        neighbourghood[itty-Nneig2:itty+Nneig2+1,ittx-Nneig2:ittx+Nneig2+1]=         \
+          varv[it,::-1,:]
+
+    variablevals = drw.variables_values(variable)
+    if drw.searchInlist(varobj.ncattrs(), 'units'):
+        vunits = varobj.units
+    else:
+        vunits = variablevals[5]
+
+# Time values at the X/Y axes
+    if ncobj.variables[dimvvalues[dimtime]].dtype == '|S1':
+        print '    ' + fname + ': WRF time variable!'
+        refdate = '19491201000000'
+        tunitsval = 'hours'
+        dimtvalues = np.zeros((dimt), dtype=np.float)
+        tvals = ncobj.variables[dimvvalues[dimtime]]
+        yrref=refdate[0:4]
+        monref=refdate[4:6]
+        dayref=refdate[6:8]
+        horref=refdate[8:10]
+        minref=refdate[10:12]
+        secref=refdate[12:14]
+
+        refdateS = yrref + '/' + monref + '/' + dayref + '_' + horref + ':' +        \
+          minref + ':' + secref
+        tunits = tunitsval + ' since ' + refdateS
+        for it in range(dimt):
+            wrfdates = drw.datetimeStr_conversion(tvals[it,:],'WRFdatetime', 'matYmdHMS')
+            dimtvalues[it] = drw.realdatetime1_CFcompilant(wrfdates, refdate, tunitsval)
+    else:
+        dimtvalues = ncobj.variables[dimvvalues[dimtime]][:]
+        tunits = ncobj.variables[newdimsvar[dimtime]].units
+
+    dimxv = dimtvalues[0:dimtsqx]
+    dimyv = dimtvalues[0:dimt:dimtsqx]
+
+    print 'Lluis lens: dimxv, dimyv:',len(dimxv), len(dimyv)
+
+    dimn = ['time','time']
+
+    if ofile == 'True':
+        ofilen = 'Neighbourghood_evol.nc'
+        newnc = NetCDFFile(ofilen, 'w')
+# Dimensions
+        newdim = newnc.createDimension('time',None)
+        newdim = newnc.createDimension('y',dimtsqy*Nneig)
+        newdim = newnc.createDimension('x',dimtsqx*Nneig)
+# Dimension values
+        newvar = newnc.createVariable('time','f8',('time'))
+        newvar[:] = np.arange(dimt)
+        newattr = drw.basicvardef(newvar, 'time','time',tunits)
+# Neighbourhghood variable
+        newvar = newnc.createVariable(variable + 'neigevol', 'f4', ('y','x'),        \
+          fill_value=fillValue)
+        newvar[:] = neighbourghood
+
+        newnc.sync()
+        newnc.close()
+        print fname + ": Successfull generation of file '" + ofilen + "' !!"
+
+# Time ticks
+    timeposX, timelabelsX = drw.CFtimes_plot(dimxv, tunits, timekinds[0], timefmts[0])
+    timeposY, timelabelsY = drw.CFtimes_plot(dimyv, tunits, timekinds[1], timefmts[1])
+
+    timepos = [timeposX, timeposY[::-1]]
+    timelabels = [timelabelsX, timelabelsY[::-1]]
+
+    for i in range(2):
+        if shadxtrms[i][0:1] != 'S':
+            shadxtrms[i] = np.float(shadxtrms[i])
+
+    drw.plot_Neighbourghood_evol(neighbourghood, dimxv, dimyv, gvarname, timetits,   \
+      timepos, timelabels, cbar, Nneig, shadxtrms, vunits, gtitle, gkind, True)
+
+def draw_timeSeries(filen, values, variables):
+    """ Function to draw a time-series
+    draw_timeSeries(filen, values, variable):
+      filen= name of the file
+      values= [gvarname]:[timetit]:[tkind]:[timefmt]:[title]:[locleg]:[gkind]
+      [gvarname]: name of the variable to appear in the graph
+      [timetit]: title of the time axis (assumed x-axis, '|' for spaces)
+      [tkind]: kind of time to appear in the graph (assumed x-axis)
+        'Nval': according to a given number of values as 'Nval',[Nval]
+        'exct': according to an exact time unit as 'exct',[tunit]; 
+          tunit= [Nunits],[tu]; [tu]= 'c': centuries, 'y': year, 'm': month,
+            'w': week, 'd': day, 'h': hour, 'i': minute, 's': second, 
+            'l': milisecond
+      [timefmt]: format of the time labels
+      [title]: title of the graphic ('|' for spaces)
+      [locleg]: location of the legend (-1, autmoatic)
+        1: 'upper right', 2: 'upper left', 3: 'lower left', 4: 'lower right',
+        5: 'right', 6: 'center left', 7: 'center right', 8: 'lower center',
+        9: 'upper center', 10: 'center'
+      [gkind]: kind of graphical output
+      variables= [varname],[timename] names of variable and variable with times
+      draw_timeSeries('wrfout_d01_1979-12-01_00:00:00_bottom_top_B6-E6-I1_south_north_B3-E3-I1_west_east_B26-E26-I1.nc', 'dt_con:time|($[DD]^{[HH]}$):exct,12,h:$%d^{%H}$:time|evolution|at|-1|6|3|26:1:pdf', 'LDQCON,time')
+    """
+
+    fname = 'draw_timeSeries'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print draw_timeSeries.__doc__
+        quit()
+
+    expectargs = ['[gvarname]', '[timetit]', '[tkind]', '[timefmt]', '[title]',      \
+      '[locleg]', '[gkind]']
+ 
+    drw.check_arguments(fname,len(expectargs),values,':',expectargs)
+
+    gvarname = values.split(':')[0]
+    timetit = values.split(':')[1].replace('|',' ')
+    tkind = values.split(':')[2]
+    timefmt = values.split(':')[3]
+    title = values.split(':')[4].replace('|',' ')
+    locleg = int(values.split(':')[5])
+    gkind = values.split(':')[6]
+    
+    ncobj = NetCDFFile(filen, 'r')
+
+    variable = variables.split(',')[0]
+    timevar = variables.split(',')[1]
+
+    if not ncobj.variables.has_key(variable):
+        print errormsg
+        print '  ' + fname + ": file '" +  filen + "' does not have variable '" +    \
+          variable + "' !!"
+        quit(-1)
+
+    if not ncobj.variables.has_key(timevar):
+        print errormsg
+        print '  ' + fname + ": file '" +  filen + "' does not have variable time '" \
+          + timevar + "' !!"
+        quit(-1)
+
+    varobj = ncobj.variables[variable]
+    timeobj = ncobj.variables[timevar]
+
+    dimt = len(timeobj[:])
+    varvals = np.zeros((2,dimt), dtype=np.float)
+
+    gunits = varobj.getncattr('units')
+    tunits = timeobj.getncattr('units')
+
+    varvals[0,:], valpot, newgunits, Spot = drw.pot_values(varobj[:].flatten(), gunits)
+    varvals[1,:] = timeobj[:]
+
+    tseriesvals = []
+    tseriesvals.append(varvals)
+
+    drw.plot_TimeSeries(tseriesvals, Spot + drw.units_lunits(gunits), tunits,        \
+      'TimeSeries', gvarname, timetit, tkind, timefmt, title,                        \
+      [gvarname.replace('_','\_')], locleg, gkind)
+
+    return
+
+#draw_timeSeries('wrfout_d01_1979-12-01_00:00:00_bottom_top_B6-E6-I1_south_north_B3-E3-I1_west_east_B26-E26-I1.nc', 'dt_con:time|($[DD]^{[HH]}$):exct,12,h:$%d^{%H}$:time|evolution|at|-1|6|3|26:1:pdf', 'LDQCON,time')
+
+def draw_trajectories(trjfilens, values, observations):
+    """ Function to draw different trajectories at the same time
+    draw_trajectories(trjfilens, values, observations):
+      trjfilens= [filen]@[Tint]@[map] ',' separated list of files with trajectories,
+         time intervals and reference maps (first one will be used to plot)
+        [filen]: name of the file to use (lines with '#', not readed) as:
+          [t-step] [x] [y]
+        [Tint]: interval of time as [Tbeg]@[Tend] or -1 for all the interval
+        [map]: [file]#[lonname]#[latname] 
+          [file]; with the [lon],[lat] matrices
+          [lonname],[latname]; names of the longitudes and latitudes variables
+      values=[leglabels]|[lonlatlims]|[title]|[graphk]|[mapkind]
+        [leglabels]: ',' separated list of names for the legend
+        [lonlatlims]: limits of the map [lonmin, latmin, lonmax, latmax] or None
+        [title]: title of the plot
+        [graphk]: kind of the graphic
+        [mapkind]: drawing coastaline ([proj],[res]) or None
+          [proj]: projection
+             * 'cyl', cilindric
+             * 'lcc', lambert conformal
+          [res]: resolution:
+             * 'c', crude
+             * 'l', low
+             * 'i', intermediate
+             * 'h', high
+             * 'f', full
+      obsevations= [obsfile],[obsname],[Tint],[null]
+        [obsfile]: name fo the File with the observations as [t-step] [lat] [lon]
+        [obsname]: name of the observations in the graph
+        [Tint]: interval of time as [Tbeg]@[Tend] or -1 for all the interval
+        [null]: null value for the observed trajectory
+    """
+
+    fname = 'draw_trajectories'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print draw_trajectories.__doc__
+        quit()
+
+    trjfiles = trjfilens.split(',')
+    leglabels = values.split('|')[0]
+    lonlatlims = values.split('|')[1]
+    title = values.split('|')[2]
+    graphk = values.split('|')[3]
+    mapkind = values.split('|')[4]
+
+    Nfiles = len(trjfiles)
+
+# Getting trajectotries 
+##
+
+    lontrjvalues = []
+    lattrjvalues = []
+
+    print '  ' + fname
+    ifn = 0
+    for ifile in trjfiles:
+        filen = ifile.split('@')[0]
+        Tint = ifile.split('@')[1]
+
+        print '    trajectory:',filen
+
+        if Tint != '-1':
+            Tbeg = Tint
+            Tend = ifile.split('@')[2]
+            mapv = ifile.split('@')[3]
+        else:
+            mapv = ifile.split('@')[2]
+
+        if not os.path.isfile(filen):
+            print errormsg
+            print '  ' + fname + ": trajectory file '" + filen + "' does not exist !!"
+            quit(-1)
+
+# Charging longitude and latitude values
+## 
+        lonvals, latvals = drw.lonlat_values(mapv.split('#')[0], mapv.split('#')[1], \
+          mapv.split('#')[2])
+
+        if ifn == 0: mapref = mapv
+        ifn = ifn + 1
+
+        objfile = open(filen, 'r')
+        trjtimev = []
+        trjxv = []
+        trjyv = []
+
+        for line in objfile:
+            if line[0:1] != '#':
+                trjtimev.append(int(line.split(' ')[0]))
+                trjxv.append(int(line.split(' ')[1]))
+                trjyv.append(int(line.split(' ')[2]))
+
+        objfile.close()
+
+        if Tint != '-1':
+            lontrjvalues.append(lonvals[trjyv[Tint:Tend+1], trjxv[Tint:Tend+1]])
+            lattrjvalues.append(latvals[trjyv[Tint:Tend+1], trjxv[Tint:Tend+1]])
+        else:
+            lontrjvalues.append(lonvals[trjyv[:], trjxv[:]])
+            lattrjvalues.append(latvals[trjyv[:], trjxv[:]])
+
+# lonlatlimits
+##
+
+    if lonlatlims == 'None':
+        lonlatlimsv = None
+    else:
+        lonlatlimsv = np.zeros((4), dtype=np.float)
+        lonlatlimsv[0] = np.float(lonlatlims.split(',')[0])
+        lonlatlimsv[1] = np.float(lonlatlims.split(',')[1])
+        lonlatlimsv[2] = np.float(lonlatlims.split(',')[2])
+        lonlatlimsv[3] = np.float(lonlatlims.split(',')[3])
+
+# lon/lat objects
+##
+    objnc = NetCDFFile(mapref.split('#')[0])
+    lonobj = objnc.variables[mapref.split('#')[1]]
+    latobj = objnc.variables[mapref.split('#')[2]]
+
+# map
+##
+    if mapkind == 'None':
+        mapkindv = None
+    else:
+        mapkindv = mapkind
+
+    if observations is None:
+        obsname = None
+    else:
+        obsfile = observations.split(',')[0]
+        obsname = observations.split(',')[1]
+        Tint = observations.split(',')[2]
+        null = np.float(observations.split(',')[3])
+        print '    observational trajectory:',obsfile
+
+        if not os.path.isfile(obsfile):
+            print errormsg
+            print '  ' + fname + ": observations trajectory file '" + obsfile +      \
+              "' does not exist !!"
+            quit(-1)
+
+        objfile = open(obsfile, 'r')
+        obstrjtimev = []
+        obstrjxv = []
+        obstrjyv = []
+
+        for line in objfile:
+            if line[0:1] != '#':
+                lon = np.float(line.split(' ')[2])
+                lat = np.float(line.split(' ')[1])
+                if not lon == null and not lat == null:
+                    obstrjtimev.append(int(line.split(' ')[0]))
+                    obstrjxv.append(lon)
+                    obstrjyv.append(lat)
+                else:
+                    obstrjtimev.append(int(line.split(' ')[0]))
+                    obstrjxv.append(None)
+                    obstrjyv.append(None)
+
+        objfile.close()
+
+        if Tint != '-1':
+            Tint = int(observations.split(',')[2].split('@')[0])
+            Tend = int(observations.split(',')[2].split('@')[1])
+            lontrjvalues.append(obstrjxv[Tint:Tend+1])
+            lattrjvalues.append(obstrjyv[Tint:Tend+1])
+        else:
+            lontrjvalues.append(obstrjxv[:])
+            lattrjvalues.append(obstrjyv[:])
+
+    drw.plot_Trajectories(lontrjvalues, lattrjvalues, leglabels.split(','),          \
+      lonobj, latobj, lonlatlimsv, title, graphk, mapkindv, obsname)
+
+    objnc.close()
+
+    return
+
+def draw_vals_trajectories(ncfile, values, variable):
+    """ Function to draw values from the outputs from 'compute_tevolboxtraj'
+    draw_vals_trajectories(ncfile, values, variable)
+    ncfile= [ncfile] ',' list of files to use
+    values= [statistics]:[Tint]:[labels]@[locleg]:[gvarname]:[timetit]:[tkind]:[timefmt]:[title]:[gkind]
+      [statistics]: which statistics to use, from: 'center', 'min', 'max', 'mean', 
+        'mean2', 'stdev'
+      [Tint]: [Tbeg]@[Tend] or None, interval of time to plot or -1 for all the times
+      [labels]: ',' separated list of labels for the legend
+      [locleg]: location of the legend (-1, autmoatic)
+        1: 'upper right', 2: 'upper left', 3: 'lower left', 4: 'lower right',
+        5: 'right', 6: 'center left', 7: 'center right', 8: 'lower center',
+        9: 'upper center', 10: 'center'
+      [gvarname]: name of the variable to appear in the graph
+      [timetit]: title of the time axis (assumed x-axis, '|' for spaces)
+      [tkind]: kind of time to appear in the graph (assumed x-axis)
+        'Nval': according to a given number of values as 'Nval',[Nval]
+        'exct': according to an exact time unit as 'exct',[tunit]; 
+          tunit= [Nunits],[tu]; [tu]= 'c': centuries, 'y': year, 'm': month,
+            'w': week, 'd': day, 'h': hour, 'i': minute, 's': second, 
+            'l': milisecond
+      [timefmt]: format of the time labels
+      [title]: title of the graphic ('|' for spaces)
+      [gkind]: kind of graphical output
+    variable= variable to use
+    """
+
+    fname = 'draw_vals_trajectories'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print draw_vals_trajectories.__doc__
+        quit()
+
+    sims = ncfile.split(',')
+
+    if len(values.split(':')) != 9:
+        print errormsg
+        print '  ' + fname  + ': wrong number of values!', len(values.split(':')),   \
+          'given 9 needed!!'
+        print '    ',values.split(':')
+        quit(-1)
+
+    statistics = values.split(':')[0]
+    Tint = values.split(':')[1]
+    labels = values.split(':')[2]
+    gvarname = values.split(':')[3]
+    timetit = values.split(':')[4].replace('|',' ')
+    tkind = values.split(':')[5]
+    timefmt = values.split(':')[6]
+    title = values.split(':')[7].replace('|',' ')
+    gkind = values.split(':')[8]
+
+    leglabels = labels.split('@')[0].split(',')
+    locleg = int(labels.split('@')[1])
+
+    Nsims = len(sims)
+
+    if Tint != '-1':
+        tini = np.float(Tint.split('@')[0])
+        tend = np.float(Tint.split('@')[1])
+    else:
+        tini = -1.
+        tend = -1.
+
+    vartimetrjv = []
+
+    print '  ' + fname
+    for trjfile in sims:
+        print '    ' + trjfile + ' ...'
+        if not os.path.isfile(trjfile):
+            print errormsg
+            print '  ' + fname + ": trajectory file: '" + trjfile +                  \
+              "' does not exist !!"
+            quit(-1)
+
+        trjobj = NetCDFFile(trjfile, 'r')
+        otim = trjobj.variables['time']
+        if not trjobj.variables.has_key(statistics + 'box_' + variable):
+            print errormsg
+            print '  ' + fname + ": file '" + trjfile + "' does not have variable '"+\
+              statistics + 'box_' + variable + "' !!"
+            quit(-1)
+        ovar = trjobj.variables[statistics + 'box_' + variable]
+        dimt = otim.shape[0]
+
+        if trjfile == sims[0]:
+            gunits = ovar.getncattr('units')
+            lname = ovar.getncattr('long_name')
+            tunits = otim.getncattr('units')
+
+        if tini != -1:
+            tiniid = -1
+            tendid = -1       
+            for itv in range(dimt):
+                if otim[itv] <= tini and otim[itv+1] >= tini: tiniid = itv
+                if otim[itv] <= tend and otim[itv+1] >= tend: tendid = itv
+
+            if tiniid == -1 or tendid == -1:
+                print errormsg
+                print '  ' + main + ' time interval ', tini,',',tend,' not found: ',     \
+                  tendid, ',', tiniid, ' !!'
+                print '    data interval [',otim[0], otim[dimt-1],']'
+                quit(-1)
+            dimt = tendid - tiniid + 1
+
+        else:
+            dimt = otim.shape[0]
+
+        valsv = np.zeros((2,dimt), dtype=np.float)
+
+        if tini == -1:
+            valsv[1,:] = otim[:]
+            valsv[0,:] = ovar[:]
+        else:
+            valsv[1,:] = otim[tiniid:tendid+1]
+            valsv[0,:] = ovar[tiniid:tendid+1]
+
+        vartimetrjv.append(valsv)
+        trjobj.close()
+
+    drw.plot_TimeSeries(vartimetrjv, drw.units_lunits(gunits), tunits,               \
+      'val_trajectories_' + statistics, gvarname, timetit, tkind, timefmt, title,    \
+      leglabels, locleg, gkind)
+
+def variable_values(values):
+    """ Function to give back values for a given variable
+      values= [varname] name of the variable
+    """
+
+    fname = 'variable_values'
+
+    values = drw.variables_values(values)
+
+    print fname,'values:',values
+    print fname,'variable_name:',values[0]
+    print fname,'standard_name:',values[1]
+    print fname,'min,max:',str(values[2]) + ',' + str(values[3])
+    print fname,'long_name:',values[4]
+    print fname,'units:',values[5]
+    print fname,'shad_colors:',values[6]
+    print fname,'all_values:',drw.numVector_String(values,',')
+
+    return
+
+####### ###### ##### #### ### ## #
+
+ngraphics = "'" + drw.numVector_String(namegraphics, "', '") + "'"
+
+### Options
+##string_operation="operation to make: " + '\n' + " out, output values -S inidim1,[inidim2,...]:enddim1,[enddim2,...]"
+string_operation="""operation to make: 
+  draw_topo_geogrid, draws topography from a WPS geo_em.d[nn].nc: -S [minTopo],[maxTopo]:[SW_lon],[SW_lat],[NE_lon],[NE_lat]:[title]:[graphic_kind]:[projection],[res_coastline]
+  draw_2D_shad_cont, draws two 2D fields, first with shading second with contour lines: -v [varns],[varnc] -S [vnamefs],[vnamefc],[dimxvn],[dimyvn],[colorbar],[ckind],[clabfmt],[sminv]:[smaxv],[sminc]:[smaxv]:[Nlev],[figt],[kindfig],[reverse]
+    [ckind]:
+      'cmap': as it gets from colorbar
+      'fixc,[colname]': fixed color [colname], all stright lines
+      'fixsignc,[colname]': fixed color [colname], >0 stright, <0 dashed  line
+"""
+
+#print string_operation
+
+parser = OptionParser()
+parser.add_option("-f", "--netCDF_file", dest="ncfile", 
+                  help="file to use", metavar="FILE")
+parser.add_option("-o", "--operation", type='choice', dest="operation", 
+       choices=namegraphics, 
+                  help="operation to make: " + ngraphics, metavar="OPER")
+parser.add_option("-S", "--valueS", dest="values", 
+                  help="[WHEN APPLICABLE] values to use according to the operation", metavar="VALUES")
+parser.add_option("-v", "--variable", dest="varname",
+                  help="[WHEN APPLICABLE] variable to check", metavar="VAR")
+
+(opts, args) = parser.parse_args()
+
+#######    #######
+## MAIN
+    #######
+
+# Not checking file operation
+Notcheckingfile = ['draw_2D_shad_cont', 'draw_2D_shad_cont_time',                    \
+  'draw_2D_shad_line', 'draw_2D_shad_line_time', 'draw_topo_geogrid_boxes',          \
+  'draw_trajectories', 'draw_vals_trajectories', 'variable_values']
+
+####### ###### ##### #### ### ## #
+errormsg='ERROR -- error -- ERROR -- error'
+
+varn=opts.varname
+oper=opts.operation
+
+if opts.ncfile is not None and not os.path.isfile(opts.ncfile) and                   \
+  not drw.searchInlist(Notcheckingfile, oper):
+    print errormsg
+    print '  ' + main + ': File ' + opts.ncfile + ' does not exist !!'
+    quit(-1)
+
+if oper == 'create_movie':
+    create_movie(opts.ncfile, opts.values, opts.varname)
+elif oper == 'draw_2D_shad':
+    draw_2D_shad(opts.ncfile, opts.values, opts.varname)
+elif oper == 'draw_2D_shad_time':
+    draw_2D_shad_time(opts.ncfile, opts.values, opts.varname)
+elif oper == 'draw_2D_shad_cont':
+    draw_2D_shad_cont(opts.ncfile, opts.values, opts.varname)
+elif oper == 'draw_2D_shad_cont_time':
+    draw_2D_shad_cont_time(opts.ncfile, opts.values, opts.varname)
+elif oper == 'draw_2D_shad_line':
+    draw_2D_shad_line(opts.ncfile, opts.values, opts.varname)
+elif oper == 'draw_2D_shad_line_time':
+    draw_2D_shad_line_time(opts.ncfile, opts.values, opts.varname)
+elif oper == 'draw_Neighbourghood_evol':
+    draw_Neighbourghood_evol(opts.ncfile, opts.values, opts.varname)
+elif oper == 'draw_lines':
+    draw_lines(opts.ncfile, opts.values, opts.varname)
+elif oper == 'draw_timeSeries':
+    draw_timeSeries(opts.ncfile, opts.values, opts.varname)
+elif oper == 'draw_topo_geogrid':
+    draw_topo_geogrid(opts.ncfile, opts.values)
+elif oper == 'draw_topo_geogrid_boxes':
+    draw_topo_geogrid_boxes(opts.ncfile, opts.values)
+elif oper == 'draw_trajectories':
+    draw_trajectories(opts.ncfile, opts.values, opts.varname)
+elif oper == 'draw_vals_trajectories':
+    draw_vals_trajectories(opts.ncfile, opts.values, opts.varname)
+elif oper == 'list_graphics':
+# From: http://www.diveintopython.net/power_of_introspection/all_together.html
+    import drawing as myself
+    object = myself
+    for opern in namegraphics:
+        if  opern != 'list_graphics': 
+            print opern + '_______ ______ _____ ____ ___ __ _'
+            print getattr(object, opern).__doc__
+elif oper == 'variable_values':
+    variable_values(opts.values)
+else:
+    print errormsg
+    print '  ' + main + ": the graphic '" + oper + "' is not ready !!"
+    print errormsg
+    quit()
Index: trunk/tools/drawing_tools.py
===================================================================
--- trunk/tools/drawing_tools.py	(revision 192)
+++ trunk/tools/drawing_tools.py	(revision 192)
@@ -0,0 +1,4460 @@
+# -*- coding: iso-8859-15 -*-
+#import pylab as plt
+# From http://stackoverflow.com/questions/13336823/matplotlib-python-error
+import numpy as np
+import matplotlib as mpl
+mpl.use('Agg')
+import matplotlib.pyplot as plt
+from mpl_toolkits.basemap import Basemap
+import os
+from netCDF4 import Dataset as NetCDFFile
+
+errormsg = 'ERROR -- error -- ERROR -- error'
+warnmsg = 'WARNING -- waring -- WARNING -- warning'
+
+fillValue = 1.e20
+
+####### Funtions
+# searchInlist:
+# datetimeStr_datetime:
+# dateStr_date:
+# numVector_String:
+# timeref_datetime:
+# slice_variable:
+# interpolate_locs:
+# datetimeStr_conversion:
+# percendone:
+# netCDFdatetime_realdatetime:
+# file_nlines:
+# variables_values:
+# check_colorBar:
+# units_lunits:
+# ASCII_LaTeX:
+# pretty_int:
+# DegGradSec_deg:
+# intT2dt:
+# lonlat_values:
+# date_CFtime:
+# pot_values:
+# CFtimes_plot:
+# color_lines:
+# output_kind:
+# check_arguments:
+# Str_Bool:
+# plot_points:
+# plot_2Dfield:
+# plot_2Dfield_easy:
+# plot_topo_geogrid:
+# plot_topo_geogrid_boxes:
+# plot_2D_shadow:
+# plot_2D_shadow_time: Plotting a 2D field with one of the axes being time
+# plot_Neighbourghood_evol:Plotting neighbourghood evolution# plot_Trajectories
+# plot_2D_shadow_contour:
+# plot_2D_shadow_contour_time:
+# dxdy_lonlat: Function to provide lon/lat 2D lilke-matrices from any sort of dx,dy values
+# plot_2D_shadow_line:
+# plot_lines: Function to plot a collection of lines
+
+# From nc_var_tools.py
+def searchInlist(listname, nameFind):
+    """ Function to search a value within a list
+    listname = list
+    nameFind = value to find
+    >>> searInlist(['1', '2', '3', '5'], '5')
+    True
+    """
+    for x in listname:
+      if x == nameFind:
+        return True
+    return False
+
+def datetimeStr_datetime(StringDT):
+    """ Function to transform a string date ([YYYY]-[MM]-[DD]_[HH]:[MI]:[SS] format) to a date object
+    >>> datetimeStr_datetime('1976-02-17_00:00:00')
+    1976-02-17 00:00:00
+    """
+    import datetime as dt
+
+    fname = 'datetimeStr_datetime'
+
+    dateD = np.zeros((3), dtype=int)
+    timeT = np.zeros((3), dtype=int)
+
+    dateD[0] = int(StringDT[0:4])
+    dateD[1] = int(StringDT[5:7])
+    dateD[2] = int(StringDT[8:10])
+
+    trefT = StringDT.find(':')
+    if not trefT == -1:
+#        print '  ' + fname + ': refdate with time!'
+        timeT[0] = int(StringDT[11:13])
+        timeT[1] = int(StringDT[14:16])
+        timeT[2] = int(StringDT[17:19])
+
+    if int(dateD[0]) == 0:
+        print warnmsg
+        print '    ' + fname + ': 0 reference year!! changing to 1'
+        dateD[0] = 1 
+ 
+    newdatetime = dt.datetime(dateD[0], dateD[1], dateD[2], timeT[0], timeT[1], timeT[2])
+
+    return newdatetime
+
+def dateStr_date(StringDate):
+  """ Function to transform a string date ([YYYY]-[MM]-[DD] format) to a date object
+  >>> dateStr_date('1976-02-17')
+  1976-02-17
+  """
+  import datetime as dt
+
+  dateD = StringDate.split('-')
+  if int(dateD[0]) == 0:
+    print warnmsg
+    print '    dateStr_date: 0 reference year!! changing to 1'
+    dateD[0] = 1
+  newdate = dt.date(int(dateD[0]), int(dateD[1]), int(dateD[2]))
+  return newdate
+
+def numVector_String(vec,char):
+    """ Function to transform a vector of numbers to a single string [char] separated
+    numVector_String(vec,char)
+      vec= vector with the numerical values
+      char= single character to split the values
+    >>> print numVector_String(np.arange(10),' ')
+    0 1 2 3 4 5 6 7 8 9
+    """
+    fname = 'numVector_String'
+
+    if vec == 'h':
+        print fname + '_____________________________________________________________'
+        print numVector_String.__doc__
+        quit()
+
+    Nvals = len(vec)
+
+    string=''
+    for i in range(Nvals):
+        if i == 0:
+            string = str(vec[i])
+        else:
+            string = string + char + str(vec[i])
+
+    return string
+
+def timeref_datetime(refd, timeval, tu):
+    """ Function to transform from a [timeval] in [tu] units from the time referece [tref] to datetime object
+    refd: time of reference (as datetime object)
+    timeval: time value (as [tu] from [tref])
+    tu: time units
+    >>> timeref = date(1949,12,1,0,0,0)
+    >>> timeref_datetime(timeref, 229784.36, hours)
+    1976-02-17 08:21:36
+    """
+    import datetime as dt
+    import numpy as np
+
+## Not in timedelta
+#    if tu == 'years':
+#        realdate = refdate + dt.timedelta(years=float(timeval))
+#    elif tu == 'months':
+#        realdate = refdate + dt.timedelta(months=float(timeval))
+    if tu == 'weeks':
+        realdate = refd + dt.timedelta(weeks=float(timeval))
+    elif tu == 'days':
+        realdate = refd + dt.timedelta(days=float(timeval))
+    elif tu == 'hours':
+        realdate = refd + dt.timedelta(hours=float(timeval))
+    elif tu == 'minutes':
+        realdate = refd + dt.timedelta(minutes=float(timeval))
+    elif tu == 'seconds':
+        realdate = refd + dt.timedelta(seconds=float(timeval))
+    elif tu == 'milliseconds':
+        realdate = refd + dt.timedelta(milliseconds=float(timeval))
+    else:
+          print errormsg
+          print '    timeref_datetime: time units "' + tu + '" not ready!!!!'
+          quit(-1)
+
+    return realdate
+
+def slice_variable(varobj, dimslice):
+    """ Function to return a slice of a given variable according to values to its 
+      dimensions
+    slice_variable(varobj, dims)
+      varobj= object wit the variable
+      dimslice= [[dimname1]:[value1]|[[dimname2]:[value2], ...] pairs of dimension 
+        [value]: 
+          * [integer]: which value of the dimension
+          * -1: all along the dimension
+          * [beg]:[end] slice from [beg] to [end]
+    """
+    fname = 'slice_variable'
+
+    if varobj == 'h':
+        print fname + '_____________________________________________________________'
+        print slice_variable.__doc__
+        quit()
+
+    vardims = varobj.dimensions
+    Ndimvar = len(vardims)
+
+    Ndimcut = len(dimslice.split('|'))
+    dimsl = dimslice.split('|')
+
+    varvalsdim = []
+    dimnslice = []
+
+    for idd in range(Ndimvar):
+        for idc in range(Ndimcut):
+            dimcutn = dimsl[idc].split(':')[0]
+            dimcutv = dimsl[idc].split(':')[1]
+            if vardims[idd] == dimcutn: 
+                posfrac = dimcutv.find(':')
+                if posfrac != -1:
+                    inifrac = int(dimcutv.split(':')[0])
+                    endfrac = int(dimcutv.split(':')[1])
+                    varvalsdim.append(slice(inifrac,endfrac))
+                    dimnslice.append(vardims[idd])
+                else:
+                    if int(dimcutv) == -1:
+                        varvalsdim.append(slice(0,varobj.shape[idd]))
+                        dimnslice.append(vardims[idd])
+                    else:
+                        varvalsdim.append(int(dimcutv))
+                break
+
+    varvalues = varobj[tuple(varvalsdim)]
+
+    return varvalues, dimnslice
+
+def interpolate_locs(locs,coords,kinterp):
+    """ Function to provide interpolate locations on a given axis
+    interpolate_locs(locs,axis,kinterp)
+      locs= locations to interpolate
+      coords= axis values with the reference of coordinates
+      kinterp: kind of interpolation
+        'lin': linear
+    >>> coordinates = np.arange((10), dtype=np.float)
+    >>> values = np.array([-1.2, 2.4, 5.6, 7.8, 12.0])
+    >>> interpolate_locs(values,coordinates,'lin')
+    [ -1.2   2.4   5.6   7.8  13. ]
+    >>> coordinates[0] = 0.5
+    >>> coordinates[2] = 2.5
+    >>> interpolate_locs(values,coordinates,'lin')
+    [ -3.4          1.93333333   5.6          7.8         13.        ]
+    """
+
+    fname = 'interpolate_locs'
+
+    if locs == 'h':
+        print fname + '_____________________________________________________________'
+        print interpolate_locs.__doc__
+        quit()
+
+    Nlocs = locs.shape[0]
+    Ncoords = coords.shape[0]
+
+    dcoords = coords[Ncoords-1] - coords[0]
+
+    intlocs = np.zeros((Nlocs), dtype=np.float)
+    minc = np.min(coords)
+    maxc = np.max(coords)
+
+    for iloc in range(Nlocs):
+        for icor in range(Ncoords-1):
+            if locs[iloc] < minc and dcoords > 0.:
+                a = 0.
+                b = 1. / (coords[1] - coords[0])
+                c = coords[0]
+            elif locs[iloc] > maxc and dcoords > 0.:
+                a = (Ncoords-1)*1.
+                b = 1. / (coords[Ncoords-1] - coords[Ncoords-2])
+                c = coords[Ncoords-2]
+            elif locs[iloc] < minc and dcoords < 0.:
+                a = (Ncoords-1)*1.
+                b = 1. / (coords[Ncoords-1] - coords[Ncoords-2])
+                c = coords[Ncoords-2]
+            elif locs[iloc] > maxc and dcoords < 0.:
+                a = 0.
+                b = 1. / (coords[1] - coords[0])
+                c = coords[0]
+            elif locs[iloc] >= coords[icor] and locs[iloc] < coords[icor+1] and dcoords > 0.:
+                a = icor*1.
+                b = 1. / (coords[icor+1] - coords[icor])
+                c = coords[icor]
+                print coords[icor], locs[iloc], coords[icor+1], ':', icor, '->', a, b
+            elif locs[iloc] <= coords[icor] and locs[iloc] > coords[icor+1] and dcoords < 0.:
+                a = icor*1.
+                b = 1. / (coords[icor+1] - coords[icor])
+                c = coords[icor]
+
+        if kinterp == 'lin':
+            intlocs[iloc] = a + (locs[iloc] - c)*b
+        else:
+            print errormsg
+            print '  ' + fname + ": interpolation kind '" + kinterp + "' not ready !!!!!"
+            quit(-1)
+
+    return intlocs
+
+def datetimeStr_conversion(StringDT,typeSi,typeSo):
+    """ Function to transform a string date to an another date object
+    StringDT= string with the date and time
+    typeSi= type of datetime string input
+    typeSo= type of datetime string output
+      [typeSi/o]
+        'cfTime': [time],[units]; ]time in CF-convention format [units] = [tunits] since [refdate]
+        'matYmdHMS': numerical vector with [[YYYY], [MM], [DD], [HH], [MI], [SS]]
+        'YmdHMS': [YYYY][MM][DD][HH][MI][SS] format
+        'Y-m-d_H:M:S': [YYYY]-[MM]-[DD]_[HH]:[MI]:[SS] format
+        'Y-m-d H:M:S': [YYYY]-[MM]-[DD] [HH]:[MI]:[SS] format
+        'Y/m/d H-M-S': [YYYY]/[MM]/[DD] [HH]-[MI]-[SS] format
+        'WRFdatetime': [Y], [Y], [Y], [Y], '-', [M], [M], '-', [D], [D], '_', [H], 
+          [H], ':', [M], [M], ':', [S], [S]
+    >>> datetimeStr_conversion('1976-02-17_08:32:05','Y-m-d_H:M:S','matYmdHMS')
+    [1976    2   17    8   32    5]
+    >>> datetimeStr_conversion(str(137880)+',minutes since 1979-12-01_00:00:00','cfTime','Y/m/d H-M-S')
+    1980/03/05 18-00-00
+    """
+    import datetime as dt
+
+    fname = 'datetimeStr_conversion'
+
+    if StringDT[0:1] == 'h':
+        print fname + '_____________________________________________________________'
+        print datetimeStr_conversion.__doc__
+        quit()
+
+    if typeSi == 'cfTime':
+        timeval = np.float(StringDT.split(',')[0])
+        tunits = StringDT.split(',')[1].split(' ')[0]
+        Srefdate = StringDT.split(',')[1].split(' ')[2]
+
+# Does reference date contain a time value [YYYY]-[MM]-[DD] [HH]:[MI]:[SS]
+##
+        yrref=Srefdate[0:4]
+        monref=Srefdate[5:7]
+        dayref=Srefdate[8:10]
+
+        trefT = Srefdate.find(':')
+        if not trefT == -1:
+#            print '  ' + fname + ': refdate with time!'
+            horref=Srefdate[11:13]
+            minref=Srefdate[14:16]
+            secref=Srefdate[17:19]
+            refdate = datetimeStr_datetime( yrref + '-' + monref + '-' + dayref +    \
+              '_' + horref + ':' + minref + ':' + secref)
+        else:
+            refdate = datetimeStr_datetime( yrref + '-' + monref + '-' + dayref +    \
+              + '_00:00:00')
+
+        if tunits == 'weeks':
+            newdate = refdate + dt.timedelta(weeks=float(timeval))
+        elif tunits == 'days':
+            newdate = refdate + dt.timedelta(days=float(timeval))
+        elif tunits == 'hours':
+            newdate = refdate + dt.timedelta(hours=float(timeval))
+        elif tunits == 'minutes':
+            newdate = refdate + dt.timedelta(minutes=float(timeval))
+        elif tunits == 'seconds':
+            newdate = refdate + dt.timedelta(seconds=float(timeval))
+        elif tunits == 'milliseconds':
+            newdate = refdate + dt.timedelta(milliseconds=float(timeval))
+        else:
+              print errormsg
+              print '    timeref_datetime: time units "' + tunits + '" not ready!!!!'
+              quit(-1)
+
+        yr = newdate.year
+        mo = newdate.month
+        da = newdate.day
+        ho = newdate.hour
+        mi = newdate.minute
+        se = newdate.second
+    elif typeSi == 'matYmdHMS':
+        yr = StringDT[0]
+        mo = StringDT[1]
+        da = StringDT[2]
+        ho = StringDT[3]
+        mi = StringDT[4]
+        se = StringDT[5]
+    elif typeSi == 'YmdHMS':
+        yr = int(StringDT[0:4])
+        mo = int(StringDT[4:6])
+        da = int(StringDT[6:8])
+        ho = int(StringDT[8:10])
+        mi = int(StringDT[10:12])
+        se = int(StringDT[12:14])
+    elif typeSi == 'Y-m-d_H:M:S':
+        dateDT = StringDT.split('_')
+        dateD = dateDT[0].split('-')
+        timeT = dateDT[1].split(':')
+        yr = int(dateD[0])
+        mo = int(dateD[1])
+        da = int(dateD[2])
+        ho = int(timeT[0])
+        mi = int(timeT[1])
+        se = int(timeT[2])
+    elif typeSi == 'Y-m-d H:M:S':
+        dateDT = StringDT.split(' ')
+        dateD = dateDT[0].split('-')
+        timeT = dateDT[1].split(':')
+        yr = int(dateD[0])
+        mo = int(dateD[1])
+        da = int(dateD[2])
+        ho = int(timeT[0])
+        mi = int(timeT[1])
+        se = int(timeT[2])
+    elif typeSi == 'Y/m/d H-M-S':
+        dateDT = StringDT.split(' ')
+        dateD = dateDT[0].split('/')
+        timeT = dateDT[1].split('-')
+        yr = int(dateD[0])
+        mo = int(dateD[1])
+        da = int(dateD[2])
+        ho = int(timeT[0])
+        mi = int(timeT[1])
+        se = int(timeT[2])
+    elif typeSi == 'WRFdatetime':
+        yr = int(StringDT[0])*1000 + int(StringDT[1])*100 + int(StringDT[2])*10 +    \
+          int(StringDT[3])
+        mo = int(StringDT[5])*10 + int(StringDT[6])
+        da = int(StringDT[8])*10 + int(StringDT[9])
+        ho = int(StringDT[11])*10 + int(StringDT[12])
+        mi = int(StringDT[14])*10 + int(StringDT[15])
+        se = int(StringDT[17])*10 + int(StringDT[18])
+    else:
+        print errormsg
+        print '  ' + fname + ': type of String input date "' + typeSi +              \
+          '" not ready !!!!'
+        quit(-1)
+
+    if typeSo == 'matYmdHMS':
+        dateYmdHMS = np.zeros((6), dtype=int)
+        dateYmdHMS[0] =  yr
+        dateYmdHMS[1] =  mo
+        dateYmdHMS[2] =  da
+        dateYmdHMS[3] =  ho
+        dateYmdHMS[4] =  mi
+        dateYmdHMS[5] =  se
+    elif typeSo == 'YmdHMS':
+        dateYmdHMS = str(yr).zfill(4) + str(mo).zfill(2) + str(da).zfill(2) +        \
+          str(ho).zfill(2) + str(mi).zfill(2) + str(se).zfill(2)
+    elif typeSo == 'Y-m-d_H:M:S':
+        dateYmdHMS = str(yr).zfill(4) + '-' + str(mo).zfill(2) + '-' +               \
+          str(da).zfill(2) + '_' + str(ho).zfill(2) + ':' + str(mi).zfill(2) + ':' + \
+          str(se).zfill(2)
+    elif typeSo == 'Y-m-d H:M:S':
+        dateYmdHMS = str(yr).zfill(4) + '-' + str(mo).zfill(2) + '-' +               \
+          str(da).zfill(2) + ' ' + str(ho).zfill(2) + ':' + str(mi).zfill(2) + ':' + \
+          str(se).zfill(2)
+    elif typeSo == 'Y/m/d H-M-S':
+        dateYmdHMS = str(yr).zfill(4) + '/' + str(mo).zfill(2) + '/' +               \
+          str(da).zfill(2) + ' ' + str(ho).zfill(2) + '-' + str(mi).zfill(2) + '-' + \
+          str(se).zfill(2)
+    elif typeSo == 'WRFdatetime':
+        dateYmdHMS = []
+        yM = yr/1000
+        yC = (yr-yM*1000)/100
+        yD = (yr-yM*1000-yC*100)/10
+        yU = yr-yM*1000-yC*100-yD*10
+
+        mD = mo/10
+        mU = mo-mD*10
+        
+        dD = da/10
+        dU = da-dD*10
+
+        hD = ho/10
+        hU = ho-hD*10
+
+        miD = mi/10
+        miU = mi-miD*10
+
+        sD = se/10
+        sU = se-sD*10
+
+        dateYmdHMS.append(str(yM))
+        dateYmdHMS.append(str(yC))
+        dateYmdHMS.append(str(yD))
+        dateYmdHMS.append(str(yU))
+        dateYmdHMS.append('-')
+        dateYmdHMS.append(str(mD))
+        dateYmdHMS.append(str(mU))
+        dateYmdHMS.append('-')
+        dateYmdHMS.append(str(dD))
+        dateYmdHMS.append(str(dU))
+        dateYmdHMS.append('_')
+        dateYmdHMS.append(str(hD))
+        dateYmdHMS.append(str(hU))
+        dateYmdHMS.append(':')
+        dateYmdHMS.append(str(miD))
+        dateYmdHMS.append(str(miU))
+        dateYmdHMS.append(':')
+        dateYmdHMS.append(str(sD))
+        dateYmdHMS.append(str(sU))
+    else:
+        print errormsg
+        print '  ' + fname + ': type of output date "' + typeSo + '" not ready !!!!'
+        quit(-1)
+
+    return dateYmdHMS
+
+def percendone(nvals,tot,percen,msg):
+    """ Function to provide the percentage of an action across the matrix
+    nvals=number of values
+    tot=total number of values
+    percen=percentage frequency for which the message is wanted
+    msg= message
+    """
+    from sys import stdout
+
+    num = int(tot * percen/100)
+    if (nvals%num == 0): 
+        print '\r        ' + msg + '{0:8.3g}'.format(nvals*100./tot) + ' %',
+        stdout.flush()
+
+    return ''
+
+def netCDFdatetime_realdatetime(units, tcalendar, times):
+    """ Function to transfrom from netCDF CF-compilant times to real time
+    """
+    import datetime as dt
+
+    txtunits = units.split(' ')
+    tunits = txtunits[0]
+    Srefdate = txtunits[len(txtunits) - 1]
+
+# Calendar type
+##
+    is360 = False
+    if tcalendar is not None:
+      print '  netCDFdatetime_realdatetime: There is a calendar attribute'
+      if tcalendar == '365_day' or tcalendar == 'noleap':
+          print '    netCDFdatetime_realdatetime: No leap years!'
+          isleapcal = False
+      elif tcalendar == 'proleptic_gregorian' or tcalendar == 'standard' or tcalendar == 'gregorian':
+          isleapcal = True
+      elif tcalendar == '360_day':
+          is360 = True
+          isleapcal = False
+      else:
+          print errormsg
+          print '    netCDFdatetime_realdatetime: Calendar "' + tcalendar + '" not prepared!'
+          quit(-1)
+
+# Does reference date contain a time value [YYYY]-[MM]-[DD] [HH]:[MI]:[SS]
+##
+    timeval = Srefdate.find(':')
+
+    if not timeval == -1:
+        print '  netCDFdatetime_realdatetime: refdate with time!'
+        refdate = datetimeStr_datetime(Srefdate)
+    else:
+        refdate = dateStr_date(Srefdate + '_00:00:00')
+
+    dimt = len(times)
+#    datetype = type(dt.datetime(1972,02,01))
+#    realdates = np.array(dimt, datetype)
+#    print realdates
+
+## Not in timedelta
+#  if tunits == 'years':
+#    for it in range(dimt):
+#      realdate = refdate + dt.timedelta(years=float(times[it]))
+#      realdates[it] = int(realdate.year)
+#  elif tunits == 'months':
+#    for it in range(dimt):
+#      realdate = refdate + dt.timedelta(months=float(times[it]))
+#      realdates[it] = int(realdate.year)
+#    realdates = []
+    realdates = np.zeros((dimt, 6), dtype=int)
+    if tunits == 'weeks':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(weeks=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'days':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(days=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'hours':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(hours=float(times[it]))
+#            if not isleapcal:
+#                Nleapdays = cal.leapdays(int(refdate.year), int(realdate.year))
+#                realdate = realdate - dt.timedelta(days=Nleapdays)
+#            if is360:
+#                Nyears360 = int(realdate.year) - int(refdate.year) + 1
+#                realdate = realdate -dt.timedelta(days=Nyears360*5)
+#            realdates[it] = realdate
+#        realdates = refdate + dt.timedelta(hours=float(times))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'minutes':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(minutes=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'seconds':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(seconds=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'milliseconds':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(milliseconds=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'microseconds':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(microseconds=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    else:
+        print errormsg
+        print '  netCDFdatetime_realdatetime: time units "' + tunits + '" is not ready!!!'
+        quit(-1)
+
+    return realdates
+
+def file_nlines(filen):
+    """ Function to provide the number of lines of a file
+    filen= name of the file
+    >>> file_nlines('trajectory.dat')
+    49
+    """
+    fname = 'file_nlines'
+
+    if not os.path.isfile(filen):
+        print errormsg
+        print '  ' + fname + ' file: "' + filen + '" does not exist !!'
+        quit(-1)
+
+    fo = open(filen,'r')
+
+    nlines=0
+    for line in fo: nlines = nlines + 1
+
+    fo.close()
+
+    return nlines
+
+def realdatetime1_CFcompilant(time, Srefdate, tunits):
+    """ Function to transform a matrix with a real time value ([year, month, day, 
+      hour, minute, second]) to a netCDF one
+        time= matrix with time
+        Srefdate= reference date ([YYYY][MM][DD][HH][MI][SS] format)
+        tunits= units of time respect to Srefdate
+    >>> realdatetime1_CFcompilant([1976, 2, 17, 8, 20, 0], '19491201000000', 'hours')
+    229784.33333333
+    """ 
+
+    import datetime as dt
+    yrref=int(Srefdate[0:4])
+    monref=int(Srefdate[4:6])
+    dayref=int(Srefdate[6:8])
+    horref=int(Srefdate[8:10])
+    minref=int(Srefdate[10:12])
+    secref=int(Srefdate[12:14])
+ 
+    refdate=dt.datetime(yrref, monref, dayref, horref, minref, secref)
+
+    if tunits == 'weeks':
+        cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5])-refdate
+        cfdates = (cfdate.days + cfdate.seconds/(3600.*24.))/7.
+    elif tunits == 'days':
+        cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5]) - refdate
+        cfdates = cfdate.days + cfdate.seconds/(3600.*24.)
+    elif tunits == 'hours':
+        cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5]) - refdate
+        cfdates = cfdate.days*24. + cfdate.seconds/3600.
+    elif tunits == 'minutes':
+        cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5]) - refdate
+        cfdates = cfdate.days*24.*60. + cfdate.seconds/60.
+    elif tunits == 'seconds':
+        cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5]) - refdate
+        cfdates = cfdate.days*24.*3600. + cfdate.seconds
+    elif tunits == 'milliseconds':
+        cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5]) - refdate
+        cfdates = cfdate.days*1000.*24.*3600. + cfdate.seconds*1000.
+    elif tunits == 'microseconds':
+        cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],times[5]) - refdate
+        cfdates = cfdate.days*1000000.*24.*3600. + cfdate.seconds*1000000.
+    else:
+        print errormsg
+        print '  ' + fname + ': time units "' + tunits + '" is not ready!!!'
+        quit(-1)
+
+    return cfdates
+
+def basicvardef(varobj, vstname, vlname, vunits):
+    """ Function to give the basic attributes to a variable
+    varobj= netCDF variable object
+    vstname= standard name of the variable
+    vlname= long name of the variable
+    vunits= units of the variable
+    """
+    attr = varobj.setncattr('standard_name', vstname)
+    attr = varobj.setncattr('long_name', vlname)
+    attr = varobj.setncattr('units', vunits)
+
+    return 
+
+def variables_values(varName):
+    """ Function to provide values to plot the different variables
+    variables_values(varName)
+      [varName]= name of the variable
+        return: [var name], [std name], [minimum], [maximum], 
+          [long name]('|' for spaces), [units], [color palette] (following: 
+          http://matplotlib.org/1.3.1/examples/color/colormaps_reference.html)
+     [varn]: original name of the variable
+       NOTE: It might be better doing it with an external ASII file. But then we 
+         got an extra dependency...
+    >>> variables_values('WRFght')
+    ['z', 'geopotential_height', 0.0, 80000.0, 'geopotential|height', 'm2s-2', 'rainbow']
+    """
+    fname='variables_values'
+
+    if varName == 'h':
+        print fname + '_____________________________________________________________'
+        print variables_values.__doc__
+        quit()
+
+# Variable name might come with a statistical surname...
+    stats=['min','max','mean','stdv']
+
+    ifst = False
+    for st in stats:
+        if varName.find(st) > -1:
+            print '    '+ fname + ": varibale '" + varName + "' with a statistical "+\
+              " surname: '",st,"' !!"
+            Lst = len(st)
+            LvarName = len(varName)
+            varn = varName[0:LvarName - Lst]
+            ifst = True
+            break
+    if not ifst:
+        varn = varName
+
+    if varn[0:6] == 'varDIM': 
+# Variable from a dimension (all with 'varDIM' prefix)
+        Lvarn = len(varn)
+        varvals = [varn[6:Lvarn+1], varn[6:Lvarn+1], 0., 1.,                         \
+          "variable|from|size|of|dimension|'" + varn[6:Lvarn+1] + "'", '1', 'rainbox']
+    elif varn == 'a_tht' or varn == 'LA_THT':
+        varvals = ['a_th', 'total_thermal_plume_cover', 0., 1.,                      \
+        'total|column|thermal|plume|cover', '1', 'YlGnBu']
+    elif varn == 'bils' or varn == 'LBILS':
+        varvals = ['bils', 'surface_total_heat_flux', -100., 100.,                   \
+          'surface|total|heat|flux', 'Wm-2', 'seismic']
+    elif varn == 'landcat' or varn == 'category':
+        varvals = ['landcat', 'land_categories', 0., 22., 'land|categories', '1',    \
+          'rainbow']
+    elif varn == 'c' or varn == 'QCLOUD' or varn == 'oliq' or varn == 'OLIQ':
+        varvals = ['c', 'condensed_water_mixing_ratio', 0., 3.e-4,                   \
+          'condensed|water|mixing|ratio', 'kgkg-1', 'BuPu']
+    elif varn == 'clt' or varn == 'CLT' or varn == 'cldt' or                         \
+      varn == 'Total cloudiness':
+        varvals = ['clt', 'cloud_area_fraction', 0., 1., 'total|cloud|cover', '1',   \
+          'gist_gray']
+    elif varn == 'cll' or varn == 'cldl' or varn == 'LCLDL' or                       \
+      varn == 'Low-level cloudiness':
+        varvals = ['cll', 'low_level_cloud_area_fraction', 0., 1.,                   \
+          'low|level|(p|>|680|hPa)|cloud|fraction', '1', 'gist_gray']
+    elif varn == 'clm' or varn == 'cldm' or varn == 'LCLDM' or                       \
+      varn == 'Mid-level cloudiness':
+        varvals = ['clm', 'mid_level_cloud_area_fraction', 0., 1.,                   \
+          'medium|level|(440|<|p|<|680|hPa)|cloud|fraction', '1', 'gist_gray']
+    elif varn == 'clh' or varn == 'cldh' or varn == 'LCLDH' or                       \
+      varn == 'High-level cloudiness':
+        varvals = ['clh', 'high_level_cloud_area_fraction', 0., 1.,                  \
+          'high|level|(p|<|440|hPa)|cloud|fraction', '1', 'gist_gray']
+    elif varn == 'dqajs' or varn == 'LDQAJS':
+        varvals = ['dqajs', 'dry_adjustment_water_vapor_tendency', -0.0003, 0.0003,  \
+        'dry|adjustment|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqcon' or varn == 'LDQCON':
+        varvals = ['dqcon', 'convective_water_vapor_tendency', -3e-8, 3.e-8,         \
+        'convective|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqdyn' or varn == 'LDQDYN':
+        varvals = ['dqdyn', 'dynamics_water_vapor_tendency', -3.e-7, 3.e-7,          \
+        'dynamics|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqeva' or varn == 'LDQEVA':
+        varvals = ['dqeva', 'evaporation_water_vapor_tendency', -3.e-6, 3.e-6,       \
+        'evaporation|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqlscst' or varn == 'LDQLSCST':
+        varvals = ['dqlscst', 'stratocumulus_water_vapor_tendency', -3.e-7, 3.e-7,   \
+        'stratocumulus|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqlscth' or varn == 'LDQLSCTH': 
+        varvals = ['dqlscth', 'thermals_water_vapor_tendency', -3.e-7, 3.e-7,        \
+        'thermal|plumes|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqlsc' or varn == 'LDQLSC':
+        varvals = ['dqlsc', 'condensation_water_vapor_tendency', -3.e-6, 3.e-6,      \
+        'condensation|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqphy' or varn == 'LDQPHY':
+        varvals = ['dqphy', 'physics_water_vapor_tendency', -3.e-7, 3.e-7,           \
+        'physics|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqthe' or varn == 'LDQTHE':
+        varvals = ['dqthe', 'thermals_water_vapor_tendency', -3.e-7, 3.e-7,          \
+        'thermal|plumes|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqvdf' or varn == 'LDQVDF':
+        varvals = ['dqvdf', 'vertical_difussion_water_vapor_tendency', -3.e-8, 3.e-8,\
+        'vertical|difussion|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqwak' or varn == 'LDQWAK':
+        varvals = ['dqwak', 'wake_water_vapor_tendency', -3.e-7, 3.e-7,              \
+        'wake|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dtajs' or varn == 'LDTAJS':
+        varvals = ['dtajs', 'dry_adjustment_thermal_tendency', -3.e-5, 3.e-5,        \
+        'dry|adjustment|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtcon' or varn == 'LDTCON':
+        varvals = ['dtcon', 'convective_thermal_tendency', -3.e-5, 3.e-5,            \
+        'convective|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtdyn' or varn == 'LDTDYN':
+        varvals = ['dtdyn', 'dynamics_thermal_tendency', -3.e-4, 3.e-4,              \
+        'dynamics|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dteva' or varn == 'LDTEVA':
+        varvals = ['dteva', 'evaporation_thermal_tendency', -3.e-3, 3.e-3,           \
+        'evaporation|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtlscst' or varn == 'LDTLSCST':
+        varvals = ['dtlscst', 'stratocumulus_thermal_tendency', -3.e-4, 3.e-4,       \
+        'stratocumulus|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtlscth' or varn == 'LDTLSCTH':
+        varvals = ['dtlscth', 'thermals_thermal_tendency', -3.e-4, 3.e-4,            \
+        'thermal|plumes|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtlsc' or varn == 'LDTLSC':
+        varvals = ['dtlsc', 'condensation_thermal_tendency', -3.e-3, 3.e-3,          \
+        'condensation|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtphy' or varn == 'LDTPHY':
+        varvals = ['dtphy', 'physics_thermal_tendency', -3.e-4, 3.e-4,               \
+        'physics|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtthe' or varn == 'LDTTHE':
+        varvals = ['dtthe', 'thermals_thermal_tendency', -3.e-4, 3.e-4,              \
+        'thermal|plumes|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtvdf' or varn == 'LDTVDF':
+        varvals = ['dtvdf', 'vertical_difussion_thermal_tendency', -3.e-5, 3.e-5,    \
+        'vertical|difussion|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtwak' or varn == 'LDTWAK':
+        varvals = ['dtwak', 'wake_thermal_tendency', -3.e-4, 3.e-4,                  \
+        'wake|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'evspsbl' or varn == 'LEVAP' or varn == 'evap':
+        varvals = ['evspsbl', 'water_evaporation_flux', 0., 1.5e-4,                  \
+          'water|evaporation|flux', 'kgm-2s-1', 'Blues']
+    elif varn == 'h2o' or varn == 'LH2O':
+        varvals = ['h2o', 'water_mass_fraction', 0., 3.e-2,                          \
+          'mass|fraction|of|water', '1', 'Blues']
+    elif varn == 'hfls' or varn == 'LH' or varn == 'LFLAT' or varn == 'flat':
+        varvals = ['hfls', 'surface_upward_latent_heat_flux', -400., 400.,           \
+          'upward|latnt|heat|flux|at|the|surface', 'Wm-2', 'seismic']
+    elif varn == 'hfss' or varn == 'LSENS' or varn == 'sens':
+        varvals = ['hfss', 'surface_upward_sensible_heat_flux', -150., 150.,         \
+          'upward|sensible|heat|flux|at|the|surface', 'Wm-2', 'seismic']
+    elif varn == 'hus' or varn == 'WRFrh' or varn == 'LMDZrh' or varn == 'rhum' or   \
+      varn == 'LRHUM':
+        varvals = ['hus', 'specific_humidity', 0., 1., 'specific|humidty', '1',      \
+          'BuPu']
+    elif varn == 'huss' or varn == 'WRFrhs' or varn == 'LMDZrhs' or varn == 'rh2m' or\
+      varn == 'LRH2M':
+        varvals = ['huss', 'specific_humidity', 0., 1., 'specific|humidty|at|2m',    \
+          '1', 'BuPu']
+    elif varn == 'lat' or varn == 'XLAT' or varn == 'XLAT_M' or varn == 'latitude':
+        varvals = ['lat', 'latitude', -90., 90., 'latitude', 'degrees North',        \
+          'seismic']
+    elif varn == 'lon' or varn == 'XLONG' or varn == 'XLONG_M':
+        varvals = ['lon', 'longitude', -180., 180., 'longitude', 'degrees East',     \
+          'seismic']
+    elif varn == 'longitude':
+        varvals = ['lon', 'longitude', 0., 360., 'longitude', 'degrees East',        \
+          'seismic']
+    elif varn == 'orog' or varn == 'HGT' or varn == 'HGT_M':
+        varvals = ['orog', 'orography',  0., 3000., 'surface|altitude', 'm','terrain']
+    elif varn == 'pr' or varn == 'RAINTOT' or varn == 'precip' or                    \
+      varn == 'LPRECIP' or varn == 'Precip Totale liq+sol':
+        varvals = ['pr', 'precipitation_flux', 0., 1.e-4, 'precipitation|flux',      \
+          'kgm-2s-1', 'BuPu']
+    elif varn == 'pracc' or varn == 'ACRAINTOT':
+        varvals = ['pracc', 'precipitation_amount', 0., 100.,                        \
+          'accumulated|precipitation', 'kgm-2', 'BuPu']
+    elif varn == 'prc' or varn == 'LPLUC' or varn == 'pluc' or varn == 'WRFprc':
+        varvals = ['prc', 'convective_precipitation_flux', 0., 2.e-4,                \
+          'convective|precipitation|flux', 'kgm-2s-1', 'Blues']
+    elif varn == 'pres' or varn == 'presnivs' or varn == 'pressure':
+        varvals = ['pres', 'air_pressure', 0., 103000., 'air|pressure', 'Pa',        \
+          'Blues']
+    elif varn == 'prls' or varn == 'WRFprls' or varn == 'LPLUL' or varn == 'plul':
+        varvals = ['prls', 'large_scale_precipitation_flux', 0., 2.e-4,              \
+          'large|scale|precipitation|flux', 'kgm-2s-1', 'Blues']
+    elif varn == 'prsn' or varn == 'SNOW' or varn == 'snow' or varn == 'LSNOW':
+        varvals = ['prsn', 'snowfall', 0., 1.e-4, 'snowfall|flux', 'kgm-2s-1', 'BuPu']
+    elif varn == 'prw' or varn == 'WRFprh':
+        varvals = ['prw', 'atmosphere_water_vapor_content', 0., 10.,                 \
+          'water|vapor"path', 'kgm-2', 'Blues']
+    elif varn == 'ps' or varn == 'psfc' or varn =='PSFC' or varn == 'psol' or        \
+      varn == 'Surface Pressure':
+        varvals=['ps', 'surface_air_pressure', 85000., 105400., 'surface|pressure',  \
+          'hPa', 'cool']
+    elif varn == 'psl' or varn == 'mslp' or varn =='WRFmslp':
+        varvals=['psl', 'air_pressure_at_sea_level', 85000., 104000.,                \
+          'mean|sea|level|pressure', 'Pa', 'Greens']
+    elif varn == 'q_th':
+        varvals = ['q_th', 'thermal_plume_total_water_content', 0., 25.,             \
+          'total|water|cotent|in|thermal|plume', 'mm', 'YlOrRd']
+    elif varn == 'r' or varn == 'QVAPOR' or varn == 'ovap' or varn == 'LOVAP':
+        varvals = ['r', 'water_mixing_ratio', 0., 0.03, 'water|mixing|ratio',        \
+          'kgkg-1', 'BuPu']
+    elif varn == 'rsds' or varn == 'SWdnSFC' or varn == 'SWdn at surface' or         \
+      varn == 'SWDOWN':
+        varvals=['rsds', 'surface_downwelling_shortwave_flux_in_air',  0., 1200.,    \
+          'downward|SW|surface|radiation', 'Wm-2' ,'Reds']
+    elif varn == 'rsdsacc':
+        varvals=['rsdsacc', 'accumulated_surface_downwelling_shortwave_flux_in_air', \
+          0., 1200., 'accumulated|downward|SW|surface|radiation', 'Wm-2' ,'Reds']
+    elif varn == 'rvor' or varn == 'WRFrvor':
+        varvals = ['rvor', 'air_relative_vorticity', -2.5E-3, 2.5E-3,                \
+          'air|relative|vorticity', 's-1', 'seismic']
+    elif varn == 'rvors' or varn == 'WRFrvors':
+        varvals = ['rvors', 'surface_air_relative_vorticity', -2.5E-3, 2.5E-3,       \
+          'surface|air|relative|vorticity', 's-1', 'seismic']
+    elif varn == 's_therm' or varn == 'LS_THERM':
+        varvals = ['s_therm', 'thermals_excess', 0., 0.8, 'thermals|excess', 'K',    \
+          'Reds']
+    elif varn == 's_therm' or varn == 'LS_THERM':
+        varvals = ['s_therm', 'thermals_excess', 0., 0.8, 'thermals|excess', 'K',    \
+          'Reds']
+    elif varn == 'ta' or varn == 'WRFt' or varn == 'temp' or varn == 'LTEMP' or      \
+      varn == 'Air temperature':
+        varvals = ['ta', 'air_temperature', 195., 320., 'air|temperature', 'K',      \
+          'YlOrRd']
+    elif varn == 'tas' or varn == 'T2' or varn == 't2m' or varn == 'T2M' or          \
+      varn == 'Temperature 2m':
+        varvals = ['tas', 'air_temperature', 240., 310., 'air|temperature|at|2m', '  \
+          K', 'YlOrRd']
+    elif varn == 'tds' or varn == 'TH2':
+        varvals = ['tds', 'air_dew_point_temperature', 240., 310.,                   \
+          'air|dew|point|temperature|at|2m', 'K', 'YlGnBu']
+    elif varn == 'time'or varn == 'time_counter':
+        varvals = ['time', 'time', 0., 1000., 'time',                                \
+          'hours|since|1949/12/01|00:00:00', 'Reds']
+    elif varn == 'ua' or varn == 'vitu' or varn == 'U' or varn == 'Zonal wind' or    \
+      varn == 'LVITU':
+        varvals = ['ua', 'eastward_wind', -30., 30., 'eastward|wind', 'ms-1',        \
+          'seismic']
+    elif varn == 'uas' or varn == 'u10m' or varn == 'U10' or varn =='Vent zonal 10m':
+        varvals = ['uas', 'eastward_wind', -30., 30., 'eastward|2m|wind',    \
+          'ms-1', 'seismic']
+    elif varn == 'va' or varn == 'vitv' or varn == 'V' or varn == 'Meridional wind'  \
+      or varn == 'LVITV':
+        varvals = ['va', 'northward_wind', -30., 30., 'northward|wind', 'ms-1',      \
+          'seismic']
+    elif varn == 'vas' or varn == 'v10m' or varn == 'V10' or                         \
+      varn =='Vent meridien 10m':
+        varvals = ['vas', 'northward_wind', -30., 30., 'northward|2m|wind', 'ms-1',  \
+          'seismic']
+    elif varn == 'wake_h' or varn == 'LWAKE_H':
+        varvals = ['wake_h', 'wake_height', 0., 1000., 'height|of|the|wakes', 'm',   \
+          'YlOrRd']
+    elif varn == 'wake_s' or varn == 'LWAKE_S':
+        varvals = ['wake_s', 'wake_area_fraction', 0., 0.5, 'wake|spatial|fraction', \
+          '1', 'BuGn']
+    elif varn == 'wa' or varn == 'W' or varn == 'Vertical wind':
+        varvals = ['wa', 'upward_wind', -10., 10., 'upward|wind', 'ms-1',            \
+          'seismic']
+    elif varn == 'wap' or varn == 'vitw' or varn == 'LVITW':
+        varvals = ['wap', 'upward_wind', -3.e-10, 3.e-10, 'upward|wind', 'mPa-1',    \
+          'seismic']
+    elif varn == 'wss' or varn == 'SPDUV':
+        varvals = ['wss', 'air_velocity',  0., 30., 'surface|horizontal|wind|speed', \
+          'ms-1', 'Reds']
+    elif varn == 'xtime' or varn == 'XTIME':
+        varvals = ['xtime', 'time',  0., 1.e5, 'time',                               \
+          'minutes|since|simulation|start', 'Reds']
+    elif varn == 'x' or varn == 'X':
+        varvals = ['x', 'x',  0., 100., 'x', '-', 'Reds']
+    elif varn == 'y' or varn == 'Y':
+        varvals = ['y', 'y',  0., 100., 'y', '-', 'Blues']
+    elif varn == 'z' or varn == 'Z':
+        varvals = ['z', 'z',  0., 100., 'z', '-', 'Greens']
+    elif varn == 'zg' or varn == 'WRFght' or varn == 'Geopotential height' or        \
+      varn == 'geop' or varn == 'LGEOP':
+        varvals = ['zg', 'geopotential_height', 0., 80000., 'geopotential|height',   \
+          'm2s-2', 'rainbow']
+    elif varn == 'zmax_th' or varn == 'LZMAX_TH':
+        varvals = ['zmax_th', 'thermal_plume_height', 0., 4000.,                     \
+          'maximum|thermals|plume|height', 'm', 'YlOrRd']
+    elif varn == 'zmla' or varn == 's_pblh' or varn == 'LS_PBLH':
+        varvals = ['zmla', 'atmosphere_boundary_layer_thickness', 0., 2500.,         \
+          'atmosphere|boundary|layer|thickness', 'm', 'Blues']
+    else:
+        print errormsg
+        print '  ' + fname + ': variable ' + varn + ' not defined !!!'
+        quit(-1)
+
+    return varvals
+
+
+#######    #######    #######    #######    #######    #######    #######    #######    #######    #######
+
+def check_colorBar(cbarn):
+    """ Check if the given colorbar exists in matplotlib
+    """
+    fname = 'check_colorBar'
+
+# Possible color bars
+    colorbars = ['binary', 'Blues', 'BuGn', 'BuPu', 'gist_yarg', 'GnBu', 'Greens',   \
+      'Greys', 'Oranges', 'OrRd', 'PuBu', 'PuBuGn', 'PuRd', 'Purples', 'RdPu',       \
+      'Reds', 'YlGn', 'YlGnBu', 'YlOrBr', 'YlOrRd', 'afmhot', 'autumn', 'bone',      \
+      'cool', 'copper', 'gist_gray', 'gist_heat', 'gray', 'hot', 'pink', 'spring',   \
+      'summer', 'winter', 'BrBG', 'bwr', 'coolwarm', 'PiYG', 'PRGn', 'PuOr', 'RdBu', \
+      'RdGy', 'RdYlBu', 'RdYlGn', 'seismic', 'Accent', 'Dark2', 'hsv', 'Paired',     \
+      'Pastel1', 'Pastel2', 'Set1', 'Set2', 'Set3', 'spectral', 'gist_earth',        \
+      'gist_ncar', 'gist_rainbow', 'gist_stern', 'jet', 'brg', 'CMRmap', 'cubehelix',\
+      'gnuplot', 'gnuplot2', 'ocean', 'rainbow', 'terrain', 'flag', 'prism']
+
+    if not searchInlist(colorbars,cbarn):
+        print warnmsg
+        print '  ' + fname + ' color bar: "' + cbarn + '" does not exist !!'
+        print '  a standard one will be use instead !!'
+
+    return
+
+def units_lunits(u):
+    """ Fucntion to provide LaTeX equivalences from a given units
+      u= units to transform
+    >>> units_lunits('kgkg-1')
+    '$kgkg^{-1}$'    
+    """
+    fname = 'units_lunits'
+
+    if u == 'h':
+        print fname + '_____________________________________________________________'
+        print units_lunits.__doc__
+        quit()
+
+# Units which does not change
+    same = ['1', 'category', 'day', 'degrees East', 'degrees Nord', 'degrees North', \
+      'g', 'hour', 'hPa', 'K', 'Km', 'kg', 'km', 'm', 'minute', 'mm', 'month', 'Pa', \
+      's', 'second', 'um', 'year', '-']
+
+    if searchInlist(same,u):
+        lu = '$' + u + '$'
+    elif len(u.split(' ')) > 1 and u.split(' ')[1] == 'since':
+        uparts = u.split(' ')
+        ip=0
+        for up in uparts:
+            if ip == 0:
+               lu = '$' + up
+            else:
+               lu = lu + '\ ' + up
+            ip=ip+1
+        lu = lu + '$'
+    else:
+        if u == 'C': lu='$^{\circ}C$'
+        elif u == 'days': lu='$day$'
+        elif u == 'degrees_east': lu='$degrees\ East$'
+        elif u == 'degree_east': lu='$degrees\ East$'
+        elif u == 'degrees longitude': lu='$degrees\ East$'
+        elif u == 'degrees latitude': lu='$degrees\ North$'
+        elif u == 'degrees_north': lu='$degrees\ North$'
+        elif u == 'degree_north': lu='$degrees\ North$'
+        elif u == 'deg C': lu='$^{\circ}C$'
+        elif u == 'degC': lu='$^{\circ}C$'
+        elif u == 'deg K': lu='$K$'
+        elif u == 'degK': lu='$K$'
+        elif u == 'hours': lu='$hour$'
+        elif u == 'J/kg': lu='$Jkg^{-1}$'
+        elif u == 'Jkg-1': lu='$Jkg^{-1}$'
+        elif u == 'K/m': lu='$Km^{-1}$'
+        elif u == 'Km-1': lu='$Km^{-1}$'
+        elif u == 'K/s': lu='$Ks^{-1}$'
+        elif u == 'Ks-1': lu='$Ks^{-1}$'
+        elif u == 'kg/kg': lu='$kgkg^{-1}$'
+        elif u == 'kgkg-1': lu='$kgkg^{-1}$'
+        elif u == 'kg kg-1': lu='$kgkg^{-1}$'
+        elif u == '(kg/kg)/s': lu='$kgkg^{-1}s^{-1}$'
+        elif u == 'kgkg-1s-1': lu='$kgkg^{-1}s^{-1}$'
+        elif u == 'kg/m2': lu='$kgm^{-2}$'
+        elif u == 'kgm-2': lu='$kgm^{-2}$'
+        elif u == 'kg m-2': lu='$kgm^{-2}$'
+        elif u == 'Kg m-2': lu='$kgm^{-2}$'
+        elif u == 'kg/m2/s': lu='$kgm^{-2}s^{-1}$'
+        elif u == 'kg/(m2*s)': lu='$kgm^{-2}s^{-1}$'
+        elif u == 'kg/(s*m2)': lu='$kgm^{-2}s^{-1}$'
+        elif u == 'kgm-2s-1': lu='$kgm^{-2}s^{-1}$'
+        elif u == '1/m': lu='$m^{-1}$'
+        elif u == 'm-1': lu='$m^{-1}$'
+        elif u == 'm2/s': lu='$m2s^{-1}$'
+        elif u == 'm2s-1': lu='$m2s^{-1}$'
+        elif u == 'm2/s2': lu='$m2s^{-2}$'
+        elif u == 'm/s': lu='$ms^{-1}$'
+        elif u == 'mmh-3': lu='$mmh^{-3}$'
+        elif u == 'ms-1': lu='$ms^{-1}$'
+        elif u == 'm s-1': lu='$ms^{-1}$'
+        elif u == 'm/s2': lu='$ms^{-2}$'
+        elif u == 'ms-2': lu='$ms^{-2}$'
+        elif u == 'minutes': lu='$minute$'
+        elif u == 'Pa/s': lu='$Pas^{-1}$'
+        elif u == 'Pas-1': lu='$Pas^{-1}$'
+        elif u == 'W m-2': lu='$Wm^{-2}$'
+        elif u == 'Wm-2': lu='$Wm^{-2}$'
+        elif u == 'W/m2': lu='$Wm^{-2}$'
+        elif u == '1/s': lu='$s^{-1}$'
+        elif u == 's-1': lu='$s^{-1}$'
+        elif u == 'seconds': lu='$second$'
+        elif u == '%': lu='\%'
+        else:
+            print errormsg
+            print '  ' + fname + ': units "' + u + '" not ready!!!!'
+            quit(-1)
+
+    return lu
+
+def ASCII_LaTeX(ln):
+    """ Function to transform from an ASCII line to LaTeX codification
+      >>> ASCII_LaTeX('Laboratoire de MÃ©tÃ©orologie Dynamique perÃ² HovmÃ¶ller')
+      Laboratoire de M\'et\'eorologie Dynamique per\`o Hovm\"oller
+    """
+    fname='ASCII_LaTeX'
+
+    if ln == 'h':
+        print fname + '_____________________________________________________________'
+        print ASCII_LaTeX.__doc__
+        quit()
+
+    newln = ln.replace('\\', '\\textbackslash')
+
+    newln = newln.replace('Ã¡', "\\'a")
+    newln = newln.replace('Ã©', "\\'e")
+    newln = newln.replace('Ã­', "\\'i")
+    newln = newln.replace('Ã³', "\\'o")
+    newln = newln.replace('Ãº', "\\'u")
+
+    newln = newln.replace('Ã ', "\\`a")
+    newln = newln.replace('Ãš', "\\`e")
+    newln = newln.replace('Ã¬', "\\`i")
+    newln = newln.replace('Ã²', "\\`o")
+    newln = newln.replace('Ã¹', "\\`u")
+
+    newln = newln.replace('Ã¢', "\\^a")
+    newln = newln.replace('Ãª', "\\^e")
+    newln = newln.replace('Ã®', "\\^i")
+    newln = newln.replace('ÃŽ', "\\^o")
+    newln = newln.replace('Ã»', "\\^u")
+
+    newln = newln.replace('Ã€', '\\"a')
+    newln = newln.replace('Ã«', '\\"e')
+    newln = newln.replace('Ã¯', '\\"i')
+    newln = newln.replace('Ã¶', '\\"o')
+    newln = newln.replace('ÃŒ', '\\"u')
+
+    newln = newln.replace('Ã§', '\c{c}')
+    newln = newln.replace('Ã±', '\~{n}')
+
+    newln = newln.replace('Ã', "\\'A")
+    newln = newln.replace('Ã', "\\'E")
+    newln = newln.replace('Ã', "\\'I")
+    newln = newln.replace('Ã', "\\'O")
+    newln = newln.replace('Ã', "\\'U")
+
+    newln = newln.replace('Ã', "\\`A")
+    newln = newln.replace('Ã', "\\`E")
+    newln = newln.replace('Ã', "\\`I")
+    newln = newln.replace('Ã', "\\`O")
+    newln = newln.replace('Ã', "\\`U")
+
+    newln = newln.replace('Ã', "\\^A")
+    newln = newln.replace('Ã', "\\^E")
+    newln = newln.replace('Ã', "\\^I")
+    newln = newln.replace('Ã', "\\^O")
+    newln = newln.replace('Ã', "\\^U")
+
+    newln = newln.replace('Ã', '\\"A')
+    newln = newln.replace('Ã', '\\"E')
+    newln = newln.replace('Ã', '\\"I')
+    newln = newln.replace('Ã', '\\"O')
+    newln = newln.replace('Ã', '\\"U')
+
+    newln = newln.replace('Ã', '\\c{C}')
+    newln = newln.replace('Ã', '\\~{N}')
+
+    newln = newln.replace('Â¡', '!`')
+    newln = newln.replace('Â¿', 'Â¿`')
+    newln = newln.replace('%', '\\%')
+    newln = newln.replace('#', '\\#')
+    newln = newln.replace('&', '\\&')
+    newln = newln.replace('$', '\\$')
+    newln = newln.replace('_', '\\_')
+    newln = newln.replace('Â·', '\\textperiodcentered')
+    newln = newln.replace('<', '$<$')
+    newln = newln.replace('>', '$>$')
+    newln = newln.replace('ï­', '*')
+#    newln = newln.replace('Âº', '$^{\\circ}$')
+    newln = newln.replace('Âª', '$^{a}$')
+    newln = newln.replace('Âº', '$^{o}$')
+    newln = newln.replace('Â°', '$^{\\circ}$')
+    newln = newln.replace('\n', '\\\\\n')
+    newln = newln.replace('\t', '\\medskip')
+
+    return newln
+
+def pretty_int(minv,maxv,Nint):
+    """ Function to plot nice intervals
+      minv= minimum value
+      maxv= maximum value
+      Nint= number of intervals
+    >>> pretty_int(23.50,67.21,5)
+    [ 25.  30.  35.  40.  45.  50.  55.  60.  65.]
+    >>> pretty_int(-23.50,67.21,15)
+    [  0.  20.  40.  60.]
+    pretty_int(14.75,25.25,5)
+    [ 16.  18.  20.  22.  24.]
+    """ 
+    fname = 'pretty_int'
+    nice_int = [1,2,5]
+
+#    print 'minv: ',minv,'maxv:',maxv,'Nint:',Nint
+
+    interval = np.abs(maxv - minv)
+
+    potinterval = np.log10(interval)
+
+    Ipotint = int(potinterval)
+    intvalue = np.float(interval / np.float(Nint))
+
+# new
+    potinterval = np.log10(intvalue)
+    Ipotint = int(potinterval)
+
+#    print 'interval:', interval, 'intavlue:', intvalue, 'potinterval:', potinterval, \
+#     'Ipotint:', Ipotint, 'intvalue:', intvalue
+
+    mindist = 10.e15
+    for inice in nice_int:
+#        print inice,':',inice*10.**Ipotint,np.abs(inice*10.**Ipotint - intvalue),mindist
+        if np.abs(inice*10.**Ipotint - intvalue) < mindist:
+            mindist = np.abs(inice*10.**Ipotint - intvalue)
+            closestint = inice
+
+    Ibeg = int(minv / (closestint*10.**Ipotint))
+
+    values = []
+    val = closestint*(Ibeg)*10.**(Ipotint)
+
+#    print 'closestint:',closestint,'Ibeg:',Ibeg,'val:',val
+
+    while val < maxv:
+        values.append(val)
+        val = val + closestint*10.**Ipotint
+
+    return np.array(values, dtype=np.float)
+
+def DegGradSec_deg(grad,deg,sec):
+    """ Function to transform from a coordinate in grad deg sec to degrees (decimal)
+    >>> DegGradSec_deg(39.,49.,26.)
+    39.8238888889
+    """
+    fname = 'DegGradSec_deg'
+
+    if grad == 'h':
+        print fname + '_____________________________________________________________'
+        print DegGradSec_deg.__doc__
+        quit()
+
+    deg = grad + deg/60. + sec/3600.
+
+    return deg
+
+def intT2dt(intT,tu):
+    """ Function to provide an 'timedelta' object from a given interval value
+      intT= interval value
+      tu= interval units, [tu]= 'd': day, 'w': week, 'h': hour, 'i': minute, 's': second,
+        'l': milisecond
+
+      >>> intT2dt(3.5,'s')
+      0:00:03.500000
+
+      >>> intT2dt(3.5,'w')
+      24 days, 12:00:00
+    """
+    import datetime as dt 
+
+    fname = 'intT2dt'
+
+    if tu == 'w':
+        dtv = dt.timedelta(weeks=np.float(intT))
+    elif tu == 'd':
+        dtv = dt.timedelta(days=np.float(intT))
+    elif tu == 'h':
+        dtv = dt.timedelta(hours=np.float(intT))
+    elif tu == 'i':
+        dtv = dt.timedelta(minutes=np.float(intT))
+    elif tu == 's':
+        dtv = dt.timedelta(seconds=np.float(intT))
+    elif tu == 'l':
+        dtv = dt.timedelta(milliseconds=np.float(intT))
+    else:
+        print errormsg
+        print '  ' + fname + ': time units "' + tu + '" not ready!!!!'
+        quit(-1)
+
+    return dtv
+
+def lonlat_values(mapfile,lonvn,latvn):
+    """ Function to obtain the lon/lat matrices from a given netCDF file
+    lonlat_values(mapfile,lonvn,latvn)
+      [mapfile]= netCDF file name
+      [lonvn]= variable name with the longitudes
+      [latvn]= variable name with the latitudes
+    """
+
+    fname = 'lonlat_values'
+
+    if mapfile == 'h':
+        print fname + '_____________________________________________________________'
+        print lonlat_values.__doc__
+        quit()
+
+    if not os.path.isfile(mapfile):
+        print errormsg
+        print '  ' + fname + ": map file '" + mapfile + "' does not exist !!"
+        quit(-1)
+
+    ncobj = NetCDFFile(mapfile, 'r')
+    lonobj = ncobj.variables[lonvn]
+    latobj = ncobj.variables[latvn]
+
+    if len(lonobj.shape) == 3:
+        lonv = lonobj[0,:,:]
+        latv = latobj[0,:,:]
+    elif len(lonobj.shape) == 2:
+        lonv = lonobj[:,:]
+        latv = latobj[:,:]
+    elif len(lonobj.shape) == 1:
+        lon0 = lonobj[:]
+        lat0 = latobj[:]
+        lonv = np.zeros( (len(lat0),len(lon0)), dtype=np.float )
+        latv = np.zeros( (len(lat0),len(lon0)), dtype=np.float )
+        for iy in range(len(lat0)):
+            lonv[iy,:] = lon0
+        for ix in range(len(lon0)):
+            latv[:,ix] = lat0
+    else:
+        print errormsg
+        print '  ' + fname + ': lon/lat variables shape:',lonobj.shape,'not ready!!'
+        quit(-1)
+
+    return lonv, latv
+
+def date_CFtime(ind,refd,tunits):
+    """ Function to transform from a given date object a CF-convention time
+      ind= date object to transform
+      refd= reference date
+      tunits= units for time
+        >>> date_CFtime(dt.datetime(1976,02,17,08,30,00), dt.datetime(1949,12,01,00,00,00), 'seconds')
+        827224200.0
+    """
+    import datetime as dt
+
+    fname = 'date_CFtime'
+
+    dt = ind - refd
+
+    if tunits == 'weeks':
+        value = dt.days/7. + dt.seconds/(3600.*24.*7.)
+    elif tunits == 'days':
+        value = dt.days + dt.seconds/(3600.*24.)
+    elif tunits == 'hours':
+        value = dt.days*24. + dt.seconds/(3600.)
+    elif tunits == 'minutes':
+        value = dt.days*24.*60. + dt.seconds/(60.)
+    elif tunits == 'seconds':
+        value = dt.days*24.*3600. + dt.seconds
+    elif tunits == 'milliseconds':
+        value = dt.days*24.*3600.*1000. + dt.seconds*1000.
+    else:
+        print errormsg
+        print '  ' + fname + ': reference time units "' + trefu + '" not ready!!!!'
+        quit(-1)
+
+    return value
+
+def pot_values(values, uvals):
+    """ Function to modify a seies of values by their potency of 10
+      pot_values(values, uvals)
+      values= values to modify
+      uvals= units of the values
+      >>> vals = np.sin(np.arange(20)*np.pi/5.+0.01)*10.e-5
+      >>> pot_values(vals,'ms-1')
+      (array([  0.00000000e+00,   5.87785252e-01,   9.51056516e-01,
+         9.51056516e-01,   5.87785252e-01,   1.22464680e-16,
+        -5.87785252e-01,  -9.51056516e-01,  -9.51056516e-01,
+        -5.87785252e-01,  -2.44929360e-16,   5.87785252e-01,
+         9.51056516e-01,   9.51056516e-01,   5.87785252e-01,
+         3.67394040e-16,  -5.87785252e-01,  -9.51056516e-01,
+        -9.51056516e-01,  -5.87785252e-01]), -4, 'x10e-4 ms-1', 'x10e-4')
+    """
+
+    fname = 'pot_values'
+
+    if np.min(values) != 0.:
+        potmin = int( np.log10( np.abs(np.min(values)) ) )
+    else:
+        potmin = 0
+
+    if np.max(values) != 0.:
+        potmax = int( np.log10( np.abs(np.max(values)) ) )
+    else:
+        potmax = 0
+
+    if potmin * potmax > 9:
+        potval = -np.min([np.abs(potmin), np.abs(potmax)]) * np.abs(potmin) / potmin
+
+        newvalues = values*10.**potval
+        potvalue = - potval
+        potS = 'x10e' + str(potvalue)
+        newunits = potS + ' ' + uvals
+    else:
+        newvalues = values
+        potvalue = None
+        potS = ''
+        newunits = uvals
+
+    return newvalues, potvalue, newunits, potS
+
+def CFtimes_plot(timev,units,kind,tfmt):
+    """ Function to provide a list of string values from a CF time values in order 
+      to use them in a plot, according to the series of characteristics. 
+      String outputs will be suited to the 'human-like' output
+        timev= time values (real values)
+        units= units string according to CF conventions ([tunits] since 
+          [YYYY]-[MM]-[DD] [[HH]:[MI]:[SS]])
+        kind= kind of output
+          'Nval': according to a given number of values as 'Nval',[Nval]
+          'exct': according to an exact time unit as 'exct',[tunit]; 
+            tunit= [Nunits],[tu]; [tu]= 'c': centuries, 'y': year, 'm': month,
+              'w': week, 'd': day, 'h': hour, 'i': minute, 's': second, 
+              'l': milisecond
+        tfmt= desired format
+          >>> CFtimes_plot(np.arange(100)*1.,'hours since 1979-12-01 00:00:00', 'Nval,5',"%Y/%m/%d %H:%M:%S")
+            0.0 1979/12/01 00:00:00
+            24.75 1979/12/02 00:45:00
+            49.5 1979/12/03 01:30:00
+            74.25 1979/12/04 02:15:00
+            99.0 1979/12/05 03:00:00
+          >>> CFtimes_plot(np.arange(100)*1.,'hours since 1979-12-01 00:00:00', 'exct,2,d',"%Y/%m/%d %H:%M:%S")
+            0.0 1979/12/01 00:00:00
+            48.0 1979/12/03 00:00:00
+            96.0 1979/12/05 00:00:00
+            144.0 1979/12/07 00:00:00
+    """ 
+    import datetime as dt 
+
+# Seconds between 0001 and 1901 Jan - 01
+    secs0001_1901=59958144000.
+
+    fname = 'CFtimes_plot'
+
+    if timev == 'h':
+        print fname + '_____________________________________________________________'
+        print CFtimes_plot.__doc__
+        quit()
+
+# Does reference date contain a time value [YYYY]-[MM]-[DD] [HH]:[MI]:[SS]
+##
+    trefT = units.find(':')
+    txtunits = units.split(' ')
+    Ntxtunits = len(txtunits)
+
+    if Ntxtunits == 3:
+        Srefdate = txtunits[Ntxtunits - 1]
+    else:
+        Srefdate = txtunits[Ntxtunits - 2]
+
+    if not trefT == -1:
+#        print '  ' + fname + ': refdate with time!'
+        if Ntxtunits == 3:
+            refdate = datetimeStr_datetime(Srefdate)
+        else:
+            refdate = datetimeStr_datetime(Srefdate + '_' + txtunits[Ntxtunits - 1])
+    else:
+        refdate = datetimeStr_datetime(Srefdate + '_00:00:00')
+
+    trefunits=units.split(' ')[0]
+    if trefunits == 'weeks':
+        trefu = 'w'
+    elif trefunits == 'days':
+        trefu = 'd'
+    elif trefunits == 'hours':
+        trefu = 'h'
+    elif trefunits == 'minutes':
+        trefu = 'm'
+    elif trefunits == 'seconds':
+        trefu = 's'
+    elif trefunits == 'milliseconds':
+        trefu = 'l'
+    else:
+        print errormsg
+        print '  ' + fname + ': reference time units "' + trefu + '" not ready!!!!'
+        quit(-1)
+
+    okind=kind.split(',')[0]
+    dtv = len(timev)
+  
+    if refdate.year == 1:
+        print warnmsg
+        print '  ' + fname + ': changing reference date: ',refdate,                  \
+          'to 1901-01-01_00:00:00 !!!'
+        refdate = datetimeStr_datetime('1901-01-01_00:00:00')
+        if trefu == 'w': timev = timev - secs0001_1901/(7.*24.*3600.)
+        if trefu == 'd': timev = timev - secs0001_1901/(24.*3600.)
+        if trefu == 'h': timev = timev - secs0001_1901/(3600.)
+        if trefu == 'm': timev = timev - secs0001_1901/(60.)
+        if trefu == 's': timev = timev - secs0001_1901
+        if trefu == 'l': timev = timev - secs0001_1901*1000.
+
+    firstT = timev[0]
+    lastT = timev[dtv-1]
+
+# First and last times as datetime objects
+    firstTdt = timeref_datetime(refdate, firstT, trefunits)
+    lastTdt = timeref_datetime(refdate, lastT, trefunits)
+
+# First and last times as [year, mon, day, hour, minut, second] vectors
+    firstTvec = np.zeros((6), dtype= np.float)
+    lastTvec = np.zeros((6), dtype= np.float)
+    chTvec = np.zeros((6), dtype= bool)
+
+    firstTvec = np.array([firstTdt.year, firstTdt.month, firstTdt.day, firstTdt.hour,\
+      firstTdt.minute, firstTdt.second])
+    lastTvec = np.array([lastTdt.year, lastTdt.month, lastTdt.day, lastTdt.hour,     \
+      lastTdt.minute, lastTdt.second])
+
+    chdate= lastTvec - firstTvec
+    chTvec = np.where (chdate != 0., True, False)
+
+    timeout = []
+    if okind == 'Nval':
+        nvalues = int(kind.split(',')[1])
+        intervT = (lastT - firstT)/(nvalues-1)
+        dtintervT = intT2dt(intervT, trefu)
+
+        for it in range(nvalues):
+            timeout.append(firstTdt + dtintervT*it)
+    elif okind == 'exct':
+        Nunits = int(kind.split(',')[1])
+        tu = kind.split(',')[2]
+
+# Generic incremental dt [seconds] according to all the possibilities ['c', 'y', 'm',
+#   'w', 'd', 'h', 'i', 's', 'l'], some of them approximated (because they are not 
+#   already necessary!)
+        basedt = np.zeros((9), dtype=np.float)
+        basedt[0] = (365.*100. + 25.)*24.*3600.
+        basedt[1] = 365.*24.*3600.
+        basedt[2] = 31.*24.*3600.
+        basedt[3] = 7.*24.*3600.
+        basedt[4] = 24.*3600.
+        basedt[5] = 3600.
+        basedt[6] = 60.
+        basedt[7] = 1.
+        basedt[8] = 1000.
+
+# Increment according to the units of the CF dates
+        if trefunits == 'weeks':
+            basedt = basedt/(7.*24.*3600.)
+        elif trefunits == 'days':
+            basedt = basedt/(24.*3600.)
+        elif trefunits == 'hours':
+            basedt = basedt/(3600.)
+        elif trefunits == 'minutes':
+            basedt = basedt/(60.)
+        elif trefunits == 'seconds':
+            basedt = basedt
+        elif trefunits == 'milliseconds':
+            basedt = basedt*1000.
+
+        if tu == 'c':
+            ti = firstTvec[0]
+            tf = lastTvec[0] 
+            centi = firstTvec[0] / 100
+
+            for it in range((tf - ti)/(Nunits*100) + 1):
+                timeout.append(dt.datetime(centi+it*Nunits*100, 1, 1, 0, 0, 0))
+        elif tu == 'y':
+            ti = firstTvec[0]
+            tf = lastTvec[0]
+            yeari = firstTvec[0]
+
+            for it in range((tf - ti)/(Nunits) + 1):
+                timeout.append(dt.datetime(yeari+it*Nunits, 1, 1, 0, 0, 0))
+        elif tu == 'm':
+            ti = firstTvec[1]
+            tf = lastTvec[1]
+            yr = firstTvec[0]
+            mon = firstTvec[1]
+
+            for it in range((tf - ti)/(Nunits) + 1):
+                mon = mon+it*Nunits
+                if mon > 12:
+                    yr = yr + 1
+                    mon = 1
+
+                timeout.append(dt.datetime(yr, mon, 1, 0, 0, 0))
+        elif tu == 'w':
+            datev=firstTdt
+            it=0
+            while datev <= lastTdt:
+                datev = firstTdt + dt.timedelta(days=7*Nunits*it)
+                timeout.append(datev)
+                it = it + 1
+        elif tu == 'd':
+#            datev=firstTdt
+            yr = firstTvec[0]
+            mon = firstTvec[1]
+            day = firstTvec[2]
+
+            if np.sum(firstTvec[2:5]) > 0:
+                firstTdt = dt.datetime(yr, mon, day+1, 0, 0, 0)
+                datev = dt.datetime(yr, mon, day+1, 0, 0, 0)
+            else:
+                firstTdt = dt.datetime(yr, mon, day, 0, 0, 0)
+                datev = dt.datetime(yr, mon, day, 0, 0, 0)
+
+            it=0
+            while datev <= lastTdt:
+                datev = firstTdt + dt.timedelta(days=Nunits*it)
+                timeout.append(datev)
+                it = it + 1
+        elif tu == 'h':
+            datev=firstTdt
+            yr = firstTvec[0]
+            mon = firstTvec[1]
+            day = firstTvec[2]
+            hour = firstTvec[3]
+
+            if np.sum(firstTvec[4:5]) > 0 or np.mod(hour,Nunits) != 0:
+                tadvance = 2*Nunits
+                if tadvance >= 24:
+                    firstTdt = dt.datetime(yr, mon, day+1, 0, 0, 0)
+                    datev = dt.datetime(yr, mon, day+1, 0, 0, 0)
+                else:
+                    firstTdt = dt.datetime(yr, mon, day, Nunits, 0, 0)
+                    datev = dt.datetime(yr, mon, day, Nunits, 0, 0)
+            else:
+                firstTdt = dt.datetime(yr, mon, day, hour, 0, 0)
+                datev = dt.datetime(yr, mon, day, hour, 0, 0)
+
+            it=0
+            while datev <= lastTdt:
+                datev = firstTdt + dt.timedelta(seconds=Nunits*3600*it)
+                timeout.append(datev)
+                it = it + 1                 
+        elif tu == 'i':
+            datev=firstTdt
+            yr = firstTvec[0]
+            mon = firstTvec[1]
+            day = firstTvec[2]
+            hour = firstTvec[3]
+            minu = firstTvec[4]
+
+            if firstTvec[5] > 0 or np.mod(minu,Nunits) != 0:
+                tadvance = 2*Nunits
+                if tadvance >= 60:
+                    firstTdt = dt.datetime(yr, mon, day, hour, 0, 0)
+                    datev = dt.datetime(yr, mon, day, hour, 0, 0)
+                else:
+                    firstTdt = dt.datetime(yr, mon, day, hour, Nunits, 0)
+                    datev = dt.datetime(yr, mon, day, hour, Nunits, 0)
+            else:
+                firstTdt = dt.datetime(yr, mon, day, hour, minu, 0)
+                datev = dt.datetime(yr, mon, day, hour, minu, 0)
+            it=0
+            while datev <= lastTdt:
+                datev = firstTdt + dt.timedelta(seconds=Nunits*60*it)
+                timeout.append(datev)
+                it = it + 1                 
+        elif tu == 's':
+            datev=firstTdt
+            it=0
+            while datev <= lastTdt:
+                datev = firstTdt + dt.timedelta(seconds=Nunits)
+                timeout.append(datev)
+                it = it + 1                 
+        elif tu == 'l':
+            datev=firstTdt
+            it=0
+            while datev <= lastTdt:
+                datev = firstTdt + dt.timedelta(seconds=Nunits*it/1000.)
+                timeout.append(datev)
+                it = it + 1
+        else:
+            print errormsg
+            print '  '  + fname + ': exact units "' + tu + '" not ready!!!!!'
+            quit(-1)
+
+    else:
+        print errormsg
+        print '  ' + fname + ': output kind "' + okind + '" not ready!!!!'
+        quit(-1)
+
+    dtout = len(timeout)
+
+    timeoutS = []
+    timeoutv = np.zeros((dtout), dtype=np.float)
+
+    for it in range(dtout):
+        timeoutS.append(timeout[it].strftime(tfmt))
+        timeoutv[it] = date_CFtime(timeout[it], refdate, trefunits)
+       
+#        print it,':',timeoutv[it], timeoutS[it]
+
+    return timeoutv, timeoutS
+
+def color_lines(Nlines):
+    """ Function to provide a color list to plot lines
+    color_lines(Nlines)
+      Nlines= number of lines
+    """
+
+    fname = 'color_lines'
+
+    colors = ['r', 'b', 'g', 'p', 'g']
+
+    colorv = []
+
+    colorv.append('k')
+    for icol in range(Nlines):
+        colorv.append(colors[icol])
+
+
+    return colorv
+
+def output_kind(kindf, namef, close):
+    """ Function to generate the output of the figure
+      kindf= kind of the output 
+        null: show in screen
+        [jpg/pdf/png/ps]: standard output types
+      namef= name of the figure (without extension)
+      close= if the graph has to be close or not [True/False]
+    """
+    fname = 'output_kind'
+
+    if kindf == 'h':
+        print fname + '_____________________________________________________________'
+        print output_kind.__doc__
+        quit()
+
+    if kindf == 'null':
+        print 'showing figure...'
+        plt.show()
+    elif kindf == 'gif':
+        plt.savefig(namef + ".gif")
+        if close: print "Successfully generation of figure '" + namef + ".jpg' !!!"
+    elif kindf == 'jpg':
+        plt.savefig(namef + ".jpg")
+        if close: print "Successfully generation of figure '" + namef + ".jpg' !!!"
+    elif kindf == 'pdf':
+        plt.savefig(namef + ".pdf")
+        if close: print "Successfully generation of figure '" + namef + ".pdf' !!!"
+    elif kindf == 'png':
+        plt.savefig(namef + ".png")
+        if close: print "Successfully generation of figure '" + namef + ".png' !!!"
+    elif kindf == 'ps':
+        plt.savefig(namef + ".ps")
+        if close: print "Successfully generation of figure '" + namef + ".ps' !!!"
+    else:
+        print errormsg
+        print '  ' + fname + ' output format: "' + kindf + '" not ready !!'
+        print errormsg
+        quit(-1)
+
+    if close:
+        plt.close()
+
+    return
+
+def check_arguments(funcname,Nargs,args,char,expectargs):
+    """ Function to check the number of arguments if they are coincident
+    check_arguments(funcname,Nargs,args,char)
+      funcname= name of the function/program to check
+      Nargs= theoretical number of arguments
+      args= passed arguments
+      char= character used to split the arguments
+    """
+
+    fname = 'check_arguments'
+
+    Nvals = len(args.split(char))
+    if Nvals != Nargs:
+        print errormsg
+        print '  ' + fname + ': wrong number of arguments:',Nvals," passed to  '",   \
+          funcname, "' which requires:",Nargs,'!!'
+        print '    given arguments:',args.split(char)
+        print '    expected arguments:',expectargs
+        quit(-1)
+
+    return
+
+def Str_Bool(val):
+    """ Function to transform from a String value to a boolean one
+    >>> Str_Bool('True')
+    True
+    >>> Str_Bool('0')
+    False
+    >>> Str_Bool('no')
+    False
+    """
+
+    fname = 'Str_Bool'
+
+    if val == 'True' or val == '1' or val == 'yes': 
+        boolv = True
+    elif val == 'False' or val == '0' or val== 'no':
+        boolv = False
+    else:
+        print errormsg
+        print '  ' + fname + ": value '" + val + "' not ready!!"
+        quit(-1)
+
+    return boolv
+
+def plot_TimeSeries(valtimes, vunits, tunits, hfileout, vtit, ttit, tkind, tformat,  \
+  tit, linesn, lloc, kfig):
+    """ Function to draw time-series
+      valtimes= list of arrays to plot [vals1[1values, 1times], [...,valsM[Mvals,Mtimes]]) 
+      vunits= units of the values
+      tunits= units of the times
+      hfileout= header of the output figure. Final name: [hfileout]_[vtit].[kfig]
+      vtit= variable title to be used in the graph
+      ttit= time title to be used in the graph
+      tkind= kind of time values to appear in the x-axis
+        'Nval': according to a given number of values as 'Nval',[Nval]
+        'exct': according to an exact time unit as 'exct',[tunit]; 
+          tunit= [Nunits],[tu]; [tu]= 'c': centuries, 'y': year, 'm': month,
+            'w': week, 'd': day, 'h': hour, 'i': minute, 's': second, 
+            'l': milisecond
+      tformat= desired format of times
+      tit= title of the graph
+      linesn= list of values fot the legend
+      lloc= location of the legend (-1, autmoatic)
+        1: 'upper right', 2: 'upper left', 3: 'lower left', 4: 'lower right',
+        5: 'right', 6: 'center left', 7: 'center right', 8: 'lower center',
+        9: 'upper center', 10: 'center'
+      kfig= type of figure: jpg, png, pds, ps
+    """
+    fname = 'plot_TimeSeries'
+
+    if valtimes == 'h':
+        print fname + '_____________________________________________________________'
+        print plot_TimeSeries.__doc__
+        quit()
+
+
+# Canging line kinds every 7 lines (end of standard colors)
+    linekinds=['.-','x-','o-']
+
+    Nlines = len(valtimes)
+
+    Nvalues = []
+    Ntimes = []
+
+    for il in range(Nlines):
+        array = valtimes[il]
+
+        if Nlines == 1:
+            print warnmsg
+            print '  ' + fname + ': drawing only one line!'
+
+            Nvalues.append(array.shape[1])
+            Ntimes.append(array.shape[0])
+            tmin = np.min(array[1])
+            tmax = np.max(array[1])
+            vmin = np.min(array[0])
+            vmax = np.max(array[0])
+        else:
+            Nvalues.append(array.shape[1])
+            Ntimes.append(array.shape[0])
+            tmin = np.min(array[1,:])
+            tmax = np.max(array[1,:])
+            vmin = np.min(array[0,:])
+            vmax = np.max(array[0,:])
+
+        if il == 0:
+            xmin = tmin
+            xmax = tmax
+            ymin = vmin
+            ymax = vmax
+        else:
+            if tmin < xmin: xmin = tmin
+            if tmax > xmax: xmax = tmax
+            if vmin < ymin: ymin = vmin
+            if vmax > ymax: ymax = vmax
+
+    dx = np.max(Ntimes)
+    dy = np.min(Nvalues)
+
+    plt.rc('text', usetex=True)
+
+    print vtit
+    if vtit == 'ps':
+        plt.ylim(98000.,ymax)
+    else:
+        plt.ylim(ymin,ymax)
+
+    plt.xlim(xmin,xmax)
+#    print 'x lim:',xmin,xmax
+#    print 'y lim:',ymin,ymax
+
+    N7lines=0
+    for il in range(Nlines):
+        array = valtimes[il]
+        if vtit == 'ps':
+            array[0,:] = np.where(array[0,:] < 98000., None, array[0,:])
+        plt.plot(array[1,:],array[0,:], linekinds[N7lines], label= linesn[il])
+        if il == 6: N7lines = N7lines + 1
+
+    timevals = np.arange(xmin,xmax)*1.
+
+    tpos, tlabels = CFtimes_plot(timevals, tunits, tkind, tformat)
+
+    if len(tpos) > 10:
+        print warnmsg
+        print '  ' + fname + ': with "' + tkind + '" there are', len(tpos), 'xticks !'
+
+    plt.xticks(tpos, tlabels)
+#    plt.Axes.set_xticklabels(tlabels)
+
+    plt.legend(loc=lloc)
+    plt.xlabel(ttit)
+    plt.ylabel(vtit + " (" + vunits + ")")
+    plt.title(tit)
+
+    figname = hfileout + '_' + vtit
+    
+    output_kind(kfig, figname, True)
+
+    return
+
+#Nt = 50
+#Nlines = 3
+
+#vtvalsv = []
+
+#valsv = np.zeros((2,Nt), dtype=np.float)
+## First
+#valsv[0,:] = np.arange(Nt)
+#valsv[1,:] = np.arange(Nt)*180.
+#vtvalsv.append(valsv)
+#del(valsv)
+
+#valsv = np.zeros((2,Nt/2), dtype=np.float)
+## Second
+#valsv[0,:] = np.arange(Nt/2)
+#valsv[1,:] = np.arange(Nt/2)*180.*2.
+#vtvalsv.append(valsv)
+#del(valsv)
+
+#valsv = np.zeros((2,Nt/4), dtype=np.float)
+## Third
+#valsv[0,:] = np.arange(Nt/4)
+#valsv[1,:] = np.arange(Nt/4)*180.*4.
+#vtvalsv.append(valsv)
+#del(valsv)
+
+#varu='mm'
+#timeu='seconds'
+
+#title='test'
+#linesname = ['line 1', 'line 2', 'line 3']
+
+#plot_TimeSeries(vtvalsv, units_lunits(varu), timeu, 'test', 'vartest', 'time', title, linesname, 'png')
+#quit()
+
+def plot_points(xval, yval, ifile, vtit, kfig, mapv):
+    """ plotting points
+      [x/yval]: x,y values to plot
+      vn,vm= minmum and maximum values to plot
+      unit= units of the variable
+      ifile= name of the input file
+      vtit= title of the variable
+      kfig= kind of figure (jpg, pdf, png)
+      mapv= map characteristics: [proj],[res]
+        see full documentation: http://matplotlib.org/basemap/
+        [proj]: projection
+          * 'cyl', cilindric
+        [res]: resolution:
+          * 'c', crude
+          * 'l', low
+          * 'i', intermediate
+          * 'h', high
+          * 'f', full
+    """
+    fname = 'plot_points'
+
+    dx=xval.shape[0]
+    dy=yval.shape[0]
+
+    plt.rc('text', usetex=True)
+
+    if not mapv is None:
+        lon00 = np.where(xval[:] < 0., 360. + olon[:], olon[:])
+        lat00 = yval[:]
+        lon0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
+        lat0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
+
+        for iy in range(len(lat00)):
+            lon0[iy,:] = lon00
+        for ix in range(len(lon00)):
+            lat0[:,ix] = lat00
+
+        map_proj=mapv.split(',')[0]
+        map_res=mapv.split(',')[1]
+
+        nlon = lon0[0,0]
+        xlon = lon0[dy-1,dx-1]
+        nlat = lat0[0,0]
+        xlat = lat0[dy-1,dx-1]
+
+        lon2 = lon0[dy/2,dx/2]
+        lat2 = lat0[dy/2,dx/2]
+
+        print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:',     \
+          xlon, ',', xlat
+
+        if map_proj == 'cyl':
+            m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat,         \
+              urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+        elif map_proj == 'lcc':
+            m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
+              llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+
+        lons, lats = np.meshgrid(olon[:], olat[:])
+        lons = np.where(lons < 0., lons + 360., lons)
+
+        x,y = m(lons,lats)
+        plt.plot(x,y)
+
+        m.drawcoastlines()
+
+        meridians = pretty_int(nlon,xlon,5)
+        m.drawmeridians(meridians,labels=[True,False,False,True])
+
+        parallels = pretty_int(nlat,xlat,5)
+        m.drawparallels(parallels,labels=[False,True,True,False])
+    else:
+#        plt.xlim(0,dx-1)
+#        plt.ylim(0,dy-1)
+
+        plt.plot(xval, yval, '.')
+
+    figname = ifile.replace('.','_') + '_' + vtit
+    graphtit = vtit.replace('_','\_')
+
+    plt.title(graphtit)
+    
+    output_kind(kfig, figname, True)
+
+    return
+
+def plot_2Dfield(varv,dimn,colorbar,vn,vx,unit,olon,olat,ifile,vtit,zvalue,time,tk,  \
+   tkt,tobj,tvals,tind,kfig,mapv,reva):
+    """ Adding labels and other staff to the graph
+      varv= 2D values to plot
+      dimn= dimension names to plot
+      colorbar= name of the color bar to use
+      vn,vm= minmum and maximum values to plot
+      unit= units of the variable
+      olon,olat= longitude, latitude objects
+      ifile= name of the input file
+      vtit= title of the variable
+      zvalue= value on the z axis
+      time= value on the time axis
+      tk= kind of time (WRF)
+      tkt= kind of time taken
+      tobj= tim object 
+      tvals= values of the time variable
+      tind= time index
+      kfig= kind of figure (jpg, pdf, png)
+      mapv= map characteristics: [proj],[res]
+        see full documentation: http://matplotlib.org/basemap/
+        [proj]: projection
+          * 'cyl', cilindric
+        [res]: resolution:
+          * 'c', crude
+          * 'l', low
+          * 'i', intermediate
+          * 'h', high
+          * 'f', full
+      reva= reverse the axes (x-->y, y-->x)
+    """
+##    import matplotlib as mpl
+##    mpl.use('Agg')
+##    import matplotlib.pyplot as plt
+
+    if reva:
+        print '  reversing the axes of the figure (x-->y, y-->x)!!'
+        varv = np.transpose(varv)
+        dimn0 = []
+        dimn0.append(dimn[1] + '')
+        dimn0.append(dimn[0] + '')
+        dimn = dimn0
+
+    fname = 'plot_2Dfield'
+    dx=varv.shape[1]
+    dy=varv.shape[0]
+
+    plt.rc('text', usetex=True)
+#    plt.rc('font', family='serif')
+
+    if not mapv is None:
+        if len(olon[:].shape) == 3:
+            lon0 = np.where(olon[0,] < 0., 360. + olon[0,], olon[0,])
+            lat0 = olat[0,]
+        elif len(olon[:].shape) == 2:
+            lon0 = np.where(olon[:] < 0., 360. + olon[:], olon[:])
+            lat0 = olat[:]
+        elif len(olon[:].shape) == 1:
+            lon00 = np.where(olon[:] < 0., 360. + olon[:], olon[:])
+            lat00 = olat[:]
+            lon0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
+            lat0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
+
+            for iy in range(len(lat00)):
+                lon0[iy,:] = lon00
+            for ix in range(len(lon00)):
+                lat0[:,ix] = lat00
+
+        map_proj=mapv.split(',')[0]
+        map_res=mapv.split(',')[1]
+
+        nlon = lon0[0,0]
+        xlon = lon0[dy-1,dx-1]
+        nlat = lat0[0,0]
+        xlat = lat0[dy-1,dx-1]
+
+        lon2 = lon0[dy/2,dx/2]
+        lat2 = lat0[dy/2,dx/2]
+
+        print '    lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:', \
+          xlon, ',', xlat
+
+        if map_proj == 'cyl':
+            m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat,         \
+              urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+        elif map_proj == 'lcc':
+            m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
+              llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+
+        if len(olon[:].shape) == 1:
+            lons, lats = np.meshgrid(olon[:], olat[:])
+        else:
+            lons = olon[0,:]
+            lats = olat[:,0]
+ 
+        lons = np.where(lons < 0., lons + 360., lons)
+
+        x,y = m(lons,lats)
+        plt.pcolormesh(x,y,varv, cmap=plt.get_cmap(colorbar), vmin=vn, vmax=vx)
+        cbar = plt.colorbar()
+
+        m.drawcoastlines()
+#        if (nlon > 180. or xlon > 180.):
+#            nlon0 = nlon
+#            xlon0 = xlon
+#            if (nlon > 180.): nlon0 = nlon - 360.
+#            if (xlon > 180.): xlon0 = xlon - 360.
+#            meridians = pretty_int(nlon0,xlon0,5)           
+#            meridians = np.where(meridians < 0., meridians + 360., meridians)
+#        else:
+#            meridians = pretty_int(nlon,xlon,5)
+
+        meridians = pretty_int(nlon,xlon,5)
+
+        m.drawmeridians(meridians,labels=[True,False,False,True])
+        parallels = pretty_int(nlat,xlat,5)
+        m.drawparallels(parallels,labels=[False,True,True,False])
+
+    else:
+        plt.xlim(0,dx-1)
+        plt.ylim(0,dy-1)
+
+        plt.pcolormesh(varv, cmap=plt.get_cmap(colorbar), vmin=vn, vmax=vx)
+        cbar = plt.colorbar()
+
+        plt.xlabel(dimn[1].replace('_','\_'))
+        plt.ylabel(dimn[0].replace('_','\_'))
+
+# set the limits of the plot to the limits of the data
+#    plt.axis([x.min(), x.max(), y.min(), y.max()])
+
+#    plt.plot(varv)
+    cbar.set_label(unit)
+
+    figname = ifile.replace('.','_') + '_' + vtit
+    graphtit = vtit.replace('_','\_')
+
+    if zvalue != 'null':
+        graphtit = graphtit + ' at z= ' + zvalue
+        figname = figname + '_z' + zvalue
+    if tkt == 'tstep':
+        graphtit = graphtit + ' at time-step= ' + time.split(',')[1]
+        figname = figname + '_t' + time.split(',')[1].zfill(4)
+    elif tkt == 'CFdate':
+        graphtit = graphtit + ' at ' + tobj.strfmt("%Y%m%d%H%M%S")
+        figname = figname + '_t' + tobj.strfmt("%Y%m%d%H%M%S")
+
+    if tk == 'WRF':
+#        datev = str(timevals[timeind][0:9])
+        datev = tvals[tind][0] + tvals[tind][1] + tvals[tind][2] + \
+          timevals[timeind][3] + timevals[timeind][4] + timevals[timeind][5] +       \
+          timevals[timeind][6] + timevals[timeind][7] + timevals[timeind][8] +       \
+          timevals[timeind][9]
+#        timev = str(timevals[timeind][11:18])
+        timev = timevals[timeind][11] + timevals[timeind][12] +                      \
+          timevals[timeind][13] + timevals[timeind][14] + timevals[timeind][15] +    \
+          timevals[timeind][16] + timevals[timeind][17] + timevals[timeind][18]
+        graphtit = vtit.replace('_','\_') + ' (' + datev + ' ' + timev + ')'
+
+    plt.title(graphtit)
+    
+    output_kind(kfig, figname, True)
+
+    return
+
+def plot_2Dfield_easy(varv,dimxv,dimyv,dimn,colorbar,vn,vx,unit,ifile,vtit,kfig,reva):
+    """ Adding labels and other staff to the graph
+      varv= 2D values to plot
+      dim[x/y]v = values at the axes of x and y
+      dimn= dimension names to plot
+      colorbar= name of the color bar to use
+      vn,vm= minmum and maximum values to plot
+      unit= units of the variable
+      ifile= name of the input file
+      vtit= title of the variable
+      kfig= kind of figure (jpg, pdf, png)
+      reva= reverse the axes (x-->y, y-->x)
+    """
+##    import matplotlib as mpl
+##    mpl.use('Agg')
+##    import matplotlib.pyplot as plt
+    fname = 'plot_2Dfield'
+
+    if reva:
+        print '  reversing the axes of the figure (x-->y, y-->x)!!'
+        varv = np.transpose(varv)
+        dimn0 = []
+        dimn0.append(dimn[1] + '')
+        dimn0.append(dimn[0] + '')
+        dimn = dimn0
+        if len(dimyv.shape) == 2:
+            x = np.transpose(dimyv)
+        else:
+            if len(dimxv.shape) == 2:
+                ddx = len(dimyv)
+                ddy = dimxv.shape[1]
+            else:
+                ddx = len(dimyv)
+                ddy = len(dimxv)
+
+            x = np.zeros((ddy,ddx), dtype=np.float)
+            for j in range(ddy):
+                x[j,:] = dimyv
+
+        if len(dimxv.shape) == 2:
+            y = np.transpose(dimxv)
+        else:
+            if len(dimyv.shape) == 2:
+                ddx = dimyv.shape[0]
+                ddy = len(dimxv)
+            else:
+                ddx = len(dimyv)
+                ddy = len(dimxv)
+
+            y = np.zeros((ddy,ddx), dtype=np.float)
+            for i in range(ddx):
+                y[:,i] = dimxv
+    else:
+        if len(dimxv.shape) == 2:
+            x = dimxv
+        else:
+            x = np.zeros((len(dimyv),len(dimxv)), dtype=np.float)
+            for j in range(len(dimyv)):
+                x[j,:] = dimxv
+
+        if len(dimyv.shape) == 2:
+            y = dimyv
+        else:
+            y = np.zeros((len(dimyv),len(dimxv)), dtype=np.float)
+            for i in range(len(dimxv)):
+                x[:,i] = dimyv
+
+    dx=varv.shape[1]
+    dy=varv.shape[0]
+
+    plt.rc('text', usetex=True)
+    plt.xlim(0,dx-1)
+    plt.ylim(0,dy-1)
+
+    plt.pcolormesh(x, y, varv, cmap=plt.get_cmap(colorbar), vmin=vn, vmax=vx)
+#    plt.pcolormesh(varv, cmap=plt.get_cmap(colorbar), vmin=vn, vmax=vx)
+    cbar = plt.colorbar()
+
+    plt.xlabel(dimn[1].replace('_','\_'))
+    plt.ylabel(dimn[0].replace('_','\_'))
+
+# set the limits of the plot to the limits of the data
+    plt.axis([x.min(), x.max(), y.min(), y.max()])
+#    if varv.shape[1] / varv.shape[0] > 10:
+#        plt.axes().set_aspect(0.001)
+#    else:
+#        plt.axes().set_aspect(np.float(varv.shape[0])/np.float(varv.shape[1]))
+
+    cbar.set_label(unit)
+
+    figname = ifile.replace('.','_') + '_' + vtit
+    graphtit = vtit.replace('_','\_')
+
+    plt.title(graphtit)
+
+    output_kind(kfig, figname, True)
+    
+    return
+
+def plot_Trajectories(lonval, latval, linesn, olon, olat, lonlatLims, gtit, kfig,    \
+  mapv, obsname):
+    """ plotting points
+      [lon/latval]= lon,lat values to plot (as list of vectors)
+      linesn: name of the lines
+      o[lon/lat]= object with the longitudes and the latitudes of the map to plot
+      lonlatLims: limits of longitudes and latitudes [lonmin, latmin, lonmax, latmax]
+      gtit= title of the graph
+      kfig= kind of figure (jpg, pdf, png)
+      mapv= map characteristics: [proj],[res]
+        see full documentation: http://matplotlib.org/basemap/
+        [proj]: projection
+          * 'cyl', cilindric
+          * 'lcc', lambert conformal
+        [res]: resolution:
+          * 'c', crude
+          * 'l', low
+          * 'i', intermediate
+          * 'h', high
+          * 'f', full
+      obsname= name of the observations in graph (can be None for without). 
+        Observational trajectory would be the last one
+    """
+    fname = 'plot_Trajectories'
+
+    if lonval == 'h':
+        print fname + '_____________________________________________________________'
+        print plot_Trajectories.__doc__
+        quit()
+
+# Canging line kinds every 7 lines (end of standard colors)
+    linekinds=['.-','x-','o-']
+
+    Ntraj = len(lonval)
+
+    if obsname is not None:
+        Ntraj = Ntraj - 1
+
+    N7lines = 0
+
+    plt.rc('text', usetex=True)
+
+    if not mapv is None:
+        if len(olon[:].shape) == 3:
+#            lon0 = np.where(olon[0,] < 0., 360. + olon[0,], olon[0,])
+            lon0 = olon[0,]
+            lat0 = olat[0,]
+        elif len(olon[:].shape) == 2:
+#            lon0 = np.where(olon[:] < 0., 360. + olon[:], olon[:])
+            lon0 = olon[:]
+            lat0 = olat[:]
+        elif len(olon[:].shape) == 1:
+#            lon00 = np.where(olon[:] < 0., 360. + olon[:], olon[:])
+            lon00 = olon[:]
+            lat00 = olat[:]
+            lon0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
+            lat0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
+
+            for iy in range(len(lat00)):
+                lon0[iy,:] = lon00
+            for ix in range(len(lon00)):
+                lat0[:,ix] = lat00
+
+        map_proj=mapv.split(',')[0]
+        map_res=mapv.split(',')[1]
+
+        dx = lon0.shape[1]
+        dy = lon0.shape[0]
+
+        nlon = lon0[0,0]
+        xlon = lon0[dy-1,dx-1]
+        nlat = lat0[0,0]
+        xlat = lat0[dy-1,dx-1]
+
+        lon2 = lon0[dy/2,dx/2]
+        lat2 = lat0[dy/2,dx/2]
+
+        if lonlatLims is not None:
+            plt.xlim(lonlatLims[0], lonlatLims[2])
+            plt.ylim(lonlatLims[1], lonlatLims[3])
+            if map_proj == 'cyl':
+                nlon = lonlatLims[0]
+                nlat = lonlatLims[1]
+                xlon = lonlatLims[2]
+                xlat = lonlatLims[3]
+
+        print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:',     \
+          xlon, ',', xlat
+
+        if map_proj == 'cyl':
+            m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat,         \
+              urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+        elif map_proj == 'lcc':
+            m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
+              llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+
+        if len(olon.shape) == 3:
+#            lons, lats = np.meshgrid(olon[0,:,:], olat[0,:,:])
+            lons = olon[0,:,:]
+            lats = olat[0,:,:]
+
+        elif len(olon.shape) == 2:
+#            lons, lats = np.meshgrid(olon[:,:], olat[:,:])
+            lons = olon[:,:]
+            lats = olat[:,:]
+        else:
+            print errormsg
+            print '  ' + fname + ': shapes of lon/lat objects', olon.shape,          \
+              'not ready!!!'
+
+        for il in range(Ntraj):
+            plt.plot(lonval[il], latval[il], linekinds[N7lines], label= linesn[il])
+            if il == 6: N7lines = N7lines + 1
+
+        m.drawcoastlines()
+
+        meridians = pretty_int(nlon,xlon,5)
+        m.drawmeridians(meridians,labels=[True,False,False,True])
+
+        parallels = pretty_int(nlat,xlat,5)
+        m.drawparallels(parallels,labels=[False,True,True,False])
+
+        plt.xlabel('W-E')
+        plt.ylabel('S-N')
+
+    else:
+        if len(olon.shape) == 3:
+            dx = olon.shape[2]
+            dy = olon.shape[1]
+        elif len(olon.shape) == 2:
+            dx = olon.shape[1]
+            dy = olon.shape[0]
+        else:
+            print errormsg
+            print '  ' + fname + ': shapes of lon/lat objects', olon.shape,          \
+              'not ready!!!'
+
+        if lonlatLims is not None:
+            plt.xlim(lonlatLims[0], lonlatLims[2])
+            plt.ylim(lonlatLims[1], lonlatLims[3])
+        else:
+            plt.xlim(np.min(olon[:]),np.max(olon[:]))
+            plt.ylim(np.min(olat[:]),np.max(olat[:]))
+
+        for il in range(Ntraj):
+            plt.plot(lonval[il], latval[il], linekinds[N7lines], label= linesn[il])
+            if il == 6: N7lines = N7lines + 1
+
+        plt.xlabel('x-axis')
+        plt.ylabel('y-axis')
+
+    figname = 'trajectories'
+    graphtit = gtit
+
+    if obsname is not None:
+        plt.plot(lonval[Ntraj], latval[Ntraj], linestyle='-', color='k',             \
+          linewidth=3, label= obsname)
+
+    plt.title(graphtit)
+    plt.legend()
+    
+    output_kind(kfig, figname, True)
+
+    return
+
+def plot_topo_geogrid(varv, olon, olat, mint, maxt, lonlatLims, gtit, kfig, mapv,    \
+  closeif):
+    """ plotting geo_em.d[nn].nc topography from WPS files
+    plot_topo_geogrid(domf, mint, maxt, gtit, kfig, mapv)
+      varv= topography values
+      o[lon/lat]= longitude and latitude objects
+      [min/max]t: minimum and maximum values of topography to draw
+      lonlatLims: limits of longitudes and latitudes [lonmin, latmin, lonmax, latmax]
+      gtit= title of the graph
+      kfig= kind of figure (jpg, pdf, png)
+      mapv= map characteristics: [proj],[res]
+        see full documentation: http://matplotlib.org/basemap/
+        [proj]: projection
+          * 'cyl', cilindric
+          * 'lcc', lamvbert conformal
+        [res]: resolution:
+          * 'c', crude
+          * 'l', low
+          * 'i', intermediate
+          * 'h', high
+          * 'f', full
+      closeif= Boolean value if the figure has to be closed
+    """
+    fname = 'plot_topo_geogrid'
+
+    if varv == 'h':
+        print fname + '_____________________________________________________________'
+        print plot_topo_geogrid.__doc__
+        quit()
+
+    dx=varv.shape[1]
+    dy=varv.shape[0]
+
+    plt.rc('text', usetex=True)
+#    plt.rc('font', family='serif')
+
+    if not mapv is None:
+        if len(olon[:].shape) == 3:
+            lon0 = olon[0,]
+            lat0 = olat[0,]
+        elif len(olon[:].shape) == 2:
+            lon0 = olon[:]
+            lat0 = olat[:]
+        elif len(olon[:].shape) == 1:
+            lon00 = olon[:]
+            lat00 = olat[:]
+            lon0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
+            lat0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
+
+            for iy in range(len(lat00)):
+                lon0[iy,:] = lon00
+            for ix in range(len(lon00)):
+                lat0[:,ix] = lat00
+
+        map_proj=mapv.split(',')[0]
+        map_res=mapv.split(',')[1]
+        dx = lon0.shape[1]
+        dy = lon0.shape[0]
+
+        if lonlatLims is not None:
+            print '  ' + fname + ': cutting the domain to plot !!!!'
+            print '    limits: W-E', lonlatLims[0], lonlatLims[2]
+            print '    limits: N-S', lonlatLims[1], lonlatLims[3]
+            nlon =  lonlatLims[0]
+            xlon =  lonlatLims[2]
+            nlat =  lonlatLims[1]
+            xlat =  lonlatLims[3]
+
+            if map_proj == 'lcc':
+                lon2 = (lonlatLims[0] + lonlatLims[2])/2.
+                lat2 = (lonlatLims[1] + lonlatLims[3])/2.
+        else:
+            nlon = lon0[0,0]
+            xlon = lon0[dy-1,dx-1]
+            nlat = lat0[0,0]
+            xlat = lat0[dy-1,dx-1]
+            lon2 = lon0[dy/2,dx/2]
+            lat2 = lat0[dy/2,dx/2]
+
+        plt.xlim(nlon, xlon)
+        plt.ylim(nlat, xlat)
+        print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:',     \
+          xlon, ',', xlat
+
+        if map_proj == 'cyl':
+            m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat,         \
+              urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+        elif map_proj == 'lcc':
+            m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
+              llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+        else:
+            print errormsg
+            print '  ' + fname + ": map projection '" + map_proj + "' not ready !!"
+            quit(-1)
+
+        if len(olon[:].shape) == 1:
+            lons, lats = np.meshgrid(olon[:], olat[:])
+        else:
+            if len(olon[:].shape) == 3:
+                lons = olon[0,:,:]
+                lats = olat[0,:,:]
+            else:
+                lons = olon[:]
+                lats = olat[:]
+ 
+        x,y = m(lons,lats)
+
+        plt.pcolormesh(x,y,varv, cmap=plt.get_cmap('terrain'), vmin=mint, vmax=maxt)
+        cbar = plt.colorbar()
+
+        m.drawcoastlines()
+
+        meridians = pretty_int(nlon,xlon,5)
+        m.drawmeridians(meridians,labels=[True,False,False,True])
+
+        parallels = pretty_int(nlat,xlat,5)
+        m.drawparallels(parallels,labels=[False,True,True,False])
+
+        plt.xlabel('W-E')
+        plt.ylabel('S-N')
+    else:
+        print emsg
+        print '  ' + fname + ': A projection parameter is needed None given !!'
+        quit(-1)    
+
+    figname = 'domain'
+    graphtit = gtit.replace('_','\_')
+    cbar.set_label('height ($m$)')
+
+    plt.title(graphtit)
+    
+    output_kind(kfig, figname, closeif)
+
+    return
+
+def plot_topo_geogrid_boxes(varv, boxesX, boxesY, boxlabels, olon, olat, mint, maxt, \
+  lonlatLims, gtit, kfig, mapv, closeif):
+    """ plotting geo_em.d[nn].nc topography from WPS files
+    plot_topo_geogrid(domf, mint, maxt, gtit, kfig, mapv)
+      varv= topography values
+      boxesX/Y= 4-line sets to draw the boxes
+      boxlabels= labels for the legend of the boxes
+      o[lon/lat]= longitude and latitude objects
+      [min/max]t: minimum and maximum values of topography to draw
+      lonlatLims: limits of longitudes and latitudes [lonmin, latmin, lonmax, latmax]
+      gtit= title of the graph
+      kfig= kind of figure (jpg, pdf, png)
+      mapv= map characteristics: [proj],[res]
+        see full documentation: http://matplotlib.org/basemap/
+        [proj]: projection
+          * 'cyl', cilindric
+          * 'lcc', lamvbert conformal
+        [res]: resolution:
+          * 'c', crude
+          * 'l', low
+          * 'i', intermediate
+          * 'h', high
+          * 'f', full
+      closeif= Boolean value if the figure has to be closed
+    """
+    fname = 'plot_topo_geogrid'
+
+    if varv == 'h':
+        print fname + '_____________________________________________________________'
+        print plot_topo_geogrid.__doc__
+        quit()
+
+    cols = color_lines(len(boxlabels))
+
+    dx=varv.shape[1]
+    dy=varv.shape[0]
+
+    plt.rc('text', usetex=True)
+#    plt.rc('font', family='serif')
+
+    if not mapv is None:
+        if len(olon[:].shape) == 3:
+            lon0 = olon[0,]
+            lat0 = olat[0,]
+        elif len(olon[:].shape) == 2:
+            lon0 = olon[:]
+            lat0 = olat[:]
+        elif len(olon[:].shape) == 1:
+            lon00 = olon[:]
+            lat00 = olat[:]
+            lon0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
+            lat0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
+
+            for iy in range(len(lat00)):
+                lon0[iy,:] = lon00
+            for ix in range(len(lon00)):
+                lat0[:,ix] = lat00
+
+        map_proj=mapv.split(',')[0]
+        map_res=mapv.split(',')[1]
+        dx = lon0.shape[1]
+        dy = lon0.shape[0]
+
+        if lonlatLims is not None:
+            print '  ' + fname + ': cutting the domain to plot !!!!'
+            print '    limits: W-E', lonlatLims[0], lonlatLims[2]
+            print '    limits: N-S', lonlatLims[1], lonlatLims[3]
+            nlon =  lonlatLims[0]
+            xlon =  lonlatLims[2]
+            nlat =  lonlatLims[1]
+            xlat =  lonlatLims[3]
+
+            if map_proj == 'lcc':
+                lon2 = (lonlatLims[0] + lonlatLims[2])/2.
+                lat2 = (lonlatLims[1] + lonlatLims[3])/2.
+        else:
+            nlon = np.min(lon0)
+            xlon = np.max(lon0)
+            nlat = np.min(lat0)
+            xlat = np.max(lat0)
+            lon2 = lon0[dy/2,dx/2]
+            lat2 = lat0[dy/2,dx/2]
+
+        plt.xlim(nlon, xlon)
+        plt.ylim(nlat, xlat)
+        print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:',     \
+          xlon, ',', xlat
+
+        if map_proj == 'cyl':
+            m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat,         \
+              urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+        elif map_proj == 'lcc':
+            m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
+              llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+
+        if len(olon[:].shape) == 1:
+            lons, lats = np.meshgrid(olon[:], olat[:])
+        else:
+            if len(olon[:].shape) == 3:
+                lons = olon[0,:,:]
+                lats = olat[0,:,:]
+            else:
+                lons = olon[:]
+                lats = olat[:]
+ 
+        x,y = m(lons,lats)
+
+        plt.pcolormesh(x,y,varv, cmap=plt.get_cmap('terrain'), vmin=mint, vmax=maxt)
+        cbar = plt.colorbar()
+
+        Nboxes = len(boxesX)/4
+        for ibox in range(Nboxes):
+            plt.plot(boxesX[ibox*4], boxesY[ibox*4], linestyle='-', linewidth=3,     \
+              label=boxlabels[ibox], color=cols[ibox])
+            plt.plot(boxesX[ibox*4+1], boxesY[ibox*4+1], linestyle='-', linewidth=3, \
+              color=cols[ibox])
+            plt.plot(boxesX[ibox*4+2], boxesY[ibox*4+2], linestyle='-', linewidth=3, \
+              color=cols[ibox])
+            plt.plot(boxesX[ibox*4+3], boxesY[ibox*4+3], linestyle='-', linewidth=3, \
+              color=cols[ibox])
+
+        m.drawcoastlines()
+
+        meridians = pretty_int(nlon,xlon,5)
+        m.drawmeridians(meridians,labels=[True,False,False,True])
+
+        parallels = pretty_int(nlat,xlat,5)
+        m.drawparallels(parallels,labels=[False,True,True,False])
+
+        plt.xlabel('W-E')
+        plt.ylabel('S-N')
+    else:
+        print emsg
+        print '  ' + fname + ': A projection parameter is needed None given !!'
+        quit(-1)    
+
+    figname = 'domain_boxes'
+    graphtit = gtit.replace('_','\_')
+    cbar.set_label('height ($m$)')
+
+    plt.title(graphtit)
+    plt.legend()
+    
+    output_kind(kfig, figname, closeif)
+
+    return
+
+def plot_2D_shadow(varsv,vnames,dimxv,dimyv,dimxu,dimyu,dimn,          \
+  colorbar,vs,uts,vtit,kfig,reva,mapv,ifclose):
+    """ Adding labels and other staff to the graph
+      varsv= 2D values to plot with shading
+      vnames= variable names for the figure
+      dim[x/y]v = values at the axes of x and y
+      dim[x/y]u = units at the axes of x and y
+      dimn= dimension names to plot
+      colorbar= name of the color bar to use
+      vs= minmum and maximum values to plot in shadow or:
+        'Srange': for full range
+        'Saroundmean@val': for mean-xtrm,mean+xtrm where xtrm = np.min(mean-min@val,max@val-mean)
+        'Saroundminmax@val': for min*val,max*val
+        'Saroundpercentile@val': for median-xtrm,median+xtrm where xtrm = np.min(median-percentile_(val),
+          percentile_(100-val)-median)
+        'Smean@val': for -xtrm,xtrm where xtrm = np.min(mean-min*@val,max*@val-mean)
+        'Smedian@val': for -xtrm,xtrm where xtrm = np.min(median-min@val,max@val-median)
+        'Spercentile@val': for -xtrm,xtrm where xtrm = np.min(median-percentile_(val),
+           percentile_(100-val)-median)
+      uts= units of the variable to shadow
+      vtit= title of the variable
+      kfig= kind of figure (jpg, pdf, png)
+      reva= ('|' for combination)
+        * 'transpose': reverse the axes (x-->y, y-->x)
+        * 'flip'@[x/y]: flip the axis x or y
+      mapv= map characteristics: [proj],[res]
+        see full documentation: http://matplotlib.org/basemap/
+        [proj]: projection
+          * 'cyl', cilindric
+          * 'lcc', lambert conformal
+        [res]: resolution:
+          * 'c', crude
+          * 'l', low
+          * 'i', intermediate
+          * 'h', high
+          * 'f', full
+      ifclose= boolean value whether figure should be close (finish) or not
+    """
+##    import matplotlib as mpl
+##    mpl.use('Agg')
+##    import matplotlib.pyplot as plt
+    fname = 'plot_2D_shadow'
+
+#    print dimyv[73,21]
+#    dimyv[73,21] = -dimyv[73,21]
+#    print 'Lluis dimsv: ',np.min(dimxv), np.max(dimxv), ':', np.min(dimyv), np.max(dimyv)
+
+    if varsv == 'h':
+        print fname + '_____________________________________________________________'
+        print plot_2D_shadow.__doc__
+        quit()
+
+    if len(varsv.shape) != 2:
+        print errormsg
+        print '  ' + fname + ': wrong variable shape:',varv.shape,'is has to be 2D!!'
+        quit(-1)
+
+    reva0 = ''
+    if reva.find('|') != 0:
+        revas = reva.split('|')
+    else:
+        revas = [reva]
+        reva0 = reva
+
+    for rev in revas:
+        if reva[0:4] == 'flip':
+            reva0 = 'flip'
+            if len(reva.split('@')) != 2:
+                 print errormsg
+                 print '  ' + fname + ': flip is given', reva, 'but not axis!'
+                 quit(-1)
+
+        if rev == 'transpose':
+            print '  reversing the axes of the figure (x-->y, y-->x)!!'
+            varsv = np.transpose(varsv)
+            dxv = dimyv
+            dyv = dimxv
+            dimxv = dxv
+            dimyv = dyv
+
+    if len(dimxv[:].shape) == 3:
+        xdims = '1,2'
+    elif len(dimxv[:].shape) == 2:
+        xdims = '0,1'
+    elif len(dimxv[:].shape) == 1:
+        xdims = '0'
+
+    if len(dimyv[:].shape) == 3:
+        ydims = '1,2'
+    elif len(dimyv[:].shape) == 2:
+        ydims = '0,1'
+    elif len(dimyv[:].shape) == 1:
+        ydims = '0'
+
+    lon0, lat0 = dxdy_lonlat(dimxv,dimyv, xdims, ydims)
+
+    if not mapv is None:
+        map_proj=mapv.split(',')[0]
+        map_res=mapv.split(',')[1]
+
+        dx = lon0.shape[1]
+        dy = lat0.shape[0]
+
+        nlon = lon0[0,0]
+        xlon = lon0[dy-1,dx-1]
+        nlat = lat0[0,0]
+        xlat = lat0[dy-1,dx-1]
+
+# Thats too much! :)
+#        if lonlatLims is not None:
+#            print '  ' + fname + ': cutting the domain to plot !!!!'
+#            plt.xlim(lonlatLims[0], lonlatLims[2])
+#            plt.ylim(lonlatLims[1], lonlatLims[3])
+#            print '    limits: W-E', lonlatLims[0], lonlatLims[2]
+#            print '    limits: N-S', lonlatLims[1], lonlatLims[3]
+
+#            if map_proj == 'cyl':
+#                nlon = lonlatLims[0]
+#                nlat = lonlatLims[1]
+#                xlon = lonlatLims[2]
+#                xlat = lonlatLims[3]
+#            elif map_proj == 'lcc':
+#                lon2 = (lonlatLims[0] + lonlatLims[2])/2.
+#                lat2 = (lonlatLims[1] + lonlatLims[3])/2.
+#                nlon =  lonlatLims[0]
+#                xlon =  lonlatLims[2]
+#                nlat =  lonlatLims[1]
+#                xlat =  lonlatLims[3]
+
+        lon2 = lon0[dy/2,dx/2]
+        lat2 = lat0[dy/2,dx/2]
+
+        print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:',     \
+          xlon, ',', xlat
+
+        if map_proj == 'cyl':
+            m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat,         \
+              urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+        elif map_proj == 'lcc':
+            m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
+              llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+        else:
+            print errormsg
+            print '  ' + fname + ": map projection '" + map_proj + "' not defined!!!"
+            print '    available: cyl, lcc'
+            quit(-1)
+ 
+        x,y = m(lon0,lat0)
+
+    else:
+        x = lon0
+        y = lat0
+
+    vsend = np.zeros((2), dtype=np.float)
+# Changing limits of the colors
+    if type(vs[0]) != type(np.float(1.)):
+        if vs[0] == 'Srange':
+            vsend[0] = np.min(varsv)
+        elif vs[0][0:11] == 'Saroundmean':
+            meanv = np.mean(varsv)
+            permean = np.float(vs[0].split('@')[1])
+            minv = np.min(varsv)*permean
+            maxv = np.max(varsv)*permean
+            minextrm = np.min([np.abs(meanv-minv), np.abs(maxv-meanv)])
+            vsend[0] = meanv-minextrm
+            vsend[1] = meanv+minextrm
+        elif vs[0][0:13] == 'Saroundminmax':
+            permean = np.float(vs[0].split('@')[1])
+            minv = np.min(varsv)*permean
+            maxv = np.max(varsv)*permean
+            vsend[0] = minv
+            vsend[1] = maxv
+        elif vs[0][0:17] == 'Saroundpercentile':
+            medianv = np.median(varsv)
+            valper = np.float(vs[0].split('@')[1])
+            minv = np.percentile(varsv, valper)
+            maxv = np.percentile(varsv, 100.-valper)
+            minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
+            vsend[0] = medianv-minextrm
+            vsend[1] = medianv+minextrm
+        elif vs[0][0:5] == 'Smean':
+            meanv = np.mean(varsv)
+            permean = np.float(vs[0].split('@')[1])
+            minv = np.min(varsv)*permean
+            maxv = np.max(varsv)*permean
+            minextrm = np.min([np.abs(meanv-minv), np.abs(maxv-meanv)])
+            vsend[0] = -minextrm
+            vsend[1] = minextrm
+        elif vs[0][0:7] == 'Smedian':
+            medianv = np.median(varsv)
+            permedian = np.float(vs[0].split('@')[1])
+            minv = np.min(varsv)*permedian
+            maxv = np.max(varsv)*permedian
+            minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
+            vsend[0] = -minextrm
+            vsend[1] = minextrm
+        elif vs[0][0:11] == 'Spercentile':
+            medianv = np.median(varsv)
+            valper = np.float(vs[0].split('@')[1])
+            minv = np.percentile(varsv, valper)
+            maxv = np.percentile(varsv, 100.-valper)
+            minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
+            vsend[0] = -minextrm
+            vsend[1] = minextrm
+        else:
+            print errormsg
+            print '  ' + fname + ": range '" + vs[0] + "' not ready!!!"
+            quit(-1)
+        print '    ' + fname + ': modified shadow min,max:',vsend
+    else:
+        vsend[0] = vs[0]
+
+    if type(vs[0]) != type(np.float(1.)):
+        if vs[1] == 'range':
+            vsend[1] = np.max(varsv)
+    else:
+        vsend[1] = vs[1]
+
+    plt.rc('text', usetex=True)
+
+    plt.pcolormesh(x, y, varsv, cmap=plt.get_cmap(colorbar), vmin=vsend[0], vmax=vsend[1])
+    cbar = plt.colorbar()
+
+    if not mapv is None:
+        m.drawcoastlines()
+
+        meridians = pretty_int(nlon,xlon,5)
+        m.drawmeridians(meridians,labels=[True,False,False,True])
+        parallels = pretty_int(nlat,xlat,5)
+        m.drawparallels(parallels,labels=[False,True,True,False])
+
+        plt.xlabel('W-E')
+        plt.ylabel('S-N')
+    else:
+        plt.xlabel(variables_values(dimn[1])[0].replace('_','\_') + ' (' +           \
+          units_lunits(dimxu) + ')')
+        plt.ylabel(variables_values(dimn[0])[0].replace('_','\_') + ' (' +           \
+          units_lunits(dimyu) + ')')
+
+    txpos = pretty_int(x.min(),x.max(),5)
+    typos = pretty_int(y.min(),y.max(),5)
+    txlabels = list(txpos)
+    for i in range(len(txlabels)): txlabels[i] = str(txlabels[i])
+    tylabels = list(typos)
+    for i in range(len(tylabels)): tylabels[i] = str(tylabels[i])
+
+# set the limits of the plot to the limits of the data
+
+    if searchInlist(revas,'transpose'):
+        x0 = y
+        y0 = x
+        x = x0
+        y = y0
+#    print 'Lluis reva0:',reva0,'x min,max:',x.min(),x.max(),' y min,max:',y.min(),y.max()
+
+    if reva0 == 'flip':
+        if reva.split('@')[1] == 'x':
+            plt.axis([x.max(), x.min(), y.min(), y.max()])
+        elif reva.split('@')[1] == 'y':
+            plt.axis([x.min(), x.max(), y.max(), y.min()])
+        else:
+            plt.axis([x.max(), x.min(), y.max(), y.min()])
+    else:
+        plt.axis([x.min(), x.max(), y.min(), y.max()])
+
+    if mapv is None:
+        plt.xticks(txpos, txlabels)
+        plt.yticks(typos, tylabels)
+
+# units labels
+    cbar.set_label(vnames.replace('_','\_') + ' (' + units_lunits(uts) + ')')
+
+    figname = '2Dfields_shadow'
+    graphtit = vtit.replace('_','\_').replace('&','\&')
+
+    plt.title(graphtit)
+    
+    output_kind(kfig, figname, ifclose)
+
+    return
+
+#Nvals=50
+#vals1 = np.zeros((Nvals,Nvals), dtype= np.float)
+#for j in range(Nvals):
+#    for i in range(Nvals):
+#      vals1[j,i]=np.sqrt((j-Nvals/2)**2. + (i-Nvals/2)**2.)
+
+#plot_2D_shadow(vals1, 'var1', np.arange(50)*1., np.arange(50)*1., 'ms-1',            \
+#  'm', ['lat','lon'], 'rainbow', [0, Nvals], 'ms-1', 'test var1', 'pdf', 'None',     \
+#  None, True)
+#quit()
+
+def plot_2D_shadow_time(varsv,vnames,dimxv,dimyv,dimxu,dimyu,dimn,colorbar,vs,uts,   \
+  vtit,kfig,reva,taxis,tpos,tlabs,ifclose):
+    """ Plotting a 2D field with one of the axes being time
+      varsv= 2D values to plot with shading
+      vnames= shading variable name for the figure
+      dim[x/y]v= values at the axes of x and y
+      dim[x/y]u= units at the axes of x and y
+      dimn= dimension names to plot
+      colorbar= name of the color bar to use
+      vs= minmum and maximum values to plot in shadow or:
+        'Srange': for full range
+        'Saroundmean@val': for mean-xtrm,mean+xtrm where xtrm = np.min(mean-min@val,max@val-mean)
+        'Saroundminmax@val': for min*val,max*val
+        'Saroundpercentile@val': for median-xtrm,median+xtrm where xtrm = np.min(median-percentile_(val),
+          percentile_(100-val)-median)
+        'Smean@val': for -xtrm,xtrm where xtrm = np.min(mean-min*@val,max*@val-mean)
+        'Smedian@val': for -xtrm,xtrm where xtrm = np.min(median-min@val,max@val-median)
+        'Spercentile@val': for -xtrm,xtrm where xtrm = np.min(median-percentile_(val),
+           percentile_(100-val)-median)
+      uts= units of the variable to shadow
+      vtit= title of the variable
+      kfig= kind of figure (jpg, pdf, png)
+      reva= 
+        * 'transpose': reverse the axes (x-->y, y-->x)
+        * 'flip'@[x/y]: flip the axis x or y
+      taxis= Which is the time-axis 
+      tpos= positions of the time ticks
+      tlabs= labels of the time ticks
+      ifclose= boolean value whether figure should be close (finish) or not
+    """
+    fname = 'plot_2D_shadow_time'
+
+    if varsv == 'h':
+        print fname + '_____________________________________________________________'
+        print plot_2D_shadow_time.__doc__
+        quit()
+
+# Definning ticks labels
+    if taxis == 'x':
+        txpos = tpos
+        txlabels = tlabs
+        plxlabel = dimxu
+        typos = pretty_int(np.min(dimyv),np.max(dimyv),10)
+        tylabels = list(typos)
+        for i in range(len(tylabels)): tylabels[i] = str(tylabels[i])
+        plylabel = variables_values(dimn[0])[0].replace('_','\_') + ' (' +           \
+          units_lunits(dimyu) + ')'
+    else:
+        txpos = pretty_int(np.min(dimxv),np.max(dimxv),10)
+        txlabels = list(txpos)
+        plxlabel = variables_values(dimn[1])[0].replace('_','\_') + ' (' +           \
+          units_lunits(dimxu) + ')'
+        typos = tpos
+        tylabels = tlabs
+        plylabel = dimyu
+
+# Transposing/flipping axis
+    if reva.find('|') != 0:
+        revas = reva.split('|')
+        reva0 = ''
+    else:
+        revas = [reva]
+        reva0 = reva
+
+    for rev in revas:
+        if rev[0:4] == 'flip':
+            reva0 = 'flip'
+            if len(reva.split('@')) != 2:
+                 print errormsg
+                 print '  ' + fname + ': flip is given', reva, 'but not axis!'
+                 quit(-1)
+            else:
+                 print "  flipping '" + rev.split('@')[1] + "' axis !"
+
+        if rev == 'transpose':
+            print '  reversing the axes of the figure (x-->y, y-->x)!!'
+# Flipping values of variable
+            varsv = np.transpose(varsv)
+            dxv = dimyv
+            dyv = dimxv
+            dimxv = dxv
+            dimyv = dyv
+
+    if len(dimxv.shape) == 3:
+        dxget='1,2'
+    elif len(dimxv.shape) == 2:
+        dxget='0,1'
+    elif len(dimxv.shape) == 1:
+        dxget='0'
+    else:
+        print errormsg
+        print '  ' + fname + ': shape of x-values:',dimxv.shape,'not ready!!'
+        quit(-1)
+
+    if len(dimyv.shape) == 3:
+        dyget='1,2'
+    elif len(dimyv.shape) == 2:
+        dyget='0,1'
+    elif len(dimyv.shape) == 1:
+        dyget='0'
+    else:
+        print errormsg
+        print '  ' + fname + ': shape of y-values:',dimyv.shape,'not ready!!'
+        quit(-1)
+
+    x,y = dxdy_lonlat(dimxv,dimyv,dxget,dyget)
+
+    plt.rc('text', usetex=True)
+
+    vsend = np.zeros((2), dtype=np.float)
+# Changing limits of the colors
+    if type(vs[0]) != type(np.float(1.)):
+        if vs[0] == 'Srange':
+            vsend[0] = np.min(varsv)
+        elif vs[0][0:11] == 'Saroundmean':
+            meanv = np.mean(varsv)
+            permean = np.float(vs[0].split('@')[1])
+            minv = np.min(varsv)*permean
+            maxv = np.max(varsv)*permean
+            minextrm = np.min([np.abs(meanv-minv), np.abs(maxv-meanv)])
+            vsend[0] = meanv-minextrm
+            vsend[1] = meanv+minextrm
+        elif vs[0][0:13] == 'Saroundminmax':
+            permean = np.float(vs[0].split('@')[1])
+            minv = np.min(varsv)*permean
+            maxv = np.max(varsv)*permean
+            vsend[0] = minv
+            vsend[1] = maxv
+        elif vs[0][0:17] == 'Saroundpercentile':
+            medianv = np.median(varsv)
+            valper = np.float(vs[0].split('@')[1])
+            minv = np.percentile(varsv, valper)
+            maxv = np.percentile(varsv, 100.-valper)
+            minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
+            vsend[0] = medianv-minextrm
+            vsend[1] = medianv+minextrm
+        elif vs[0][0:5] == 'Smean':
+            meanv = np.mean(varsv)
+            permean = np.float(vs[0].split('@')[1])
+            minv = np.min(varsv)*permean
+            maxv = np.max(varsv)*permean
+            minextrm = np.min([np.abs(meanv-minv), np.abs(maxv-meanv)])
+            vsend[0] = -minextrm
+            vsend[1] = minextrm
+        elif vs[0][0:7] == 'Smedian':
+            medianv = np.median(varsv)
+            permedian = np.float(vs[0].split('@')[1])
+            minv = np.min(varsv)*permedian
+            maxv = np.max(varsv)*permedian
+            minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
+            vsend[0] = -minextrm
+            vsend[1] = minextrm
+        elif vs[0][0:11] == 'Spercentile':
+            medianv = np.median(varsv)
+            valper = np.float(vs[0].split('@')[1])
+            minv = np.percentile(varsv, valper)
+            maxv = np.percentile(varsv, 100.-valper)
+            minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
+            vsend[0] = -minextrm
+            vsend[1] = minextrm
+        else:
+            print errormsg
+            print '  ' + fname + ": range '" + vs[0] + "' not ready!!!"
+            quit(-1)
+        print '    ' + fname + ': modified shadow min,max:',vsend
+    else:
+        vsend[0] = vs[0]
+
+    if type(vs[0]) != type(np.float(1.)):
+        if vs[1] == 'range':
+            vsend[1] = np.max(varsv)
+    else:
+        vsend[1] = vs[1]
+
+    plt.pcolormesh(x, y, varsv, cmap=plt.get_cmap(colorbar), vmin=vsend[0], vmax=vsend[1])
+    cbar = plt.colorbar()
+
+#    print 'Lluis reva0:',reva0,'x min,max:',x.min(),x.max(),' y min,max:',y.min(),y.max()
+
+# set the limits of the plot to the limits of the data
+    if reva0 == 'flip':
+        if reva.split('@')[1] == 'x':
+            plt.axis([x.max(), x.min(), y.min(), y.max()])
+        elif reva.split('@')[1] == 'y':
+            plt.axis([x.min(), x.max(), y.max(), y.min()])
+        else:
+            plt.axis([x.max(), x.min(), y.max(), y.min()])
+    else:
+        plt.axis([x.min(), x.max(), y.min(), y.max()])
+
+    if searchInlist(revas, 'transpose'):
+        plt.xticks(typos, tylabels)
+        plt.yticks(txpos, txlabels)
+        plt.xlabel(plylabel)
+        plt.ylabel(plxlabel)
+    else:
+        plt.xticks(txpos, txlabels)
+        plt.yticks(typos, tylabels)
+        plt.xlabel(plxlabel)
+        plt.ylabel(plylabel)
+
+# units labels
+    cbar.set_label(vnames.replace('_','\_') + ' (' + units_lunits(uts) + ')')
+
+    figname = '2Dfields_shadow_time'
+    graphtit = vtit.replace('_','\_').replace('&','\&')
+
+    plt.title(graphtit)
+    
+    output_kind(kfig, figname, ifclose)
+
+    return
+
+def plot_2D_shadow_contour(varsv,varcv,vnames,dimxv,dimyv,dimxu,dimyu,dimn,          \
+  colorbar,ckind,clabfmt,vs,vc,uts,vtit,kfig,reva,mapv):
+    """ Adding labels and other staff to the graph
+      varsv= 2D values to plot with shading
+      varcv= 2D values to plot with contours
+      vnames= variable names for the figure
+      dim[x/y]v = values at the axes of x and y
+      dim[x/y]u = units at the axes of x and y
+      dimn= dimension names to plot
+      colorbar= name of the color bar to use
+      ckind= contour kind
+        'cmap': as it gets from colorbar
+        'fixc,[colname]': fixed color [colname], all stright lines
+        'fixsigc,[colname]': fixed color [colname], >0 stright, <0 dashed  line
+      clabfmt= format of the labels in the contour plot (None, no labels)
+      vs= minmum and maximum values to plot in shadow
+      vc= vector with the levels for the contour
+      uts= units of the variable [u-shadow, u-contour]
+      vtit= title of the variable
+      kfig= kind of figure (jpg, pdf, png)
+      reva= 
+        * 'transpose': reverse the axes (x-->y, y-->x)
+        * 'flip'@[x/y]: flip the axis x or y
+      mapv= map characteristics: [proj],[res]
+        see full documentation: http://matplotlib.org/basemap/
+        [proj]: projection
+          * 'cyl', cilindric
+          * 'lcc', lamvbert conformal
+        [res]: resolution:
+          * 'c', crude
+          * 'l', low
+          * 'i', intermediate
+          * 'h', high
+          * 'f', full
+    """
+##    import matplotlib as mpl
+##    mpl.use('Agg')
+##    import matplotlib.pyplot as plt
+    fname = 'plot_2D_shadow_contour'
+
+    if varsv == 'h':
+        print fname + '_____________________________________________________________'
+        print plot_2D_shadow_contour.__doc__
+        quit()
+
+    if reva[0:4] == 'flip':
+        reva0 = 'flip'
+        if len(reva.split('@')) != 2:
+             print errormsg
+             print '  ' + fname + ': flip is given', reva, 'but not axis!'
+             quit(-1)
+    else:
+        reva0 = reva
+
+    if reva0 == 'transpose':
+        print '  reversing the axes of the figure (x-->y, y-->x)!!'
+        varsv = np.transpose(varsv)
+        varcv = np.transpose(varcv)
+        dxv = dimyv
+        dyv = dimxv
+        dimxv = dxv
+        dimyv = dyv
+
+    if not mapv is None:
+        if len(dimxv[:].shape) == 3:
+            lon0 = dimxv[0,]
+            lat0 = dimyv[0,]
+        elif len(dimxv[:].shape) == 2:
+            lon0 = dimxv[:]
+            lat0 = dimyv[:]
+        elif len(dimxv[:].shape) == 1:
+            lon00 = dimxv[:]
+            lat00 = dimyv[:]
+            lon0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
+            lat0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
+
+            for iy in range(len(lat00)):
+                lon0[iy,:] = lon00
+            for ix in range(len(lon00)):
+                lat0[:,ix] = lat00
+
+        map_proj=mapv.split(',')[0]
+        map_res=mapv.split(',')[1]
+
+        dx = lon0.shape[1]
+        dy = lon0.shape[0]
+
+        nlon = lon0[0,0]
+        xlon = lon0[dy-1,dx-1]
+        nlat = lat0[0,0]
+        xlat = lat0[dy-1,dx-1]
+
+# Thats too much! :)
+#        if lonlatLims is not None:
+#            print '  ' + fname + ': cutting the domain to plot !!!!'
+#            plt.xlim(lonlatLims[0], lonlatLims[2])
+#            plt.ylim(lonlatLims[1], lonlatLims[3])
+#            print '    limits: W-E', lonlatLims[0], lonlatLims[2]
+#            print '    limits: N-S', lonlatLims[1], lonlatLims[3]
+
+#            if map_proj == 'cyl':
+#                nlon = lonlatLims[0]
+#                nlat = lonlatLims[1]
+#                xlon = lonlatLims[2]
+#                xlat = lonlatLims[3]
+#            elif map_proj == 'lcc':
+#                lon2 = (lonlatLims[0] + lonlatLims[2])/2.
+#                lat2 = (lonlatLims[1] + lonlatLims[3])/2.
+#                nlon =  lonlatLims[0]
+#                xlon =  lonlatLims[2]
+#                nlat =  lonlatLims[1]
+#                xlat =  lonlatLims[3]
+
+        lon2 = lon0[dy/2,dx/2]
+        lat2 = lat0[dy/2,dx/2]
+
+        print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:',     \
+          xlon, ',', xlat
+
+        if map_proj == 'cyl':
+            m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat,         \
+              urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+        elif map_proj == 'lcc':
+            m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
+              llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+
+        if len(dimxv.shape) == 1:
+            lons, lats = np.meshgrid(dimxv, dimyv)
+        else:
+            if len(dimxv.shape) == 3:
+                lons = dimxv[0,:,:]
+                lats = dimyv[0,:,:]
+            else:
+                lons = dimxv[:]
+                lats = dimyv[:]
+ 
+        x,y = m(lons,lats)
+
+    else:
+        if len(dimxv.shape) == 2:
+            x = dimxv
+        else:
+            if len(dimyv.shape) == 1:
+                x = np.zeros((len(dimyv),len(dimxv)), dtype=np.float)
+                for j in range(len(dimyv)):
+                    x[j,:] = dimxv
+            else:
+                x = np.zeros((dimyv.shape), dtype=np.float)
+                if x.shape[0] == dimxv.shape[0]:
+                    for j in range(x.shape[1]):
+                        x[:,j] = dimxv
+                else:
+                    for j in range(x.shape[0]):
+                        x[j,:] = dimxv
+
+        if len(dimyv.shape) == 2:
+            y = dimyv
+        else:
+            if len(dimxv.shape) == 1:
+                y = np.zeros((len(dimyv),len(dimxv)), dtype=np.float)
+                for i in range(len(dimxv)):
+                    y[:,i] = dimyv
+            else:
+                y = np.zeros((dimxv.shape), dtype=np.float)
+                if y.shape[0] == dimyv.shape[0]:
+                    for i in range(y.shape[1]):
+                        y[:,i] = dimyv
+                else:
+                    for i in range(y.shape[0]):
+                        y[i,:] = dimyv
+
+    plt.rc('text', usetex=True)
+
+    plt.pcolormesh(x, y, varsv, cmap=plt.get_cmap(colorbar), vmin=vs[0], vmax=vs[1])
+    cbar = plt.colorbar()
+
+# contour
+##
+    contkind = ckind.split(',')[0]
+    if contkind == 'cmap':
+        cplot = plt.contour(x, y, varcv, levels=vc)
+    elif  contkind == 'fixc':
+        plt.rcParams['contour.negative_linestyle'] = 'solid'
+        coln = ckind.split(',')[1]
+        cplot = plt.contour(x, y, varcv, levels=vc, colors=coln)
+    elif  contkind == 'fixsigc':
+        coln = ckind.split(',')[1]
+        cplot = plt.contour(x, y, varcv, levels=vc, colors=coln)
+    else:
+        print errormsg
+        print '  ' + fname + ': contour kind "' + contkind + '" not defined !!!!!'
+        quit(-1)
+
+    if clabfmt is not None:
+        plt.clabel(cplot, fmt=clabfmt)
+        mincntS = format(vc[0], clabfmt[1:len(clabfmt)])
+        maxcntS = format(vc[len(vc)-1], clabfmt[1:len(clabfmt)])
+    else:
+        mincntS = '{:g}'.format(vc[0])
+        maxcntS = '{:g}'.format(vc[len(vc)-1])        
+
+    if not mapv is None:
+        m.drawcoastlines()
+
+        meridians = pretty_int(nlon,xlon,5)
+        m.drawmeridians(meridians,labels=[True,False,False,True])
+        parallels = pretty_int(nlat,xlat,5)
+        m.drawparallels(parallels,labels=[False,True,True,False])
+
+        plt.xlabel('W-E')
+        plt.ylabel('S-N')
+    else:
+        plt.xlabel(variables_values(dimn[1])[0] + ' (' + units_lunits(dimxu) + ')')
+        plt.ylabel(variables_values(dimn[0])[0] + ' (' + units_lunits(dimyu) + ')')
+
+    txpos = pretty_int(x.min(),x.max(),10)
+    typos = pretty_int(y.min(),y.max(),10)
+    txlabels = list(txpos)
+    for i in range(len(txlabels)): txlabels[i] = str(txlabels[i])
+    tylabels = list(typos)
+    for i in range(len(tylabels)): tylabels[i] = str(tylabels[i])
+
+# set the limits of the plot to the limits of the data
+    if reva0 == 'flip':
+        if reva.split('@')[1] == 'x':
+            plt.axis([x.max(), x.min(), y.min(), y.max()])
+        else:
+            plt.axis([x.min(), x.max(), y.max(), y.min()])
+    else:
+        plt.axis([x.min(), x.max(), y.min(), y.max()])
+
+    plt.xticks(txpos, txlabels)
+    plt.yticks(typos, tylabels)
+
+# units labels
+    cbar.set_label(vnames[0].replace('_','\_') + ' (' + units_lunits(uts[0]) + ')')
+    plt.annotate(vnames[1].replace('_','\_') +' (' + units_lunits(uts[1]) + ') [' +  \
+      mincntS + ', ' + maxcntS + ']', xy=(0.55,0.04), xycoords='figure fraction',    \
+      color=coln)
+
+    figname = '2Dfields_shadow-contour'
+    graphtit = vtit.replace('_','\_').replace('&','\&')
+
+    plt.title(graphtit)
+    
+    output_kind(kfig, figname, True)
+
+    return
+
+#Nvals=50
+#vals1 = np.zeros((Nvals,Nvals), dtype= np.float)
+#vals2 = np.zeros((Nvals,Nvals), dtype= np.float)
+#for j in range(Nvals):
+#    for i in range(Nvals):
+#      vals1[j,i]=np.sqrt((j-Nvals/2)**2. + (i-Nvals/2)**2.)
+#      vals2[j,i]=np.sqrt((j-Nvals/2)**2. + (i-Nvals/2)**2.) - Nvals/2
+
+#prettylev=pretty_int(-Nvals/2,Nvals/2,10)
+
+#plot_2D_shadow_contour(vals1, vals2, ['var1', 'var2'], np.arange(50)*1.,             \
+#  np.arange(50)*1., ['x-axis','y-axis'], 'rainbow', 'fixc,b', "%.2f", [0, Nvals],    \
+#  prettylev, ['$ms^{-1}$','$kJm^{-1}s^{-1}$'], 'test var1 & var2', 'pdf', False)
+
+def plot_2D_shadow_contour_time(varsv,varcv,vnames,valv,timv,timpos,timlab,valu,     \
+  timeu,axist,dimn,colorbar,ckind,clabfmt,vs,vc,uts,vtit,kfig,reva,mapv):
+    """ Adding labels and other staff to the graph
+      varsv= 2D values to plot with shading
+      varcv= 2D values to plot with contours
+      vnames= variable names for the figure
+      valv = values at the axes which is not time
+      timv = values for the axis time
+      timpos = positions at the axis time
+      timlab = labes at the axis time
+      valu = units at the axes which is not time
+      timeu = units at the axes which is not time
+      axist = which is the axis time
+      dimn= dimension names to plot
+      colorbar= name of the color bar to use
+      ckind= contour kind
+        'cmap': as it gets from colorbar
+        'fixc,[colname]': fixed color [colname], all stright lines
+        'fixsigc,[colname]': fixed color [colname], >0 stright, <0 dashed  line
+      clabfmt= format of the labels in the contour plot (None, no labels)
+      vs= minmum and maximum values to plot in shadow
+      vc= vector with the levels for the contour
+      uts= units of the variable [u-shadow, u-contour]
+      vtit= title of the variable
+      kfig= kind of figure (jpg, pdf, png)
+      reva= 
+        * 'transpose': reverse the axes (x-->y, y-->x)
+        * 'flip'@[x/y]: flip the axis x or y
+      mapv= map characteristics: [proj],[res]
+        see full documentation: http://matplotlib.org/basemap/
+        [proj]: projection
+          * 'cyl', cilindric
+          * 'lcc', lamvbert conformal
+        [res]: resolution:
+          * 'c', crude
+          * 'l', low
+          * 'i', intermediate
+          * 'h', high
+          * 'f', full
+    """
+##    import matplotlib as mpl
+##    mpl.use('Agg')
+##    import matplotlib.pyplot as plt
+    fname = 'plot_2D_shadow_contour'
+
+    if varsv == 'h':
+        print fname + '_____________________________________________________________'
+        print plot_2D_shadow_contour.__doc__
+        quit()
+
+    if axist == 'x':
+        dimxv = timv.copy()
+        dimyv = valv.copy()
+    else:
+        dimxv = valv.copy()
+        dimyv = timv.copy()
+
+    if reva[0:4] == 'flip':
+        reva0 = 'flip'
+        if len(reva.split('@')) != 2:
+             print errormsg
+             print '  ' + fname + ': flip is given', reva, 'but not axis!'
+             quit(-1)
+    else:
+        reva0 = reva
+
+    if reva0 == 'transpose':
+        if axist == 'x': 
+            axist = 'y'
+        else:
+            axist = 'x'
+
+    if not mapv is None:
+        if len(dimxv[:].shape) == 3:
+            lon0 = dimxv[0,]
+            lat0 = dimyv[0,]
+        elif len(dimxv[:].shape) == 2:
+            lon0 = dimxv[:]
+            lat0 = dimyv[:]
+        elif len(dimxv[:].shape) == 1:
+            lon00 = dimxv[:]
+            lat00 = dimyv[:]
+            lon0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
+            lat0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
+
+            for iy in range(len(lat00)):
+                lon0[iy,:] = lon00
+            for ix in range(len(lon00)):
+                lat0[:,ix] = lat00
+        if reva0 == 'transpose':
+            print '  reversing the axes of the figure (x-->y, y-->x)!!'
+            varsv = np.transpose(varsv)
+            varcv = np.transpose(varcv)
+            lon0 = np.transpose(lon0)
+            lat0 = np.transpose(lat0)
+
+        map_proj=mapv.split(',')[0]
+        map_res=mapv.split(',')[1]
+
+        dx = lon0.shape[1]
+        dy = lon0.shape[0]
+
+        nlon = lon0[0,0]
+        xlon = lon0[dy-1,dx-1]
+        nlat = lat0[0,0]
+        xlat = lat0[dy-1,dx-1]
+
+# Thats too much! :)
+#        if lonlatLims is not None:
+#            print '  ' + fname + ': cutting the domain to plot !!!!'
+#            plt.xlim(lonlatLims[0], lonlatLims[2])
+#            plt.ylim(lonlatLims[1], lonlatLims[3])
+#            print '    limits: W-E', lonlatLims[0], lonlatLims[2]
+#            print '    limits: N-S', lonlatLims[1], lonlatLims[3]
+
+#            if map_proj == 'cyl':
+#                nlon = lonlatLims[0]
+#                nlat = lonlatLims[1]
+#                xlon = lonlatLims[2]
+#                xlat = lonlatLims[3]
+#            elif map_proj == 'lcc':
+#                lon2 = (lonlatLims[0] + lonlatLims[2])/2.
+#                lat2 = (lonlatLims[1] + lonlatLims[3])/2.
+#                nlon =  lonlatLims[0]
+#                xlon =  lonlatLims[2]
+#                nlat =  lonlatLims[1]
+#                xlat =  lonlatLims[3]
+
+        lon2 = lon0[dy/2,dx/2]
+        lat2 = lat0[dy/2,dx/2]
+
+        print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:',     \
+          xlon, ',', xlat
+
+        if map_proj == 'cyl':
+            m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat,         \
+              urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+        elif map_proj == 'lcc':
+            m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
+              llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+
+        if len(dimxv.shape) == 1:
+            lons, lats = np.meshgrid(dimxv, dimyv)
+        else:
+            if len(dimxv.shape) == 3:
+                lons = dimxv[0,:,:]
+                lats = dimyv[0,:,:]
+            else:
+                lons = dimxv[:]
+                lats = dimyv[:]
+ 
+        x,y = m(lons,lats)
+
+    else:
+        if reva0  == 'transpose':
+            print '  reversing the axes of the figure (x-->y, y-->x)!!'
+            varsv = np.transpose(varsv)
+            varcv = np.transpose(varcv)
+            dimn0 = []
+            dimn0.append(dimn[1] + '')
+            dimn0.append(dimn[0] + '')
+            dimn = dimn0
+            if len(dimyv.shape) == 2:
+                x = np.transpose(dimyv)
+            else:
+                if len(dimxv.shape) == 2:
+                    ddx = len(dimyv)
+                    ddy = dimxv.shape[1]
+                else:
+                    ddx = len(dimyv)
+                    ddy = len(dimxv)
+    
+                x = np.zeros((ddy,ddx), dtype=np.float)
+                for j in range(ddy):
+                    x[j,:] = dimyv
+
+            if len(dimxv.shape) == 2:
+                y = np.transpose(dimxv)
+            else:
+                if len(dimyv.shape) == 2:
+                    ddx = dimyv.shape[0]
+                    ddy = len(dimxv)
+                else:
+                    ddx = len(dimyv)
+                    ddy = len(dimxv)
+
+                y = np.zeros((ddy,ddx), dtype=np.float)
+                for i in range(ddx):
+                    y[:,i] = dimxv
+        else:
+            if len(dimxv.shape) == 2:
+                x = dimxv
+            else:
+                if len(dimyv.shape) == 1:
+                    x = np.zeros((len(dimyv),len(dimxv)), dtype=np.float)
+                    for j in range(len(dimyv)):
+                        x[j,:] = dimxv
+                else:
+                    x = np.zeros((dimyv.shape), dtype=np.float)
+                    if x.shape[0] == dimxv.shape[0]:
+                        for j in range(x.shape[1]):
+                            x[:,j] = dimxv
+                    else:
+                        for j in range(x.shape[0]):
+                            x[j,:] = dimxv
+
+            if len(dimyv.shape) == 2:
+                y = dimyv
+            else:
+                if len(dimxv.shape) == 1:
+                    y = np.zeros((len(dimyv),len(dimxv)), dtype=np.float)
+                    for i in range(len(dimxv)):
+                        y[:,i] = dimyv
+                else:
+                    y = np.zeros((dimxv.shape), dtype=np.float)
+                    if y.shape[0] == dimyv.shape[0]:
+                        for i in range(y.shape[1]):
+                            y[:,i] = dimyv
+                    else:
+                        for i in range(y.shape[0]):
+                            y[i,:] = dimyv
+
+    dx=varsv.shape[1]
+    dy=varsv.shape[0]
+    
+    plt.rc('text', usetex=True)
+
+    if axist == 'x':
+        valpos = pretty_int(y.min(),y.max(),10)
+        vallabels = list(valpos)
+        for i in range(len(vallabels)): vallabels[i] = str(vallabels[i])
+    else:
+        valpos = pretty_int(x.min(),x.max(),10)
+        vallabels = list(valpos)
+        for i in range(len(vallabels)): vallabels[i] = str(vallabels[i])
+
+    if reva0 == 'flip':
+        if reva.split('@')[1] == 'x':
+            varsv[:,0:dx-1] = varsv[:,dx-1:0:-1]
+            varcv[:,0:dx-1] = varcv[:,dx-1:0:-1]
+            plt.xticks(valpos, vallabels[::-1])
+        else:
+            varsv[0:dy-1,:] = varsv[dy-1:0:-1,:]
+            varcv[0:dy-1,:] = varcv[dy-1:0:-1,:]
+            plt.yticks(valpos, vallabels[::-1])
+    else:
+        plt.xlim(0,dx-1)
+        plt.ylim(0,dy-1)
+
+    plt.pcolormesh(x, y, varsv, cmap=plt.get_cmap(colorbar), vmin=vs[0], vmax=vs[1])
+    cbar = plt.colorbar()
+    
+# contour
+##
+    contkind = ckind.split(',')[0]
+    if contkind == 'cmap':
+        cplot = plt.contour(x, y, varcv, levels=vc)
+    elif  contkind == 'fixc':
+        plt.rcParams['contour.negative_linestyle'] = 'solid'
+        coln = ckind.split(',')[1]
+        cplot = plt.contour(x, y, varcv, levels=vc, colors=coln)
+    elif  contkind == 'fixsigc':
+        coln = ckind.split(',')[1]
+        cplot = plt.contour(x, y, varcv, levels=vc, colors=coln)
+    else:
+        print errormsg
+        print '  ' + fname + ': contour kind "' + contkind + '" not defined !!!!!'
+        quit(-1)
+
+    if clabfmt is not None:
+        plt.clabel(cplot, fmt=clabfmt)
+        mincntS = format(vc[0], clabfmt[1:len(clabfmt)])
+        maxcntS = format(vc[len(vc)-1], clabfmt[1:len(clabfmt)])
+    else:
+        mincntS = '{:g}'.format(vc[0])
+        maxcntS = '{:g}'.format(vc[len(vc)-1])        
+
+    if not mapv is None:
+        m.drawcoastlines()
+
+        meridians = pretty_int(nlon,xlon,5)
+        m.drawmeridians(meridians,labels=[True,False,False,True])
+        parallels = pretty_int(nlat,xlat,5)
+        m.drawparallels(parallels,labels=[False,True,True,False])
+
+        plt.xlabel('W-E')
+        plt.ylabel('S-N')
+    else:
+        if axist == 'x':
+            plt.xlabel(timeu)
+            plt.xticks(timpos, timlab)
+            plt.ylabel(variables_values(dimn[0])[0] + ' (' + units_lunits(valu) + ')')
+            plt.yticks(valpos, vallabels)
+        else:
+            plt.xlabel(variables_values(dimn[1])[0] + ' (' + units_lunits(valu) + ')')
+            plt.xticks(valpos, vallabels)
+            plt.ylabel(timeu)
+            plt.yticks(timpos, timlab)
+
+# set the limits of the plot to the limits of the data
+    plt.axis([x.min(), x.max(), y.min(), y.max()])
+
+# units labels
+    cbar.set_label(vnames[0].replace('_','\_') + ' (' + units_lunits(uts[0]) + ')')
+    plt.annotate(vnames[1].replace('_','\_') +' (' + units_lunits(uts[1]) + ') [' +  \
+      mincntS + ', ' + maxcntS + ']', xy=(0.55,0.04), xycoords='figure fraction',    \
+      color=coln)
+
+    figname = '2Dfields_shadow-contour'
+    graphtit = vtit.replace('_','\_').replace('&','\&')
+
+    plt.title(graphtit)
+    
+    output_kind(kfig, figname, True)
+
+    return
+
+def dxdy_lonlat(dxv,dyv,ddx,ddy):
+    """ Function to provide lon/lat 2D lilke-matrices from any sort of dx,dy values
+    dxdy_lonlat(dxv,dyv,Lv,lv)
+      dx: values for the x
+      dy: values for the y
+      ddx: ',' list of which dimensions to use from values along x
+      ddy: ',' list of which dimensions to use from values along y
+    """
+
+    fname = 'dxdy_lonlat'
+
+    if ddx.find(',') > -1:
+        dxk = 2
+        ddxv = ddx.split(',')
+        ddxy = int(ddxv[0])
+        ddxx = int(ddxv[1])
+    else:
+        dxk = 1
+        ddxy = int(ddx)
+        ddxx = int(ddx)
+
+    if ddy.find(',') > -1:
+        dyk = 2
+        ddyv = ddy.split(',')
+        ddyy = int(ddyv[0])
+        ddyx = int(ddyv[1])
+    else:
+        dyk = 1
+        ddyy = int(ddy)
+        ddyx = int(ddy)
+
+    ddxxv = dxv.shape[ddxx]
+    ddxyv = dxv.shape[ddxy]
+    ddyxv = dyv.shape[ddyx]
+    ddyyv = dyv.shape[ddyy]
+
+    slicex = []
+    if len(dxv.shape) > 1:
+        for idim in range(len(dxv.shape)):
+            if idim == ddxx or idim == ddxy:
+                slicex.append(slice(0,dxv.shape[idim]))
+            else:
+                slicex.append(0)
+    else:
+        slicex.append(slice(0,len(dxv)))
+
+    slicey = []
+    if len(dyv.shape) > 1:
+        for idim in range(len(dyv.shape)):
+            if idim == ddyx or idim == ddyy:
+                slicey.append(slice(0,dyv.shape[idim]))
+            else:
+                slicey.append(0)
+    else:
+        slicey.append(slice(0,len(dyv)))
+
+#    print '    ' + fname + ' Lluis shapes dxv:',dxv.shape,'dyv:',dyv.shape 
+#    print '    ' + fname + ' Lluis slicex:',slicex,'slicey:',slicey
+
+    if dxk == 2 and dyk == 2:
+        if ddxxv != ddyxv:
+            print errormsg
+            print '  ' + fname + ': wrong dx dimensions! ddxx=',ddxxv,'ddyx=',ddyxv
+            print '    choose another for x:',dxv.shape,'or y:',dyv.shape
+            quit(-1)
+        if ddxyv != ddyyv:
+            print errormsg
+            print '  ' + fname + ': wrong dy dimensions! ddxy=',ddxyv,'ddyy=',ddyv
+            print '    choose another for x:',dxv.shape,'or y:',dyv.shape
+            quit(-1)
+        dx = ddxxv
+        dy = ddxyv
+
+        print '  ' + fname + ': final dimension 2D lon/lat-like matrices:',dy,',',dx
+        lonv = np.zeros((dy,dx), dtype=np.float)
+        latv = np.zeros((dy,dx), dtype=np.float)
+
+
+        lonv = dxv[tuple(slicex)]
+        latv = dyv[tuple(slicey)]
+
+    elif dxk == 2 and dyk == 1:
+        if not ddxxv == ddyxv and not ddxyv == ddyyv:
+            print errormsg
+            print '  ' + fname + ': wrong dimensions! ddxx=',ddxxv,'ddyx=',ddyxv,    \
+              'ddyx=',ddyxv,'ddyy=',ddyyv
+            print '    choose another for x:',dxv.shape,'or y:',dyv.shape
+            quit(-1)
+        dx = ddxvv
+        dy = ddxyv
+
+        print '  ' + fname + ': final dimension 2D lon/lat-like matrices:',dy,',',dx
+        lonv = np.zeros((dy,dx), dtype=np.float)
+        latv = np.zeros((dy,dx), dtype=np.float)
+        lonv = dxv[tuple(slicex)]
+
+        if ddxxv == ddyxv: 
+            for iy in range(dy):
+                latv[iy,:] = dyv[tuple(slicey)]
+        else:
+            for ix in range(dx):
+                latv[:,ix] = dyv[tuple(slicey)]
+
+    elif dxk == 1 and dyk == 2:
+        if not ddxxv == ddyxv and not ddxyv == ddyyv:
+            print errormsg
+            print '  ' + fname + ': wrong dimensions! ddxx=',ddxxv,'ddyx=',ddyxv,    \
+              'ddyx=',ddyxv,'ddyy=',ddyyv
+            print '    choose another for x:',dxv.shape,'or y:',dyv.shape
+            quit(-1)
+        dx = ddyxv
+        dy = ddyyv
+ 
+        print '  ' + fname + ': final dimension 2D lon/lat-like matrices:',dy,',',dx
+        lonv = np.zeros((dy,dx), dtype=np.float)
+        latv = np.zeros((dy,dx), dtype=np.float)
+
+        latv = dyv[tuple(slicey)]
+
+        if ddyxv == ddxxv: 
+            for iy in range(dy):
+                lonv[iy,:] = dxv[tuple(slicex)]
+        else:
+            for ix in range(dx):
+                lonv[:,ix] = dxv[tuple(slicex)]
+
+
+    elif dxk == 1 and dyk == 1:
+        dx = ddxxv
+        dy = ddyyv
+ 
+#        print 'dx:',dx,'dy:',dy 
+
+        lonv = np.zeros((dy,dx), dtype=np.float)
+        latv = np.zeros((dy,dx), dtype=np.float)
+
+        for iy in range(dy):
+            lonv[iy,:] = dxv[tuple(slicex)]
+        for ix in range(dx):
+            latv[:,ix] = dyv[tuple(slicey)]
+
+    return lonv,latv
+
+def plot_2D_shadow_line(varsv,varlv,vnames,vnamel,dimxv,dimyv,dimxu,dimyu,dimn,             \
+  colorbar,colln,vs,uts,utl,vtit,kfig,reva,mapv,ifclose):
+    """ Plotting a 2D field with shadows and another one with a line
+      varsv= 2D values to plot with shading
+      varlv= 1D values to plot with line
+      vnames= variable names for the shadow variable in the figure
+      vnamel= variable names for the line varibale in the figure
+      dim[x/y]v = values at the axes of x and y
+      dim[x/y]u = units at the axes of x and y
+      dimn= dimension names to plot
+      colorbar= name of the color bar to use
+      colln= color for the line
+      vs= minmum and maximum values to plot in shadow
+      uts= units of the variable to shadow
+      utl= units of the variable to line
+      vtit= title of the variable
+      kfig= kind of figure (jpg, pdf, png)
+      reva= 
+        * 'transpose': reverse the axes (x-->y, y-->x)
+        * 'flip'@[x/y]: flip the axis x or y
+      mapv= map characteristics: [proj],[res]
+        see full documentation: http://matplotlib.org/basemap/
+        [proj]: projection
+          * 'cyl', cilindric
+          * 'lcc', lambert conformal
+        [res]: resolution:
+          * 'c', crude
+          * 'l', low
+          * 'i', intermediate
+          * 'h', high
+          * 'f', full
+      ifclose= boolean value whether figure should be close (finish) or not
+    """
+##    import matplotlib as mpl
+##    mpl.use('Agg')
+##    import matplotlib.pyplot as plt
+    fname = 'plot_2D_shadow_line'
+
+    if varsv == 'h':
+        print fname + '_____________________________________________________________'
+        print plot_2D_shadow_line.__doc__
+        quit()
+
+    if reva[0:4] == 'flip':
+        reva0 = 'flip'
+        if len(reva.split('@')) != 2:
+             print errormsg
+             print '  ' + fname + ': flip is given', reva, 'but not axis!'
+             quit(-1)
+    else:
+        reva0 = reva
+
+    if reva0 == 'transpose':
+        print '  reversing the axes of the figure (x-->y, y-->x)!!'
+        varsv = np.transpose(varsv)
+        dxv = dimyv
+        dyv = dimxv
+        dimxv = dxv
+        dimyv = dyv
+
+    if len(dimxv[:].shape) == 3:
+        lon0 = dimxv[0,]
+    elif len(dimxv[:].shape) == 2:
+        lon0 = dimxv[:]
+
+    if len(dimyv[:].shape) == 3:
+        lat0 = dimyv[0,]
+    elif len(dimyv[:].shape) == 2:
+        lat0 = dimyv[:]
+
+    if len(dimxv[:].shape) == 1 and len(dimyv[:].shape) == 1:
+        lon00 = dimxv[:]
+        lon0 = np.zeros( (len(lat00),len(lon00)), dtype=np.float )
+
+        for iy in range(len(lat00)):
+            lon0[iy,:] = lon00
+        for ix in range(len(lon00)):
+            lat0[:,ix] = lat00
+
+    if not mapv is None:
+        map_proj=mapv.split(',')[0]
+        map_res=mapv.split(',')[1]
+
+        dx = lon0.shape[1]
+        dy = lat0.shape[0]
+
+        nlon = lon0[0,0]
+        xlon = lon0[dy-1,dx-1]
+        nlat = lat0[0,0]
+        xlat = lat0[dy-1,dx-1]
+
+# Thats too much! :)
+#        if lonlatLims is not None:
+#            print '  ' + fname + ': cutting the domain to plot !!!!'
+#            plt.xlim(lonlatLims[0], lonlatLims[2])
+#            plt.ylim(lonlatLims[1], lonlatLims[3])
+#            print '    limits: W-E', lonlatLims[0], lonlatLims[2]
+#            print '    limits: N-S', lonlatLims[1], lonlatLims[3]
+
+#            if map_proj == 'cyl':
+#                nlon = lonlatLims[0]
+#                nlat = lonlatLims[1]
+#                xlon = lonlatLims[2]
+#                xlat = lonlatLims[3]
+#            elif map_proj == 'lcc':
+#                lon2 = (lonlatLims[0] + lonlatLims[2])/2.
+#                lat2 = (lonlatLims[1] + lonlatLims[3])/2.
+#                nlon =  lonlatLims[0]
+#                xlon =  lonlatLims[2]
+#                nlat =  lonlatLims[1]
+#                xlat =  lonlatLims[3]
+
+        lon2 = lon0[dy/2,dx/2]
+        lat2 = lat0[dy/2,dx/2]
+
+        print 'lon2:', lon2, 'lat2:', lat2, 'SW pt:', nlon, ',', nlat, 'NE pt:',     \
+          xlon, ',', xlat
+
+        if map_proj == 'cyl':
+            m = Basemap(projection=map_proj, llcrnrlon=nlon, llcrnrlat=nlat,         \
+              urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+        elif map_proj == 'lcc':
+            m = Basemap(projection=map_proj, lat_0=lat2, lon_0=lon2, llcrnrlon=nlon, \
+              llcrnrlat=nlat, urcrnrlon=xlon, urcrnrlat= xlat, resolution=map_res)
+        else:
+            print errormsg
+            print '  ' + fname + ": map projection '" + map_proj + "' not defined!!!"
+            print '    available: cyl, lcc'
+            quit(-1)
+
+        if len(dimxv.shape) == 1:
+            lons, lats = np.meshgrid(dimxv, dimyv)
+        else:
+            if len(dimxv.shape) == 3:
+                lons = dimxv[0,:,:]
+            else:
+                lons = dimxv[:]
+
+            if len(dimyv.shape) == 3:
+                lats = dimyv[0,:,:]
+            else:
+                lats = dimyv[:]
+ 
+        x,y = m(lons,lats)
+
+    else:
+        if len(dimxv.shape) == 3:
+            x = dimxv[0,:,:]
+        elif len(dimxv.shape) == 2:
+            x = dimxv
+        else:
+# Attempt of simplier way...
+#            x = np.zeros((lon0.shape), dtype=np.float)
+#            for j in range(lon0.shape[0]):
+#                x[j,:] = dimxv
+
+## This way is too complicated and maybe not necessary ? (assuming dimxv.shape == dimyv.shape)
+            if len(dimyv.shape) == 1:
+                x = np.zeros((len(dimyv),len(dimxv)), dtype=np.float)
+                for j in range(len(dimxv)):
+                    x[j,:] = dimxv
+            else:
+                x = np.zeros((dimyv.shape), dtype=np.float)
+                if x.shape[0] == dimxv.shape[0]:
+                    for j in range(x.shape[1]):
+                        x[:,j] = dimxv
+                else:
+                    for j in range(x.shape[0]):
+                        x[j,:] = dimxv
+
+        if len(dimyv.shape) == 3:
+            y = dimyv[0,:,:]
+        elif len(dimyv.shape) == 2:
+            y = dimyv
+        else:
+#            y = np.zeros((lat0.shape), dtype=np.float)
+#            for i in range(lat0.shape[1]):
+#                x[:,i] = dimyv
+
+# Idem
+            if len(dimxv.shape) == 1:
+                y = np.zeros((len(dimyv),len(dimxv)), dtype=np.float)
+                for i in range(len(dimxv)):
+                    y[:,i] = dimyv
+            else:
+                y = np.zeros((dimxv.shape), dtype=np.float)
+                if y.shape[0] == dimyv.shape[0]:
+                    for i in range(y.shape[1]):
+                        y[:,i] = dimyv
+                else:
+                    for j in range(y.shape[0]):
+                        y[j,:] = dimyv
+
+    plt.rc('text', usetex=True)
+
+    plt.pcolormesh(x, y, varsv, cmap=plt.get_cmap(colorbar), vmin=vs[0], vmax=vs[1])
+    cbar = plt.colorbar()
+
+    if not mapv is None:
+        m.drawcoastlines()
+
+        meridians = pretty_int(nlon,xlon,5)
+        m.drawmeridians(meridians,labels=[True,False,False,True])
+        parallels = pretty_int(nlat,xlat,5)
+        m.drawparallels(parallels,labels=[False,True,True,False])
+
+        plt.xlabel('W-E')
+        plt.ylabel('S-N')
+    else:
+        plt.xlabel(variables_values(dimn[1])[0] + ' (' + units_lunits(dimxu) + ')')
+        plt.ylabel(variables_values(dimn[0])[0] + ' (' + units_lunits(dimyu) + ')')
+
+# Line
+##
+
+    if reva0 == 'flip' and reva.split('@')[1] == 'y':
+        b=-np.max(y[0,:])/np.max(varlv)
+        a=np.max(y[0,:])
+    else:
+        b=np.max(y[0,:])/np.max(varlv)
+        a=0.
+
+    newlinv = varlv*b+a
+    if reva0 == 'transpose':
+        plt.plot(newlinv, x[0,:], '-', color=colln, linewidth=2)
+    else:
+        plt.plot(x[0,:], newlinv, '-', color=colln, linewidth=2)
+
+    txpos = pretty_int(x.min(),x.max(),10)
+    typos = pretty_int(y.min(),y.max(),10)
+    txlabels = list(txpos)
+    for i in range(len(txlabels)): txlabels[i] = str(txlabels[i])
+    tylabels = list(typos)
+    for i in range(len(tylabels)): tylabels[i] = str(tylabels[i])
+
+    tllabels = pretty_int(np.min(varlv),np.max(varlv),len(txlabels))
+    for it in range(len(tllabels)):
+        yval = (tllabels[it]*b+a)
+        plt.plot([x.max()*0.97, x.max()], [yval, yval], '-', color='k')
+        plt.annotate(tllabels[it], xy=(1.01,tllabels[it]/np.max(varlv)),             \
+          xycoords='axes fraction')
+
+# set the limits of the plot to the limits of the data
+    if reva0 == 'flip':
+        if reva.split('@')[1] == 'x':
+            plt.axis([x.max(), x.min(), y.min(), y.max()])
+        else:
+            plt.axis([x.min(), x.max(), y.max(), y.min()])
+    else:
+        plt.axis([x.min(), x.max(), y.min(), y.max()])
+
+    plt.tick_params(axis='y',right='off')
+    if mapv is None:
+        plt.xticks(txpos, txlabels)
+        plt.yticks(typos, tylabels)
+
+    tllabels = pretty_int(np.min(varlv),np.max(varlv),len(txlabels))
+    for it in range(len(tllabels)):
+        plt.annotate(tllabels[it], xy=(1.01,tllabels[it]/np.max(varlv)), xycoords='axes fraction')
+
+# units labels
+    cbar.set_label(vnames.replace('_','\_') + ' (' + units_lunits(uts) + ')')
+
+    plt.annotate(vnamel +' (' + units_lunits(utl) + ')', xy=(0.75,0.04), 
+      xycoords='figure fraction', color=colln)
+    figname = '2Dfields_shadow_line'
+    graphtit = vtit.replace('_','\_').replace('&','\&')
+
+    plt.title(graphtit)
+    
+    output_kind(kfig, figname, ifclose)
+
+    return
+
+def plot_Neighbourghood_evol(varsv, dxv, dyv, vnames, ttits, tpos, tlabels, colorbar, \
+  Nng, vs, uts, gtit, kfig, ifclose):
+    """ Plotting neighbourghood evolution
+      varsv= 2D values to plot with shading
+      vnames= shading variable name for the figure
+      d[x/y]v= values at the axes of x and y
+      ttits= titles of both time axis
+      tpos= positions of the time ticks
+      tlabels= labels of the time ticks
+      colorbar= name of the color bar to use
+      Nng= Number of grid points of the full side of the box (odd value)
+      vs= minmum and maximum values to plot in shadow or:
+        'Srange': for full range
+        'Saroundmean@val': for mean-xtrm,mean+xtrm where xtrm = np.min(mean-min@val,max@val-mean)
+        'Saroundminmax@val': for min*val,max*val
+        'Saroundpercentile@val': for median-xtrm,median+xtrm where xtrm = np.min(median-percentile_(val),
+          percentile_(100-val)-median)
+        'Smean@val': for -xtrm,xtrm where xtrm = np.min(mean-min*@val,max*@val-mean)
+        'Smedian@val': for -xtrm,xtrm where xtrm = np.min(median-min@val,max@val-median)
+        'Spercentile@val': for -xtrm,xtrm where xtrm = np.min(median-percentile_(val),
+           percentile_(100-val)-median)
+      uts= units of the variable to shadow
+      gtit= title of the graph
+      kfig= kind of figure (jpg, pdf, png)
+      ifclose= boolean value whether figure should be close (finish) or not
+    """
+    import numpy.ma as ma
+
+    fname = 'plot_Neighbourghood_evol'
+
+    if varsv == 'h':
+        print fname + '_____________________________________________________________'
+        print plot_Neighbourghood_evol.__doc__
+        quit()
+
+    if len(varsv.shape) != 2:
+        print errormsg
+        print '  ' + fname + ': wrong number of dimensions of the values: ',         \
+          varsv.shape
+        quit(-1)
+
+    varsvmask = ma.masked_equal(varsv,fillValue)
+
+    vsend = np.zeros((2), dtype=np.float)
+# Changing limits of the colors
+    if type(vs[0]) != type(np.float(1.)):
+        if vs[0] == 'Srange':
+            vsend[0] = np.min(varsvmask)
+        elif vs[0][0:11] == 'Saroundmean':
+            meanv = np.mean(varsvmask)
+            permean = np.float(vs[0].split('@')[1])
+            minv = np.min(varsvmask)*permean
+            maxv = np.max(varsvmask)*permean
+            minextrm = np.min([np.abs(meanv-minv), np.abs(maxv-meanv)])
+            vsend[0] = meanv-minextrm
+            vsend[1] = meanv+minextrm
+        elif vs[0][0:13] == 'Saroundminmax':
+            permean = np.float(vs[0].split('@')[1])
+            minv = np.min(varsvmask)*permean
+            maxv = np.max(varsvmask)*permean
+            vsend[0] = minv
+            vsend[1] = maxv
+        elif vs[0][0:17] == 'Saroundpercentile':
+            medianv = np.median(varsvmask)
+            valper = np.float(vs[0].split('@')[1])
+            minv = np.percentile(varsvmask, valper)
+            maxv = np.percentile(varsvmask, 100.-valper)
+            minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
+            vsend[0] = medianv-minextrm
+            vsend[1] = medianv+minextrm
+        elif vs[0][0:5] == 'Smean':
+            meanv = np.mean(varsvmask)
+            permean = np.float(vs[0].split('@')[1])
+            minv = np.min(varsvmask)*permean
+            maxv = np.max(varsvmask)*permean
+            minextrm = np.min([np.abs(meanv-minv), np.abs(maxv-meanv)])
+            vsend[0] = -minextrm
+            vsend[1] = minextrm
+        elif vs[0][0:7] == 'Smedian':
+            medianv = np.median(varsvmask)
+            permedian = np.float(vs[0].split('@')[1])
+            minv = np.min(varsvmask)*permedian
+            maxv = np.max(varsvmask)*permedian
+            minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
+            vsend[0] = -minextrm
+            vsend[1] = minextrm
+        elif vs[0][0:11] == 'Spercentile':
+            medianv = np.median(varsvmask)
+            valper = np.float(vs[0].split('@')[1])
+            minv = np.percentile(varsvmask, valper)
+            maxv = np.percentile(varsvmask, 100.-valper)
+            minextrm = np.min([np.abs(medianv-minv), np.abs(maxv-medianv)])
+            vsend[0] = -minextrm
+            vsend[1] = minextrm
+        else:
+            print errormsg
+            print '  ' + fname + ": range '" + vs[0] + "' not ready!!!"
+            quit(-1)
+        print '    ' + fname + ': modified shadow min,max:',vsend
+    else:
+        vsend[0] = vs[0]
+
+    if type(vs[0]) != type(np.float(1.)):
+        if vs[1] == 'range':
+            vsend[1] = np.max(varsv)
+    else:
+        vsend[1] = vs[1]
+
+    plt.rc('text', usetex=True)
+
+#    plt.pcolormesh(dxv, dyv, varsv, cmap=plt.get_cmap(colorbar), vmin=vsend[0], vmax=vsend[1])
+    plt.pcolormesh(varsvmask, cmap=plt.get_cmap(colorbar), vmin=vsend[0], vmax=vsend[1])
+    cbar = plt.colorbar()
+
+    newtposx = (tpos[0][:] - np.min(dxv)) * len(dxv) * Nng / (np.max(dxv) - np.min(dxv))
+    newtposy = (tpos[1][:] - np.min(dyv)) * len(dyv) * Nng / (np.max(dyv) - np.min(dyv))
+
+    plt.xticks(newtposx, tlabels[0])
+    plt.yticks(newtposy, tlabels[1])
+    plt.xlabel(ttits[0])
+    plt.ylabel(ttits[1])
+
+    plt.axes().set_aspect('equal')
+# From: http://stackoverflow.com/questions/14406214/moving-x-axis-to-the-top-of-a-plot-in-matplotlib
+    plt.axes().xaxis.tick_top
+    plt.axes().xaxis.set_ticks_position('top')
+
+# units labels
+    cbar.set_label(vnames.replace('_','\_') + ' (' + units_lunits(uts) + ')')
+
+    figname = 'Neighbourghood_evol'
+    graphtit = gtit.replace('_','\_').replace('&','\&')
+
+    plt.title(graphtit, position=(0.5,1.05))
+    
+    output_kind(kfig, figname, ifclose)
+
+    return
+
+def plot_lines(vardv, varvv, vaxis, dtit, linesn, vtit, vunit, gtit, kfig):
+    """ Function to plot a collection of lines
+      vardv= list of set of dimension values
+      varvv= list of set of values
+      vaxis= which axis will be used for the values ('x', or 'y')
+      dtit= title for the common dimension
+      linesn= names for the legend
+      vtit= title for the vaxis
+      vunit= units of the vaxis
+      gtit= main title
+      kfig= kind of figure
+      plot_lines([np.arange(10)], [np.sin(np.arange(10)*np.pi/2.5)], 'y', 'time (s)',      \
+  ['2.5'], 'sin', '-', 'sinus frequency dependency', 'pdf')
+    """
+    fname = 'plot_lines'
+
+    if vardv == 'h':
+        print fname + '_____________________________________________________________'
+        print plot_lines.__doc__
+        quit()
+
+# Canging line kinds every 7 lines (end of standard colors)
+    linekinds=['.-','x-','o-']
+
+    Ntraj = len(vardv)
+
+    N7lines = 0
+
+    plt.rc('text', usetex=True)
+
+    if vaxis == 'x':
+        for il in range(Ntraj):
+            plt.plot(varvv[il], vardv[il], linekinds[N7lines], label= linesn[il])
+            if il == 6: N7lines = N7lines + 1
+
+        plt.xlabel(vtit + ' (' + vunit + ')')
+        plt.ylabel(dtit)
+        plt.xlim(np.min(varvv[:]),np.max(varvv[:]))
+        plt.ylim(np.min(vardv[:]),np.max(vardv[:]))
+
+    else:
+        for il in range(Ntraj):
+            plt.plot(vardv[il], varvv[il], linekinds[N7lines], label= linesn[il])
+            if il == 6: N7lines = N7lines + 1
+
+        plt.xlabel(dtit)
+        plt.ylabel(vtit + ' (' + vunit + ')')
+        plt.xlim(np.min(vardv[:]),np.max(vardv[:]))
+        plt.ylim(np.min(varvv[:]),np.max(varvv[:]))
+
+    figname = 'lines'
+    graphtit = gtit
+
+    plt.title(graphtit)
+    plt.legend()
+    
+    output_kind(kfig, figname, True)
+
+    return
Index: trunk/tools/nc_var.py
===================================================================
--- trunk/tools/nc_var.py	(revision 192)
+++ trunk/tools/nc_var.py	(revision 192)
@@ -0,0 +1,230 @@
+#!/usr/bin/python
+## g.e. ccrc468-17 # ./nc_var.py -v time -f 123/CCRC_NARCliM_Sydney_All_1990-1999_pr10max.nc -o out -S 1:-1
+## g.e. ccrc468-17 # ./nc_var.py -v prac -f xyz/CCRC_NARCliM_Sydney_DAM_1990-1999_prac.nc -o mname -S pluja
+## g.e. ccrc468-17 # ./nc_var.py -v lluis -f CCRC_NARCliM_Sydney_MOM_1990-1999_prac.nc -o addref -S 'prac:standard_name@lluis_variable:long_name@test variable lluis:units@m s-1:0.'
+## g.e. ccrc468-17 # ./nc_var.py -v lluis66 -f ~/UNSW-CCRC-WRF/tools/python/CCRC_NARCliM_Sydney_MOM_1990-1999_prac.nc -o addattr -S 'comment|Lluis Fita-123456'
+## g.e. ccrc468-17 # ./nc_var.py -v lluis66 -f ~/UNSW-CCRC-WRF/tools/python/CCRC_NARCliM_Sydney_MOM_1990-1999_prac.nc -o rmvattr -S 'comment'
+## g.e. acuna # ./nc_var.py -f /d4/lflmd/etudes/WRF_LMDZ/WaquaL/WRF/control/wrfout/wrfout_d01_1979-12-01_00:00:00 -o checkallvars -S 'DateStrLen,Time,soil_layers_stag,bottom_top_stag,bottom_top,west_east_stag,west_east,south_north,south_north_stag:-3,1,2,2,2,-2,-2,-2,-2'
+## g.e. foudre # nc_var.py -f ~/etudes/WRF_LMDZ/tests/wrf_input/AR40.0/wrfout_d01_1979-01-01_00\:00\:00 -o checkallvars -S 'bottom_top_plus1,num_orchidee_soil_levels,lmdz_ksoil_types,DIM0009,DateStrLen,Time,soil_layers_stag,bottom_top_stag,bottom_top,west_east_stag,west_east,south_north,south_north_stag:2,0,0,1,-3,1,2,2,2,-2,-2,-2,-2'
+## g.e. # nc_var.py -o field_stats -f ~/etudes/domains/Polynesie/geo_em.d03.nc -S full -v HGT_M
+## g.e. # nc_var.py -o filter_2dim -S '80,y,x,lon,lat' -f 'tahiti_5m_ll.grd' -v 'z'
+
+from optparse import OptionParser
+import numpy as np
+from netCDF4 import Dataset as NetCDFFile
+import os
+import re
+import nc_var_tools as ncvar
+
+operations=['addvals', 'chdimname', 'checkallvars', 'checkAllValues', 'checkNaNs',   \
+  'chgtimestep', 'chvarname', 'compute_deaccum', 'compute_opersvarsfiles',           \
+  'compute_opervaralltime', 'compute_opervartimes', 'compute_tevolboxtraj',          \
+  'DataSetSection', 'DataSetSection_multidims', 'dimVar_creation', 'fattradd',       \
+  'fdimadd', 'fgaddattr', 'field_stats', 'file_oper_alongdims', 'filter_2dim',       \
+  'flipdim', 'fvaradd', 'gaddattrk', 'gaddattr', 'get_namelist_vars', 'grattr',      \
+  'grmattr', 'igattrs', 'isgattrs', 'isvattrs', 'ivars', 'ivattrs', 'maskvar',       \
+  'ncreplace', 'netcdf_concatenation', 'netcdf_fold_concatenation',                  \
+  'compute_opersvarsfiles',                                                          \
+  'seasmean', 'sellonlatbox', 'sellonlatlevbox', 'setvar_asciivalues',               \
+  'sorttimesmat', 'spacemean', 'statcompare_files', 'submns', 'subyrs', 'TimeInf',   \
+  'timemean', 'valmod', 'valmod_dim','varaddattrk', 'varaddattr', 'varaddref',       \
+  'varout', 'varoutold', 'varrmattr', 'varrm', 'vrattr', 'WRF_d0Nref',               \
+  'WRF_CFlonlat_creation', 'WRF_CFtime_creation', 'WRF_CFxtime_creation',            \
+  'list_operations']
+
+### Options
+##string_operation="operation to make: " + '\n' + " out, output values -S inidim1,[inidim2,...]:enddim1,[enddim2,...]"
+string_operation="""operation to make: 
+  addgattr, add a new global attribute: addatr -S [attrname]|[attrvalue]
+  addvattr, add a new attribute to any given variable: addatr -S [attrname]|[attrvalue]
+  addref, add a new variable with dimension and attributes from an already existing 'variable ref' in the file and -S [variable ref]:[attr name]@[value]:[[attr2]@[value2], ...]:[value/file with values]  mname, modify name -S newname
+  checkallvalrs: Function to check all variables of a file: -S [dimn1],[[dimn2],...,[dimnN]]:[dim1],[[dim2],...,[dimN]]
+  mname, modify name -S newname
+  out, output values -S inidim1,[inidim2,...]:enddim1,[enddim2,...]
+  valmod, modifiy values of variable -S [modification]:
+     sumc,[constant]: add [constant] to variables values
+     subc,[constant]: substract [constant] to variables values
+     mulc,[constant]: multipy by [constant] to variables values
+     divc,[constant]: divide by [constant] to variables values
+  rmgattr, remove a global attribute: rmgattr -S [attrname]
+  rmvattr, remove an attribute to any given variable: rmvattr -S [attrname]
+"""
+
+#print string_operation
+
+operationnames = "'" + ncvar.numVector_String(operations, "', '") + "'"
+
+parser = OptionParser()
+parser.add_option("-f", "--netCDF_file", dest="ncfile", 
+                  help="file to use", metavar="FILE")
+parser.add_option("-o", "--operation", type='choice', dest="operation", 
+  choices=operations, help="operation to make: " + operationnames, metavar="OPER")
+parser.add_option("-S", "--valueS (when applicable)", dest="values", 
+                  help="values to use according to the operation", metavar="VALUES")
+parser.add_option("-v", "--variable", dest="varname",
+                  help="variable to check", metavar="VAR")
+
+(opts, args) = parser.parse_args()
+
+#if opts.help:
+#  parser.print_help()
+#  print string_operation
+#  sys.exit()
+
+#######    #######
+## MAIN
+    #######
+
+# Operations which file name is not a real file
+NotCheckingFile = ['list_operations', 'netcdf_concatenation', 'netcdf_fold_concatenation']
+
+####### ###### ##### #### ### ## #
+errormsg='ERROR -- error -- ERROR -- error'
+
+varn=opts.varname
+oper=opts.operation
+
+if opts.ncfile is not None and not os.path.isfile(opts.ncfile) and                   \
+  not ncvar.searchInlist(NotCheckingFile,oper):
+    print errormsg
+    print '  File ' + opts.ncfile + ' does not exist !!'
+    quit(-1)
+
+if oper == 'addvals':
+    ncvar.addvals(opts.values, opts.ncfile, opts.varname)
+elif oper == 'chdimname':
+    ncvar.chdimname(opts.values, opts.ncfile, opts.varname)
+elif oper == 'checkallvars':
+    ncvar.checkallvars(opts.values, opts.ncfile)
+elif oper == 'checkAllValues':
+    ncvar.checkAllValues(opts.values, opts.ncfile)
+elif oper == 'checkNaNs':
+    ncvar.checkNaNs(opts.values, opts.ncfile)
+elif oper == 'chgtimestep':
+    ncvar.chgtimestep(opts.values, opts.ncfile, opts.varname)
+elif oper == 'chvarname':
+    ncvar.chvarname(opts.values, opts.ncfile, opts.varname)
+elif oper == 'compute_deaccum':
+    ncvar.compute_deaccum(opts.values, opts.ncfile, opts.varname)
+elif oper == 'compute_opersvarsfiles':
+    ncvar.compute_opersvarsfiles(opts.values, opts.varname)
+elif oper == 'compute_opervaralltime':
+    ncvar.compute_opervaralltime(opts.values, opts.ncfile, opts.varname)
+elif oper == 'compute_opervartimes':
+    ncvar.compute_opervartimes(opts.values, opts.ncfile, opts.varname)
+elif oper == 'compute_tevolboxtraj':
+    ncvar.compute_tevolboxtraj(opts.values, opts.ncfile, opts.varname)
+elif oper == 'DataSetSection':
+    ncvar.DataSetSection(opts.values, opts.ncfile)
+elif oper == 'DataSetSection_multidims':
+    ncvar.DataSetSection_multidims(opts.values, opts.ncfile)
+elif oper == 'dimVar_creation':
+    ncvar.dimVar_creation(opts.values, opts.ncfile)
+elif oper == 'fattradd':
+    ncvar.fattradd(var, opts.values, opts.ncfile)
+elif oper == 'fdimadd':
+    ncvar.fdimadd(opts.values, opts.ncfile)
+elif oper == 'fgaddattr':
+    ncvar.fgaddattr(opts.values, opts.ncfile)
+elif oper == 'file_oper_alongdims':
+    ncvar.file_oper_alongdims(opts.values, opts.ncfile, opts.varname)
+elif oper == 'field_stats':
+    ncvar.field_stats(opts.values, opts.ncfile, opts.varname)
+elif oper == 'filter_2dim':
+    ncvar.filter_2dim(opts.values, opts.ncfile, opts.varname)
+elif oper == 'flipdim':
+    ncvar.flipdim(opts.values, opts.ncfile, opts.varname)
+elif oper == 'fvaradd':
+    ncvar.fvaradd(opts.values, opts.ncfile)
+elif oper == 'gaddattrk':
+    ncvar.gaddattrk(opts.values, opts.ncfile)
+elif oper == 'gaddattr':
+    ncvar.gaddattr(opts.values, opts.ncfile)
+elif oper == 'get_namelist_vars':
+    ncvar.get_namelist_vars(opts.values, opts.ncfile)
+elif oper == 'grattr':
+    ncvar.grattr(opts.values, opts.ncfile)
+elif oper == 'grmattr':
+    ncvar.grmattr(opts.values, opts.ncfile)
+elif oper == 'igattrs':
+    ncvar.igattrs(opts.ncfile)
+elif oper == 'isgattrs':
+    ncvar.isgattrs(opts.values, opts.ncfile)
+elif oper == 'isvattrs':
+    ncvar.isvattrs(opts.values, opts.ncfile, opts.varname)
+elif oper == 'ivars':
+    ncvar.ivars(opts.ncfile)
+elif oper == 'ivattrs':
+    ncvar.ivattrs(opts.ncfile, opts.varname)
+elif oper == 'list_operations':
+# From: http://www.diveintopython.net/power_of_introspection/all_together.html
+    object = ncvar
+    for opern in operations:
+        if  opern != 'list_operations': 
+            print opern + '_______ ______ _____ ____ ___ __ _'
+            print getattr(object, opern).__doc__
+elif oper == 'maskvar':
+    ncvar.maskvar(opts.values, opts.ncfile, opts.varname)
+elif oper == 'ncreplace':
+    ncvar.ncreplace(opts.values, opts.ncfile, opts.varname)
+elif oper == 'netcdf_concatenation':
+    ncvar.netcdf_concatenation(opts.ncfile)
+elif oper == 'netcdf_fold_concatenation':
+    ncvar.netcdf_fold_concatenation(opts.values, opts.ncfile, opts.varname)
+elif oper == 'opersvarsfiles':
+    ncvar.compute_opersvarsfiles(opts.values, opts.varname)
+elif oper == 'seasmean':
+    ncvar.seasmean(timename, opts.ncfile, opts.varname)
+elif oper == 'sellonlatbox':
+    ncvar.sellonlatbox(opts.values, opts.ncfile, opts.varname)
+elif oper == 'sellonlatlevbox':
+    ncvar.sellonlatlevbox(opts.values, opts.ncfile, opts.varname)
+elif oper == 'setvar_asciivalues':
+    ncvar.setvar_asciivalues(opts.values, opts.ncfile, opts.varname)
+elif oper == 'sorttimesmat':
+    ncvar.sorttimesmat(opts.ncfile, opts.varname)
+elif oper == 'spacemean':
+    ncvar.spacemean(opts.ncfile, opts.varname)
+elif oper == 'statcompare_files':
+    ncvar.statcompare_files(opts.values)
+elif oper == 'submns':
+    ncvar.submns(opts.values, opts.ncfile, opts.varname)
+elif oper == 'subyrs':
+    ncvar.subyrs(opts.values, opts.ncfile, opts.varname)
+elif oper == 'TimeInf':
+    ncvar.TimeInf(opts.ncfile, opts.varname)
+elif oper == 'timemean':
+    ncvar.timemean(opts.values, opts.ncfile, opts.varname)
+elif oper == 'valmod':
+    ncvar.valmod(opts.values, opts.ncfile, opts.varname)
+elif oper == 'valmod_dim':
+    ncvar.valmod_dim(opts.values, opts.ncfile, opts.varname)
+elif oper == 'varaddattrk':
+    ncvar.varaddattrk(opts.values, opts.ncfile, opts.varname)
+elif oper == 'varaddattr':
+    ncvar.varaddattr(opts.values, opts.ncfile, opts.varname)
+elif oper == 'varaddref':
+    ncvar.varaddref(opts.values, opts.ncfile, opts.varname)
+elif oper == 'varout':
+    ncvar.varout(opts.values, opts.ncfile, opts.varname)
+elif oper == 'varoutold':
+    ncvar.varoutold(opts.values, opts.ncfile, opts.varname)
+elif oper == 'varrmattr':
+    ncvar.varrmattr(opts.values, opts.ncfile, opts.varname)
+elif oper == 'varrm':
+    ncvar.varrm(opts.ncfile, opts.varname)
+elif oper == 'vrattr':
+    ncvar.vrattr(opts.values, opts.ncfile, opts.varname)
+elif oper == 'WRF_d0Nref':
+    ncvar.WRF_d0Nref(opts.values, opts.ncfile)
+elif oper == 'WRF_CFlonlat_creation':
+    ncvar.WRF_CFlonlat_creation(opts.values, opts.ncfile, opts.varname)
+elif oper == 'WRF_CFtime_creation':
+    ncvar.WRF_CFtime_creation(opts.values, opts.ncfile, opts.varname)
+elif oper == 'WRF_CFxtime_creation':
+    ncvar.WRF_CFxtime_creation(opts.values, opts.ncfile, opts.varname)
+else:
+    print errormsg
+    print '   The operation ' + oper + ' is not ready !!'
+    print errormsg
+    quit()
Index: trunk/tools/nc_var_tools.py
===================================================================
--- trunk/tools/nc_var_tools.py	(revision 192)
+++ trunk/tools/nc_var_tools.py	(revision 192)
@@ -0,0 +1,12843 @@
+import numpy as np
+from netCDF4 import Dataset as NetCDFFile
+import os
+import re
+
+main = 'nc_var_tools.py'
+
+errormsg='ERROR -- error -- ERROR -- error'
+warnmsg='WARNING -- warning -- WARNING -- warning'
+
+fillValue = 1.e20
+
+def filexist(filen, emsg, fmsg):
+    """ Check existence of a file 
+    filen= file name
+    emsg= general error message
+    fmsg= message before generic text of inexistence of file
+    """
+    if not os.path.isfile(filen):
+        print emsg
+        print '  ' + fmsg + ' file "' + filen + '" does not exist !!'
+        print emsg
+        quit(-1)    
+
+def varinfile(ncf, filen, emsg, vmsg, varn):
+    """ Check existence of a variable inside a netCDF file 
+    ncf= netCDF object
+    filen= file name
+    emsg= general error message
+    vmsg= message before generic text of inexistence of variable
+    varn= variable name
+    """
+    if not ncf.variables.has_key(varn):
+        print emsg
+        print '  file "' + filen + '" does not have ' + vmsg + ' variable "' + varn + '" !!'
+        print emsg
+        ncf.close()
+        quit(-1)    
+
+class testvarinfile(object):
+    """ Check existence of a variable inside a netCDF file 
+    ncf= netCDF object
+    filen= file name
+    emsg= general error message
+    vmsg= message before generic text of inexistence of variable
+    varn= variable name
+    self.exist= boolean value of existence
+    self.message= error message
+    """
+    def __init__(self, ncf, filen, emsg, vmsg, varn):
+
+        if ncf is None:
+            self.exist= None
+            self.message = None
+        else:
+            if not ncf.variables.has_key(varn):
+                self.exist = False
+                self.message = emsg + '\n' + '  file "' + filen + '" does not have "' + vmsg + '" variable "' + varn + '" !!\n' + \
+                  emsg
+            else:
+                self.exist = True
+
+def attrinvar(varobj, emsg, vmsg, attrn):
+    """ Check existence of an attribute in a netCDF variable object
+    varobj= netCDF variable object
+    emsg= general error message
+    vmsg= message before generic text of inexistence of variable
+    attrrn= attribute name
+    """
+    varattrs = varobj.ncattrs()
+
+    if not isInlist(varattrs, attrn):
+        print emsg
+        print '  variable "' + varobj.name + '" does not have attribute ' + attrn + '" !!'
+        print emsg
+        ncf.close()
+        quit(-1)    
+
+def reduce_spaces(string):
+    """ Function to give words of a line of text removing any extra space
+    """
+    values = string.replace('\n','').split(' ')
+    vals = []
+    for val in values:
+         if len(val) > 0:
+             vals.append(val)
+
+    return vals
+
+def reduce_tabulars(string):
+    """ Function to give words of a line of text removing any extra space and tabular separation
+    """
+    values = string.replace('\n','').split('\t')
+    vals = []
+    for val in values:
+         if len(val) > 0:
+             vals.append(val)
+
+    return vals
+
+def valmodoper(varVal, valuesS):
+    """ Function to run the modification of a variable
+      varVAl= matrix with the values
+      valuesS= [modins],[[modval1],...,[modvalN]] modification instruction, value with which modify
+        [modins]: Modifiers:
+          sumc: add [modval1]
+          subc: remove [modval1]
+          mulc: multiply by [modval1]
+          divc: divide by [modval1]
+          lowthres: if [val] < [modval1]; val = [modval2]
+          upthres: if [val] > [modval1]; val = [modval2]
+          potc: [val] ** [modval1]
+    """
+    fname='valmodoper'
+
+    if valuesS == 'h':
+        print fname + '_____________________________________________________________'
+        print valmodoper.__doc__
+        quit()
+
+    valsS = valuesS.split(',')
+    modins = valsS[0]
+    modval = float(valsS[1])
+
+    if modins == 'sumc':
+        varVal[:] = varVal[:] + modval
+    elif modins == 'subc':
+        varVal[:] = varVal[:] - modval
+    elif modins == 'mulc':
+        varVal[:] = varVal[:] * modval
+    elif modins == 'divc':
+        varVal[:] = varVal[:] / modval
+    elif modins == 'lowthres':
+        varVal2 = np.where(varVal[:] < float(valsS[1]), float(valsS[2]), varVal[:])
+        varVal[:] = varVal2
+    elif modins == 'upthres':
+        varVal2 = np.where(varVal[:] > float(valsS[1]), float(valsS[2]), varVal[:])
+        varVal[:] = varVal2
+    elif modins == 'potc':
+        varVal[:] = varVal[:] ** modval
+    else: 
+        print errormsg
+        print '  valmodoper: Operation to modify values ' + modins + ' is not defined !!!'
+        print errormsg
+        quit(-1)
+
+    return varVal
+
+def valmod(values, ncfile, varn):
+    """ Function to modify the value of a variable
+    values = modins,[modval1],[...,[modvalN]]
+      modins = instruction: 
+        'sumc', add [modval1]
+        'subc', substraction [modval1]
+        'mulc', multiply by [modval1] 
+        'divc', divide by [modval1] 
+        'lowthres': modify all values below [modval1] to [modval2]
+        'upthres': modify all values above [modval1] to [modval2]
+        'potc': [val] ** [modval1]
+    ncfile = netCDF file name
+    varn = name of the variable
+    """
+    fname='valmod'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print valmod.__doc__
+        quit()
+
+    vals = values.split(',')
+    modins = vals[0]
+    modval = float(vals[1])
+
+    if not os.path.isfile(ncfile):
+      print errormsg
+      print '   ' + fname + ': File "' + ncfile + '" does not exist !!'
+      print errormsg
+      quit(-1)    
+
+    ncf = NetCDFFile(ncfile,'a')
+
+    if ncf.dimensions.has_key('plev'):
+      # removing pressure level from variable name
+      varn = re.sub("\d+", "", varn) 
+
+    if not ncf.variables.has_key(varn):
+      print errormsg
+      print '   ' + fname + ": File '" + ncfile + "' does not have variable '" +     \
+        varn + "' !!"
+      print errormsg
+      ncf.close()
+      quit(-1)
+
+    var = ncf.variables[varn]
+    varshape = var.shape
+    vartype = var.dtype
+    Ndims = len(varshape)
+    
+    varshapevals = list(varshape)
+    Nvars = len(varshape)
+   
+    if not Nvars == 0:
+        if Nvars == 1:
+            varvals = np.zeros(varshape[0], dtype=vartype) 
+        elif Nvars == 2:
+            varvals = np.zeros((varshape[0], varshape[1]), dtype=vartype)
+        elif Nvars == 3:
+            varvals = np.zeros((varshape[1], varshape[2]), dtype=vartype)
+        elif Nvars == 4:
+            varvals = np.zeros((varshape[2], varshape[3]), dtype=vartype) 
+        elif Nvars == 5:
+            varvals = np.zeros((varshape[3], varshape[4]), dtype=vartype)
+        elif Nvars == 6:
+            varvals = np.zeros((varshape[4], varshape[5]), dtype=vartype)
+        else:
+            print errormsg
+            print '  fvaradd: variable size ',Nvars,' is not ready!!!!'
+
+# Allocating all the necessary memory (just in case)
+
+        if Nvars <= 2:
+            varvals = var[:]
+            var[:] = valmodoper(varvals, values)
+        elif Nvars == 3:
+            for i in range(varshape[0]):
+                varvals[:] = var[i,:,:]
+                var[i,:,:] = valmodoper(varvals, values)
+        elif Nvars == 4:
+    	    for i in range(varshape[0]):
+                for j in range(varshape[1]):
+                    varvals[:] = var[i,j,:,:]
+                    var[i,j,:,:] = valmodoper(varvals, values)
+        elif Nvars == 5:
+  	    for i in range(varshape[0]):
+                for j in range(varshape[1]):
+                    for k in range(varshape[2]):
+                        varvals[:] = var[i,j,k,:,:]
+                        var[i,j,k,:,:] = valmodoper(varvals, values)
+        elif Nvars == 6:
+	    for i in range(varshape[0]):
+                for j in range(varshape[1]):
+                    for k in range(varshape[2]):
+                        for l in range(varshape[3]):
+                            varvals[:] = var[i,j,k,l,:,:]
+                            var[i,j,k,l,:,:] = valmodoper(varvals, values)
+
+    ncf.sync()
+    ncf.close()
+
+def rangedim(end, shape):
+    """Gives the instruction to retrieve values from a dimension of a variable
+    >>> print rangedim(-1, 15)
+    15
+    """
+    if end == -1:
+      return shape
+    else:
+      return end
+
+def varaddref(values, ncfile, varn):
+  """ Function to add a variable in an existing file copying characteristics from an existing one
+  values = [variable ref]:[attr name]@[value][:[attr2]@[value2], ...]:[value/file with values] add a 
+    new variable [varn] with dimension and attributes from an already existing [variable ref] with 
+    attributes [[attr name]@[value][:[attr2]@[value2], ...]] in the file [netcdf] and value 
+    [value/file with values]
+  netcdf = netCDF file name
+  varn = new variable name
+  """
+  fname = 'varaddref'
+
+  if values == 'h':
+      print fname + '_____________________________________________________________'
+      print varaddref.__doc__
+      quit()
+
+  varvalues = values.split(':')
+
+  Nvarvalues = len(varvalues)
+  varprev = varvalues[0]
+  newattrs = {}
+  for iattr in range(Nvarvalues - 2):
+    attrv = varvalues[iattr+1]
+    newattrs[attrv.split('@')[0]] = attrv.split('@')[1]
+
+  ncf = NetCDFFile(ncfile,'a')
+
+  if ncf.variables.has_key(varn):
+    print errormsg
+    print '   varaddref: File already has the varible ' + varn + ' !!!'
+    print errormsg
+    ncf.close()
+    quit(-1)
+
+  if not ncf.variables.has_key(varprev):
+    print errormsg
+    print '    varaddref: File does not have variable ' + varprev + ' !!!!'
+    print errormsg
+    ncf.close()
+    quit(-1)
+
+  varp = ncf.variables[varprev]
+  varpVal = varp[:]
+  varpshape = varp.shape
+  Nvarpshape = len(varpshape)
+  varpattrs = varp.ncattrs()
+  varptype = varp.dtype
+  varpdims = varp.dimensions
+  varpndims = varp.ndim
+
+##  print '  shape of the variable used as reference: ',varpshape
+#
+# variable characteristics 
+  if len(varpshape) == 4:
+    dimpt = varpshape[0]
+    dimpz = varpshape[1]
+    dimpy = varpshape[2]
+    dimpx = varpshape[3]
+  elif len(varpshape) == 3:
+    dimpt = varpshape[0]
+    dimpy = varpshape[1]
+    dimpx = varpshape[2]
+  elif len(varpshape) == 3:
+    dimpy = varpshape[0]
+    dimpx = varpshape[1]
+
+  newvar = ncf.createVariable(varn, varptype, dimensions=varpdims)
+  newvar = ncf.variables[varn]
+#
+# Values
+  varplen=1
+  for idim in range(varpndims):
+    varplen=varplen*varpshape[idim]
+
+  if varptype == 'float' or varptype == 'float32' or varptype == 'float64' or vartype == np.float(1.) or vartype == np.float32(1.):
+    newvals = np.reshape(np.arange(varplen), varpshape)*1.
+  else:
+    newvals = np.reshape(np.arange(varplen), varpshape)
+
+  if not os.path.isfile(varvalues[Nvarvalues-1]):
+##    print '  Using constant value'
+    newvals[:] = float(varvalues[Nvarvalues-1])
+  else:
+##    print '  Using 2-D values from ' + varvalues[Nvarvalues-1]
+    asciif = open(varvalues[Nvarvalues-1], 'r')
+
+    fdimx = len(asciif.readlines())
+    asciif.seek(0)
+
+    if len(varpshape) == 4:
+      if not fdimx == dimpx:
+        print errormsg
+        print '   varaddref: Provided file has dimx=', fdimx, ' and variable has dimx=', dimpx, ' !!!'
+        print errormsg
+        ncf.close()
+        quit(-1)
+
+      iline = 0
+      idx = 0
+      for fline in asciif:
+        line = fline.replace('\n','')
+        yvals = []
+        for iyval in line.split('     '):
+          yvals.append(float(iyval))
+
+        if iline == 0:
+          fdimy = len(yvals)
+          if not fdimy == dimpy:
+            print errormsg
+            print '    varaddref: Provided file has dimy=', fdimy, ' and variable has dimy= ', dimpy, ' !!!'
+            print errormsg
+            ncf.close()
+            quit(-1)
+        for it in range(dimpt):
+          for iz in range(dimpz):
+            newvals[it,iz,:,idx] = yvals
+  
+        idx = idx+1
+        iline = iline+1
+
+    elif len(varpshape) == 3:
+      if not fdimx == dimpx:
+        print errormsg
+        print '    varaddref: Provided file has dimx=', fdimx, ' and variable has dimx=', dimpx, ' !!!'
+        print errormsg
+        ncf.close()
+        quit(-1)
+
+      iline = 0
+      idx = 0
+      for fline in asciif:
+        line = fline.replace('\n','')
+        yvals = []
+        for iyval in line.split('     '):
+          yvals.append(float(iyval))
+
+        if iline == 0:
+          fdimy = len(yvals)
+          if not fdimy == dimpy:
+            print errormsg
+            print '    varaddref: Provided file has dimy=', fdimy, ' and variable has dimy= ',dimpy, ' !!!'
+            print errormsg
+            ncf.close()
+            quit(-1)
+        for it in range(dimpt):
+          newvals[it,:,idx] = yvals
+
+        idx = idx+1
+        iline = iline+1
+    elif len(varpshape) == 2:
+      if not fdimx == dimpx:
+        print errormsg
+        print '    varaddref: Provided file has dimx=', fdimx, ' and variable has dimx=', dimpx, ' !!!'
+        print errormsg
+        ncf.close()
+        quit(-1)
+
+      iline = 0
+      idx = 0
+      for fline in asciif:
+        line = fline.replace('\n','')
+        yvals = []
+        for iyval in line.split('     '):
+          yvals.append(float(iyval))
+
+        if iline == 0:
+          fdimy = len(yvals)
+          if not fdimy == dimpy:
+            print errormsg
+            print '    varaddref: Provided file has dimy=', fdimy, ' and variable has dimy= ',dimpy, ' !!!'
+            print errormsg
+            ncf.close()
+            quit(-1)
+
+        newvals[:,idx] = yvals
+        idx = idx+1
+        iline = iline+1
+
+  asciif.close()
+  newvar[:] = newvals
+
+#
+# Attributes
+  for iattr in range(len(varpattrs)):
+    attrn = varpattrs[iattr]
+    attrval = varp.getncattr(attrn)
+
+    if attrn in newattrs:
+      newattr = newvar.setncattr(attrn, newattrs[attrn])
+    else:
+      newattr = newvar.setncattr(attrn, attrval)
+
+  ncf.sync()
+  ncf.close()
+
+def varoutold(values, ncfile, varn):
+  """ Function when we want to output variable values
+  values = [optsIrange]:[optsErange]
+    [optsIrange]: val1,val2,...,valN inital value for the 'N' dimensions of the variable
+    [optsErange]: val1,val2,...,valN ending value for the 'N' dimensions of the variable
+  ncfile = netCDF file name
+  varn = variable name
+  """
+  import numpy as np
+  from netCDF4 import Dataset as NetCDFFile
+
+  optsIrange = values.split(':')[0]
+  optsErange = values.split(':')[1]
+
+  inirange=optsIrange.split(',')
+  endrange=optsErange.split(',')
+
+  irange = [int(val) for val in inirange]
+  erange = [int(val) for val in endrange]
+
+  if not len(irange) == len(erange):
+    print errormsg
+    print '    varout: Different number of values in each range!'
+    print '    varout: initial range: ' + optsIrange
+    print '    varout: ending range: ' + optsErange
+    print errormsg
+    quit(-1)
+  else:
+    ndims=len(irange)
+ 
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    varout: File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'r')
+
+  if ncf.dimensions.has_key('plev'):
+    # removing pressure level from variable name
+    varn = re.sub("\d+", "", varn) 
+
+  if not ncf.variables.has_key(varn):
+    print errormsg
+    print '    varout: File "' + ncfile + '" does not have variable "' + varn + '" !!!!'
+    print errormsg
+    ncf.close()
+    quit(-1)
+
+  var = ncf.variables[varn]
+
+  varshape = var.shape
+  Nvarshape = len(varshape)
+ 
+  if not Nvarshape == ndims:
+    print errormsg
+    print '    varout: Provided number of values of the range ' + ndims + ' is different of the shape of the variable ' + Nvarshape + ' !!!'
+    print errormsg
+    ncf.close()
+    quit(-1)
+
+  if Nvarshape == 1:
+    varValrange = var[irange[0]:rangedim(erange[0], varshape[0])]
+  elif Nvarshape == 2:
+    varValrange = var[irange[0]:rangedim(erange[0], varshape[0]),                               \
+      irange[1]:rangedim(erange[1]), varshape[1]]
+  elif Nvarshape == 3:
+    varValrange = var[irange[0]:rangedim(erange[0], varshape[0]),                               \
+      irange[1]:rangedim(erange[1], varshape[1]), irange[2]:rangedim(erange[2], varshape[2])]
+  elif Nvarshape == 4:
+    varValrange = var[irange[0]:rangedim(erange[0], varshape[0]),                               \
+      irange[1]:rangedim(erange[1], varshape[1]), irange[2]:rangedim(erange[2], varshape[2]),      \
+      irange[3]:rangedim(erange[3], varshape[3])]
+  elif Nvarshape == 5:
+    varValrange = var[irange[0]:rangedim(erange[0], varshape[0]),                               \
+      irange[1]:rangedim(erange[1], varshape[1]), irange[2]:rangedim(erange[2], varshape[2]),      \
+      irange[3]:rangedim(erange[3], varshape[3]), irange[4]:rangedim(erange[4], varshape[4])]
+  elif Nvarshape == 6:
+    varValrange = var[irange[0]:rangedim(erange[0], varshape[0]),                               \
+      irange[1]:rangedim(erange[1], varshape[1]), irange[2]:rangedim(erange[2], varshape[2]),      \
+      irange[3]:rangedim(erange[3], varshape[3]), irange[4]:rangedim(erange[4], varshape[4]),      \
+      irange[5]:rangedim(erange[5], varshape[5])]
+
+  ncf.close()
+
+  Nshaperange = len(varValrange.shape)
+  Noneshape = 0
+  for ir in range(Nshaperange):
+    if varValrange.shape[ir] == 1:
+      Noneshape = Noneshape + 1
+
+  if Noneshape == Nshaperange - 1:
+    for i in range(len(varValrange)):
+      print '%2s %f' % ( 'NC', varValrange[i] )
+
+
+def varout(values, ncfile, varn):
+    """ Function when we want to output variable values
+    values = [dimname1]:[valdim1]|[dimname2]:[valdim2]|[...,[dimnameN]:[valdimN]]
+      [valdim]: 
+        * [integer]: which value of the dimension
+        * -1: all along the dimension
+        * [beg]:[end] slice from [beg] to [end]
+    ncfile = netCDF file name
+    varn = variable name
+    """
+
+    fname = 'varout'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print varout.__doc__
+        quit()
+
+    ncobj = NetCDFFile(ncfile, 'r')
+
+    if  not ncobj.variables.has_key(varn):
+        print errormsg
+        print '  ' + fname + ': file "' + ncfile + '" does not have variable "' +    \
+          varn + '" !!'
+        quit(-1)
+
+    vobj = ncobj.variables[varn]
+
+    newvar, newdims = slice_variable(vobj, values)
+
+    Nnewdims = len(newdims)
+    
+    if Nnewdims == 1:
+        for i in range(newvar.shape[0]):
+            print '%2s %f' % ( 'NC',newvar[i] )
+    elif Nnewdims == 2:
+        for i0 in range(newvar.shape[0]):
+            row = numVector_String(newvar[i0,:],' ')
+            print 'NC ' + row
+    else:
+        for i0 in range(newvar.shape[Nnewdims-2]):
+            varslice = []
+            dimsinf = ''
+            for idim in range(Nnewdims - 2):
+                for d in range(newvar.shape[idim]):
+                    if idim == 0: 
+                        dimsinf = newdims[idim] + ': ' + str(d)
+                    else:
+                        dimsinf = dimsinf + ' ' + newdims[idim] + ': ' + str(d)
+
+                    varslice.append(d)
+
+            varslice.append(i0)
+            varslice.append(0,newvar.shape[Nnewdims-1])
+
+            row = numVector_String(newvar[tuple(varslice)],' ')
+            print 'NCinf ' + dimsinf + '_________________'
+            print 'NC ' + row
+
+    ncobj.close()
+
+    return
+
+def chdimname(values, ncfile, varn):
+  """ Changing the name of the dimension
+  values = [olddimname]:[newdimname]
+    [olddimname]: old name of the dimension
+    [newdimname]: new name of the dimension
+  ncfile = netCDF file name
+  varn = variable name
+  """
+
+  fname = 'chdimname'
+
+  if values == 'h':
+        print fname + '_____________________________________________________________'
+        print chdimname.__doc__
+        quit()
+
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    chdimname: File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'a')
+
+  olddimname=values.split(':')[0]
+  newdimname=values.split(':')[1]
+
+  if not ncf.dimensions.has_key(olddimname):
+    print warnmsg
+    print '    chdimname: File "' + ncfile + '" does not have dimension "' + olddimname + '" !!!!'
+    ncf.close()
+    quit()
+
+  if not olddimname == newdimname and not ncf.dimensions.has_key(newdimname):
+      newname = ncf.renameDimension(olddimname, newdimname)
+      ncf.sync()
+      ncf.close()
+  else:
+      print warnmsg
+      print '    chdimname: File "' + ncfile + '" already has dimension name "' + newdimname + '" '
+      print '    chdimname: modifying all the variables which use the old dimension'
+      filevars = ncf.variables
+      for fvarn in filevars:
+          if ncf.variables.has_key(fvarn):
+              fvar = ncf.variables[fvarn]
+              fvardims = fvar.dimensions
+              if searchInlist(fvardims, olddimname):
+                  print '    variable "' + fvarn + '" uses dimension "' + olddimname + '" '
+                  varinf = variable_inf(fvar)
+
+                  newdims = tuple(fvardims)
+                  change = {olddimname: newdimname}
+# From http://stackoverflow.com/questions/9067043/python-replace-list-values-using-a-tuple
+                  newdims = tuple([ change.get(x,x) for x in fvardims ])
+                  newvar = ncf.createVariable(fvarn + 'tmpdname', varinf.dtype, newdims, fill_value=varinf.FillValue)
+                  varv = fvar[:]
+                  newvar[:] = varv
+
+                  for attrn in varinf.attributes:
+                      attrv = fvar.getncattr(attrn)
+                      newar = newvar.setncattr(attrn, attrv)
+
+                  fvar = ncf.renameVariable(fvarn, fvarn + 'rmdname')
+                  ncf.sync()
+                  newvar = ncf.renameVariable(fvarn + 'tmpdname', fvarn)
+                  ncf.sync()
+                  ncf.close()
+                  varrm(ncfile, fvarn + 'rmdname')
+                  ncf = NetCDFFile(ncfile,'a')
+
+def chvarname(values, ncfile, varn):
+  """Changing the name of the variable
+  values = new variable name
+  ncfile = netCDF file
+  varn = name of the variable
+  """
+  fname = 'chvarname'
+
+  if values == 'h':
+      print fname + '_____________________________________________________________'
+      print chvarname.__doc__
+      quit()
+
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    ' + fname + ': File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'a')
+
+  if ncf.dimensions.has_key('plev'):
+    # removing pressure level from variable name
+    varn = re.sub("\d+", "", varn) 
+
+  if not ncf.variables.has_key(varn):
+    print warnmsg
+    print '    ' + fname + ': File does not have variable "' + varn + '" !!!!'
+    ncf.close()
+    quit(-1)
+
+  if not varn == values and not ncf.variables.has_key(values):
+    newname = ncf.renameVariable(varn, values)
+
+  ncf.sync()
+  ncf.close()
+
+def searchInlist(listname, nameFind):
+    """ Function to search a value within a list
+    listname = list
+    nameFind = value to find
+    >>> searInlist(['1', '2', '3', '5'], '5')
+    True
+    """
+    for x in listname:
+      if x == nameFind:
+        return True
+    return False
+
+def set_attribute(ncv, attrname, attrvalue):
+    """ Sets a value of an attribute of a netCDF variable. Removes previous attribute value if exists
+    ncv = object netcdf variable
+    attrname = name of the attribute
+    attrvalue = value of the attribute
+    """
+
+    attvar = ncv.ncattrs()
+    if searchInlist(attvar, attrname):
+        attr = ncv.delncattr(attrname)
+
+    attr = ncv.setncattr(attrname, attrvalue)
+
+    return attr
+
+def set_attributek(ncv, attrname, attrval, attrkind):
+    """ Sets a value of an attribute of a netCDF variable with a kind. Removes previous attribute value if exists
+    ncvar = object netcdf variable
+    attrname = name of the attribute
+    attrvalue = value of the attribute
+    atrtrkind = kind of attribute: 'S', string ('!' as spaces); 'I', integer; 'Inp32', numpy integer 32;
+       'R', real; ' npfloat', np.float; 'D', np.float64
+    """
+
+    if attrkind == 'S':
+        attrvalue = str(attrval.replace('!', ' '))
+    elif attrkind == 'I':
+        attrvalue = int(attrval)
+    elif attrkind == 'Inp32':
+        attrvalue = np.int32(attrval)
+    elif attrkind == 'R':
+        attrvalue = float(attrval)
+    elif attrkind == 'npfloat':
+        attrvalue = np.float(attrval)
+    elif attrkind == 'D':
+        attrvalue = np.float64(attrval)
+    else:
+        print errormsg
+        print '    set_attributek: "' + attrkind + '" kind of attribute is not ready!'
+        quit(-1)
+
+    attvar = ncv.ncattrs()
+    if searchInlist(attvar, attrname):
+        attr = ncv.delncattr(attrname)
+
+    attr = ncv.setncattr(attrname, attrvalue)
+    
+    return attr
+
+def basicvardef(varobj, vstname, vlname, vunits):
+    """ Function to give the basic attributes to a variable
+    varobj= netCDF variable object
+    vstname= standard name of the variable
+    vlname= long name of the variable
+    vunits= units of the variable
+    """
+    attr = varobj.setncattr('standard_name', vstname)
+    attr = varobj.setncattr('long_name', vlname)
+    attr = varobj.setncattr('units', vunits)
+
+    return
+
+def gaddattr(values, ncfile):
+  """ Add a global attribute to a netCDF. Removes previous attribute if it exist
+  values = [attrname]|[attrvalue ('!' as spaces)]
+  ncfile = netCDF file
+  """
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    gaddattr: File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'a')
+
+  attrvals=values.split('|')
+  attrn=attrvals[0]
+  attrv=attrvals[1].replace('!', ' ')
+
+  ncf = set_attribute(ncf, attrn, attrv)
+
+  ncf.sync()
+  ncf.close()
+
+def gaddattrk(values, ncfile):
+  """ Add a global attribute to a netCDF caring about the type. Removes previous attribute if it exist
+  values = [attrname]|[attrvalue]|[attrk]
+    attrname = name of the attribute
+    attrvalue = value of the attribute
+    attrk = 'S', string ('!' as spaces); 'I', integer;  'Inp32', numpy integer 32; 'R', real; 'D', double
+  ncfile = netCDF file
+  """
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    gaddattrk: File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'a')
+
+  attrvals=values.split('|')
+  attrn=attrvals[0]
+  attrv0=attrvals[1]
+  attrk=attrvals[2]
+
+  if attrk == 'S':
+    attrv = str(attrv0.replace('!', ' '))
+  elif attrk == 'I':
+    attrv = int(attrv0)
+  elif attrk == 'Inp32':
+    attrv = np.int32(attrv0)
+  elif attrk == 'R':
+    attrv = float(attrv0)
+  elif attrk == 'D':
+    attrv = np.float64(attrv0)
+  else:
+    print errormsg
+    print '    gaddattrk: "' + attrk + '" kind of attribute is not ready!'
+    ncf.close()
+    quit(-1)
+
+  ncf = set_attribute(ncf, attrn, attrv)
+
+  ncf.sync()
+  ncf.close()
+
+def varaddattr(values, ncfile, varn):
+  """ Add an attribute to a variable. Removes previous attribute if it exists
+  values = [attrname]|[attrvalue('!' as spaces)]
+  ncfile = netCDF file name
+  varn = name of the variable
+  """
+  fname = 'varaddattr'
+
+  if values == 'h':
+      print fname + '_____________________________________________________________'
+      print varaddattr.__doc__
+      quit()
+
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    ' + fname +': File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'a')
+
+  if ncf.dimensions.has_key('plev'):
+    # removing pressure level from variable name
+    varn = re.sub("\d+", "", varn) 
+
+  if not ncf.variables.has_key(varn):
+    print errormsg
+    print '    ' + fname +': File "' + ncfile + '" does not have variable "' + varn + '" !!!!'
+    print errormsg
+    ncf.close()
+    quit(-1)
+
+  attrvals=values.split('|')
+  attrn=attrvals[0]
+  attrv=attrvals[1].replace('!', ' ')
+
+  var = ncf.variables[varn]
+  var = set_attribute(var, attrn, attrv)
+
+  ncf.sync()
+  ncf.close()
+
+def varaddattrk(values, ncfile, varn):
+  """ Add an attribute to a variable caring about the type
+  values = [attrname]|[attrvalue]|[attrk]
+    attrname = name of the attribute
+    attrvalue = value of the attribute
+    attrk = 'S', string ('!' as spaces); 'I', integer; 'R', real; 'D', double; 
+      'npR', numpy Real, 'npR32', numpy Real-32
+  ncfile = netCDF file
+  varn = variable name
+  """
+  fname = 'varaddattrk'
+
+  if values == 'h':
+      print fname + '_____________________________________________________________'
+      print varaddattrk.__doc__
+      quit()
+
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    ' + fname + ': File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'a')
+
+  if ncf.dimensions.has_key('plev'):
+    # removing pressure level from variable name
+    varn = re.sub("\d+", "", varn) 
+
+  if not ncf.variables.has_key(varn):
+    print errormsg
+    print '    ' + fname + ': File "' + ncfile + '"does not have variable ' + varn + ' !!!!'
+    print errormsg
+    ncf.close()
+    quit(-1)
+
+  attrvals=values.split('|')
+  attrn=attrvals[0]
+  attrv0=attrvals[1]
+  attrk=attrvals[2]
+
+  var = ncf.variables[varn]
+  if attrk == 'S':
+    attrv = str(attrv0.replace('!', ' '))
+  elif attrk == 'I':
+    attrv = int(attrv0)
+  elif attrk == 'R':
+    attrv = float8(attrv0)
+  elif attrk == 'D':
+    attrv = np.float64(attrv0)
+  elif attrk == 'npR':
+    attrv = np.float(attrv0)
+  elif attrk == 'npR32':
+    attrv = np.float32(attrv0)
+  else:
+    print errormsg
+    print '    ' + fname + ': "' + attrk + '" kind of attribute is not ready!'
+    ncf.close()
+    quit(-1)
+
+  var = set_attribute(var, attrn, attrv)
+
+  ncf.sync()
+  ncf.close()
+
+def varrmattr(values, ncfile, varn):
+  """ Removing an attribute from a variable
+  values = attribute name
+  ncfile = netCDF file name
+  varn = variable name
+  """
+  fname = 'varrmattr'
+  if values == 'h':
+      print fname + '_____________________________________________________________'
+      print varrmattr.__doc__
+      quit()
+
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    ' + fname +': File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'a')
+
+  if ncf.dimensions.has_key('plev'):
+    # removing pressure level from variable name
+    varn = re.sub("\d+", "", varn) 
+
+  if not ncf.variables.has_key(varn):
+    print errormsg
+    print '    ' + fname +': File "' + ncfile + '" does not have variable "' + varn + '" !!!!'
+    print errormsg
+    ncf.close()
+    quit(-1)
+
+  var = ncf.variables[varn]
+
+  attvar = var.ncattrs()
+  if searchInlist(attvar, values):
+      attr = var.delncattr(values)
+  else:
+      print warnmsg
+      print '    ' + fname +': "' + varn + '" does not have attribute: ' + values
+
+  ncf.sync()
+  ncf.close()
+
+def grmattr(values, ncfile):
+  """ Removing a global attribute
+  values = attribute name
+  ncfile = netCDF file
+  """
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    grmattr: File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'a')
+
+  attvar = ncf.ncattrs()
+  if searchInlist(attvar, values):
+      attr = ncf.delncattr(values)
+  else:
+      print warnmsg
+      print '  grmattr: "' + ncfile + '" does not have attribute: ' + values
+
+  ncf.sync()
+  ncf.close()
+
+def fvaradd(values, ncfile):
+  """ Adding variable (and all its attributes and dimensions) from a reference file to a file
+  values = [netCDFref]:[varnref]
+    netCDFref = netCDF file name as reference for the variable to add
+    varnref = name of the variable from [netCDFref] to be added
+  ncfile = netCDF file name
+  """
+
+  fname = 'fvaradd'
+
+  if values == 'h':
+      print fname + '_____________________________________________________________'
+      print fvaradd.__doc__
+      quit()
+
+  refnc = values.split(':')[0]
+  refvar = values.split(':')[1]
+
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    fvaradd: File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  if not os.path.isfile(refnc):
+    print errormsg
+    print '    fvaradd: Reference file "' + refnc + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'a')
+  ncref = NetCDFFile(refnc,'r')
+
+  refvars = ncref.variables
+  if searchInlist(refvars, refvar):
+      refvarv = ncref.variables[refvar]
+  else:
+      print errormsg
+      print '    fvaradd: File "' + refnc + '" does not have variable: ' + refvar
+      ncf.close()
+      ncref.close()
+      quit(-1)
+
+  vardims = refvarv.dimensions
+  vartype = refvarv.dtype
+  varattr = refvarv.ncattrs()
+
+# Checking dimensions
+##
+  newdims = ncf.dimensions
+  for rdim in vardims:
+      if not searchInlist(newdims, rdim):
+          print '      fvaradd: Adding dimension ' + rdim
+          ncf.close()
+          ncref.close()
+          fdimadd(refnc + ',' + rdim, ncfile)
+          ncf = NetCDFFile(ncfile,'a')
+          ncref = NetCDFFile(refnc,'r')
+
+# Checking fill value
+## 
+  if searchInlist(varattr, '_FillValue'):
+      varfil = refvarv._FillValue
+  else:
+      varfil = False
+
+  print '      fvaradd: Adding refvar:', refvar, 'shape: ', refvarv.shape
+  var = ncf.createVariable(refvar, vartype, vardims, fill_value=varfil)
+
+  varshape = refvarv.shape
+  Nvars = len(varshape)
+   
+  if not Nvars == 0:
+      if Nvars == 1:
+          varvals = np.zeros(varshape[0], dtype=vartype) 
+      elif Nvars == 2:
+          varvals = np.zeros((varshape[0], varshape[1]), dtype=vartype)
+      elif Nvars == 3:
+          varvals = np.zeros((varshape[0], varshape[1], varshape[2]), dtype=vartype)
+      elif Nvars == 4:
+          varvals = np.zeros((varshape[0], varshape[1], varshape[2], varshape[3]), dtype=vartype) 
+      elif Nvars == 5:
+          varvals = np.zeros((varshape[0], varshape[1], varshape[2], varshape[3], varshape[4]), dtype=vartype)
+      elif Nvars == 6:
+          varvals = np.zeros((varshape[0], varshape[1], varshape[2], varshape[3], varshape[4], varshape[5]), dtype=vartype)
+      else:
+          print errormsg
+          print '  fvaradd: variable size ',Nvars,' is not ready!!!!'
+
+# Allocating all the necessary memory (just in case)
+      var[:] = varvals
+
+      if Nvars <= 2:
+          varvals = refvarv[:]
+          var[:] = varvals
+      elif Nvars == 3:
+          for i in range(varshape[0]):
+              varvals[i,:,:] = refvarv[i,:,:]
+              var[i,:,:] = varvals[i,:,:]
+      elif Nvars == 4:
+	  for i in range(varshape[0]):
+              for j in range(varshape[1]):
+                  varvals[i,j,:,:] = refvarv[i,j,:,:]
+                  var[i,j,:,:] = varvals[i,j,:,:]
+      elif Nvars == 5:
+	  for i in range(varshape[0]):
+              for j in range(varshape[1]):
+                  for k in range(varshape[2]):
+                      varvals[i,j,k,:,:] = refvarv[i,j,k,:,:]
+                      var[i,j,k,:,:] = varvals[i,j,k,:,:]
+      elif Nvars == 6:
+	  for i in range(varshape[0]):
+              for j in range(varshape[1]):
+                  for k in range(varshape[2]):
+                      for l in range(varshape[3]):
+                          varvals[i,j,k,l,:,:] = refvarv[i,j,k,l,:,:]
+                          var[i,j,k,l,:,:] = varvals[i,j,k,l,:,:]
+
+  newvar = ncf.variables[refvar]
+  for attr in varattr:
+      newvarattrs = newvar.ncattrs()
+      attrv = refvarv.getncattr(attr)
+      if not searchInlist(newvarattrs, attr):     
+          newvar.setncattr(attr, attrv)
+
+  ncf.sync()
+  ncf.close()
+  ncref.close()
+
+def fdimadd(values, ncfile):
+  """ Adding dimension from another reference file 
+  values = [refnc],[refdim]
+    refnc = netCDF file name as reference
+    refdim = name of the dimension to be added
+  ncfile = netCDF file name
+  """
+  fname='fdimadd'
+
+  refnc = values.split(',')[0]
+  refdim = values.split(',')[1]
+
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    ' + fname + ': File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  if not os.path.isfile(refnc):
+    print errormsg
+    print '    ' + fname + ': Reference file "' + refnc + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'a')
+  ncref = NetCDFFile(refnc,'r')
+
+  refdims = ncref.dimensions
+  if searchInlist(refdims, refdim):
+      refdimv = ncref.dimensions[refdim]
+  else:
+      print errormsg
+      print '    ' + fname + ': File "' + refnc + '" does not have dimension: "' + refdim + '"'
+      ncf.close()
+      ncref.close()
+      quit(-1)
+
+  if refdimv.isunlimited():
+      print '      ' + fname + ': Unlimited dimension '
+      dimsize = None
+  else:
+      dimsize = len(refdimv)
+
+  print '      ' + fname + ': Adding refdim:', refdim, 'size:', dimsize
+  dim = ncf.createDimension(refdim, dimsize)
+  
+  ncf.sync()
+  ncf.close()
+  ncref.close()
+
+def fattradd(var, values, ncfile):
+  """ Adding attributes from a reference file
+  var = variable to which has to be added the attribute
+  values = [refnc]:[refvar]
+    refnc = netCDF file name as reference
+    refvar = variable from the reference file
+  ncfile = netCDF file name
+  """
+
+  refnc = values.split(':')[0]
+  refvar = values.split(':')[1]
+
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    fattradd: File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  if not os.path.isfile(refnc):
+    print errormsg
+    print '    fattradd: Reference file "' + refnc + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'a')
+  ncref = NetCDFFile(refnc,'r')
+
+  vars = ncf.variables
+  if searchInlist(vars, var):
+      varv = ncf.variables[var]
+  else:
+      print '  fattradd: File "' + ncfile + '" does not have variable: "' + var + '"'
+      ncf.close()
+      ncref.close()
+      quit(-1)
+
+  refvars = ncref.variables
+  if searchInlist(refvars, refvar):
+      refvarv = ncref.variables[refvar]
+  else:
+      print '    fattradd: File "' + refnc + '" does not have variable: "' + refvar + '"'
+      ncf.close()
+      ncref.close()
+      quit(-1)
+
+  refvarattrs = refvarv.ncattrs()
+  Nattrs = len(refvarattrs)
+  print '      fattradd: Adding ', Nattrs,' atributes from:', refvar
+
+  for attr in refvarattrs:
+      attrv = refvarv.getncattr(attr)
+      atvar = set_attribute(varv, attr, attrv)
+  
+  ncf.sync()
+  ncf.close()
+  ncref.close()
+
+def fgaddattr(values, ncfile):
+  """ Adding global attributes from a reference file
+  values = netCDF file name as reference
+  ncfile = netCDF file name
+  """
+
+  refnc = values
+
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    fgaddattr: File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  if not os.path.isfile(refnc):
+    print errormsg
+    print '    fgaddattr: Reference file "' + refnc + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'a')
+  ncref = NetCDFFile(refnc,'r')
+
+  refgattrs = ncref.ncattrs()
+  Nattrs = len(refgattrs)
+  print '      fgaddattr: Adding ', Nattrs,' global atributes'
+
+  for attr in refgattrs:
+      attrv = ncref.getncattr(attr)
+      atvar = set_attribute(ncf, attr, attrv)
+  
+  ncf.sync()
+  ncf.close()
+  ncref.close()
+
+def varrm(ncfile, var):
+  """ Removing a variable from a file
+  ncfile = netCDF object file
+  var = variable name to remove
+  """
+  import shutil as shu
+  fname = 'varrm'
+
+  if var == 'h':
+      print fname + '_____________________________________________________________'
+      print varrm.__doc__
+      quit()
+
+
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    varrm: File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'a')
+  ncvars = ncf.variables
+  ncf.close()
+
+  if not searchInlist(ncvars, var):
+      print '    varrm: File "' + ncfile + '" does not have variable: "' + var + '"'
+      ncf.close()
+      quit(-1)
+
+  tmpncf = NetCDFFile('tmp_py.nc' , 'w')
+  gtmpattr = set_attribute(tmpncf, 'copy', 'temporal')
+  tmpncf.sync()
+  tmpncf.close()
+
+  for varn in ncvars:
+      if not varn == var:
+           fvaradd(ncfile + ':' + varn, 'tmp_py.nc')
+
+  fgaddattr(ncfile, 'tmp_py.nc')
+  shu.copyfile('tmp_py.nc', ncfile)
+  os.remove('tmp_py.nc')
+ 
+def ivars(ncfile):
+  """Give all the variable names of a file
+  """
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    ivars: File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'a')
+  ncvars = ncf.variables
+  allvars=''
+  for var in ncvars:
+      print var
+      allvars=allvars + ':' + var
+
+  print '  # allvars= ' + allvars
+  ncf.close()
+
+def igattrs(ncfile):
+  """Give all the global attributes of a file
+  """
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    igattrs: File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit()    
+
+  ncf = NetCDFFile(ncfile,'r')
+  ncattrs = ncf.ncattrs()
+  allattrs=''
+  allattrsdic = {}
+  for attr in ncattrs:
+      attrv=ncf.getncattr(attr)
+      if type(attrv) == type(str('1')):
+          attrk = 'S'
+      elif type(attrv) == type(unicode('1')):
+          attrk = 'S'
+      elif type(attrv) == type(int(1)):
+          attrk = 'I'
+      elif type(attrv) == type(np.int(1)):
+          attrk = 'Inp'
+      elif type(attrv) == type(np.int32(1)):
+          attrk = 'Inp32'
+      elif type(attrv) == type(float(1.)):
+          attrk = 'R'
+      elif type(attrv) == type(np.float32(1.)):
+          attrk = 'Rnp32'
+      elif type(attrv) == type(np.float64(1.)):
+          attrk = 'Rnp64'
+      else:
+          print errormsg
+          print '    igattr: Reading attribute "', type(attrv), '" not ready! value:', attrv
+          ncf.close()
+          quit(-1)
+      print attr, '|',  attrv, '|', attrk
+      allattrsdic[attr] = [attrv, attrk]
+      allattrs=allattrs + ':' + attr + '|' + str(attrv) + '|' + attrk
+
+  print '####### ###### ##### #### ### ## #'
+  print '# allgattrs= ' + allattrs
+  ncf.close()
+
+  return allattrsdic
+
+def isgattrs(values, ncfile):
+  """Give a single global attribute of a file and its type
+  values = attribute name
+  ncfile = netCDF file name
+  output:
+    attribute name, '|',  attribute value, '|', attribute kind ('S', string '!' as spaces; 'I', integer; 'R', real; 'D', double )
+  """
+
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    isgattrs: File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'r')
+  ncattrs = ncf.ncattrs()
+
+  if not searchInlist(ncattrs, values):
+      print '    isgattrs: File "' + ncfile + '" does not have global attribute: "' + values + '" '
+      ncf.close()
+      quit(-1)
+
+  attrv=ncf.getncattr(values)
+  if type(attrv) == type(str('1')):
+      attrk = 'S'
+      attrv = attrv.replace(' ','!')
+  elif type(attrv) == type(unicode('1')):
+      attrk = 'S'
+      attrv = attrv.replace(' ','!')
+  elif type(attrv) == type(int(1)):
+      attrk = 'I'
+  elif type(attrv) == type(np.int(1)):
+      attrk = 'I'
+  elif type(attrv) == type(np.int32(1)):
+      attrk = 'I'
+  elif type(attrv) == type(float(1.)):
+      attrk = 'R'
+  elif type(attrv) == type(np.float32(1.)):
+      attrk = 'R'
+  elif type(attrv) == type(np.float64(1.)):
+      attrk = 'D'
+  else:
+      print errormsg
+      print '    isgattr: Reading attribute "', type(attrv), '" not ready! value:', attrv
+      ncf.close()
+      quit(-1)
+  print values, '|',  attrv, '|', attrk
+
+  ncf.close()
+  return [values, attrv, attrk]
+
+def ivattrs(ncfile, varn):
+  """Give all the attributes of a variable and its type
+  ncfile = netCDF file name
+  var = variable name
+  output:
+    attribute name, '|',  attribute value, '|', attribute kind ('S', string '!' as spaces; 'I', integer; 'R', real; 'D', double )
+  """
+
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    ivattrs: File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'r')
+  ncvars = ncf.variables
+
+  if not searchInlist(ncvars, varn):
+      print '    ivattrs: File "' + ncfile + '" does not have variable: "' + varn + '" '
+      ncf.close()
+      quit(-1)
+  varval = ncf.variables[varn]
+
+  ncattrs = varval.ncattrs()
+  allattrs=''
+  allattrsdic = {}
+  for attr in ncattrs:
+      attrv=varval.getncattr(attr)
+      if type(attrv) == type(str('1')):
+          attrk = 'S'
+          attrv = attrv.replace(' ','!')
+      elif type(attrv) == type(unicode('1')):
+          attrk = 'S'
+          attrv = attrv.replace(' ','!')
+      elif type(attrv) == type(int(1)):
+          attrk = 'I'
+      elif type(attrv) == type(np.int(1)):
+          attrk = 'I'
+      elif type(attrv) == type(np.int32(1)):
+          attrk = 'I'
+      elif type(attrv) == type(float(1.)):
+          attrk = 'R'
+      elif type(attrv) == type(np.float32(1.)):
+          attrk = 'R'
+      elif type(attrv) == type(np.float64(1.)):
+          attrk = 'D'
+      else:
+          print errormsg
+          print '    ivattrs: Reading attribute "', type(attrv), '" not ready! value:', attrv
+          ncf.close()
+          quit(-1)
+      print attr, '|',  attrv, '|', attrk
+      allattrsdic[attr]  = [attrv, attrk]
+      allattrs=allattrs + ':' + attr + '|' + str(attrv) + '|' + attrk
+
+  print '####### ###### ##### #### ### ## #'
+  print '# allvattrs= ' + allattrs
+  ncf.close()
+
+  return allattrsdic
+
+def isvattrs(values, ncfile, varn):
+  """Give a single attribute of a variable
+  values = attribute name
+  ncfile = netCDF file name
+  varn = variable name
+  """
+
+  if not os.path.isfile(ncfile):
+    print errormsg
+    print '    isvattrs:File "' + ncfile + '" does not exist !!'
+    print errormsg
+    quit(-1)    
+
+  ncf = NetCDFFile(ncfile,'r')
+  ncvars = ncf.variables
+
+  if not searchInlist(ncvars, varn):
+      print errormsg
+      print '    isvattrs:"' + ncfile + '" does not have variable: "' + varn + '" '
+      ncf.close()
+      quit(-1)
+  varval = ncf.variables[varn]
+
+  ncattrs = varval.ncattrs()
+  if not searchInlist(ncattrs, values):
+      print errormsg
+      print '    isvattrs:' + ncfile + ' does not have global attribute: "' + values + '" '
+      ncf.close()
+      quit(-1)
+
+  attrv=varval.getncattr(values)
+  if type(attrv) == type(str('1')):
+      attrk = 'S'
+  elif type(attrv) == type(unicode('1')):
+      attrk = 'S'
+  elif type(attrv) == type(int(1)):
+      attrk = 'I'
+  elif type(attrv) == type(np.int(1)):
+      attrk = 'I'
+  elif type(attrv) == type(np.int32(1)):
+      attrk = 'I'
+  elif type(attrv) == type(float(1.)):
+      attrk = 'R'
+  elif type(attrv) == type(np.float(1.)):
+      attrk = 'R'
+  elif type(attrv) == type(np.float32(1.)):
+      attrk = 'R'
+  elif type(attrv) == type(np.float64(1.)):
+      attrk = 'D'
+  else:
+      print errormsg
+      print '    isvattr: Reading attribute "', type(attrv), '" not ready! value:', attrv
+      ncf.close()
+      quit(-1)
+  print values, '|',  attrv, '|', attrk
+
+  ncf.close()
+  return [values, attrv, attrk]
+
+def grattr(values, ncfile):
+  """ Function to read a global atribute
+  values = attribute name
+  ncfile = netCDF file name
+  """
+  ncf = NetCDFFile(ncfile,'r')
+
+  glob_attrs = ncf.ncattrs()
+
+  attrPos = searchInlist(glob_attrs, values)
+
+  if not attrPos:
+    print errormsg
+    print '    grattr: File "' + ncfile + '" does not have attribute "' + values + '" !!!!'
+    print errormsg
+    ncf.close()
+    quit(-1)
+
+  print ncf.getncattr(values)
+
+  ncf.close()
+
+def vrattr(values, ncfile, varn):
+    """ Function to remove an atribute from a variable
+    values = attribute name
+    ncfile = netCDF file name
+    varn = variable name
+    """
+    fname = 'vrattr'
+
+    ncf = NetCDFFile(ncfile,'r')
+
+    if not ncf.variables.has_key(varn):
+        print errormsg
+        print '  ' + fname + ": File '" + ncfile + "' does not have variable '" +    \
+          varn + "' !!!!"
+        ncf.close()
+        quit(-1)
+
+    var = ncf.variables[varn]
+    var_attrs = var.ncattrs()
+
+    if not searchInlist(var_attrs, values):
+        print errormsg
+        print '  ' + fname + ": Variable '" + varn + "' does not have attribute '" + \
+          values + "' !!!!"
+        ncf.close()
+        quit(-1)
+    else:
+        attr = var.delncattr(values)
+    
+    ncf.close()
+
+    return
+
+def datetimeStr_datetime(StringDT):
+    """ Function to transform a string date ([YYYY]-[MM]-[DD]_[HH]:[MI]:[SS] format) to a date object
+    >>> datetimeStr_datetime('1976-02-17_00:00:00')
+    1976-02-17 00:00:00
+    """
+    import datetime as dt
+
+    fname = 'datetimeStr_datetime'
+
+    dateD = np.zeros((3), dtype=int)
+    timeT = np.zeros((3), dtype=int)
+
+    dateD[0] = int(StringDT[0:4])
+    dateD[1] = int(StringDT[5:7])
+    dateD[2] = int(StringDT[8:10])
+
+    trefT = StringDT.find(':')
+    if not trefT == -1:
+#        print '  ' + fname + ': refdate with time!'
+        timeT[0] = int(StringDT[11:13])
+        timeT[1] = int(StringDT[14:16])
+        timeT[2] = int(StringDT[17:19])
+
+    if int(dateD[0]) == 0:
+        print warnmsg
+        print '    ' + fname + ': 0 reference year!! changing to 1'
+        dateD[0] = 1 
+ 
+    newdatetime = dt.datetime(dateD[0], dateD[1], dateD[2], timeT[0], timeT[1], timeT[2])
+
+    return newdatetime
+
+def dateStr_date(StringDate):
+  """ Function to transform a string date ([YYYY]-[MM]-[DD] format) to a date object
+  >>> dateStr_date('1976-02-17')
+  1976-02-17
+  """
+  import datetime as dt
+
+  dateD = StringDate.split('-')
+  if int(dateD[0]) == 0:
+    print warnmsg
+    print '    dateStr_date: 0 reference year!! changing to 1'
+    dateD[0] = 1
+  newdate = dt.date(int(dateD[0]), int(dateD[1]), int(dateD[2]))
+  return newdate
+
+def timeStr_time(StringDate):
+  """ Function to transform a string date ([HH]:[MI]:[SS] format) to a time object
+  >>> datetimeStr_datetime('04:32:54')
+  04:32:54
+  """
+  import datetime as dt
+
+  timeT = StringDate.split(':')
+  if len(timeT) == 3:
+    newtime = dt.time(int(timeT[0]), int(timeT[1]), int(timeT[2]))
+  else:
+    newtime = dt.time(int(timeT[0]), int(timeT[1]), 0)
+
+  return newtime
+
+def timeref_datetime(refd, timeval, tu):
+    """ Function to transform from a [timeval] in [tu] units from the time referece [tref] to datetime object
+    refd: time of reference (as datetime object)
+    timeval: time value (as [tu] from [tref])
+    tu: time units
+    >>> timeref = date(1949,12,1,0,0,0)
+    >>> timeref_datetime(timeref, 229784.36, hours)
+    1976-02-17 08:21:36
+    """
+    import datetime as dt
+    import numpy as np
+
+## Not in timedelta
+#    if tu == 'years':
+#        realdate = refdate + dt.timedelta(years=float(timeval))
+#    elif tu == 'months':
+#        realdate = refdate + dt.timedelta(months=float(timeval))
+    if tu == 'weeks':
+        realdate = refd + dt.timedelta(weeks=float(timeval))
+    elif tu == 'days':
+        realdate = refd + dt.timedelta(days=float(timeval))
+    elif tu == 'hours':
+        realdate = refd + dt.timedelta(hours=float(timeval))
+    elif tu == 'minutes':
+        realdate = refd + dt.timedelta(minutes=float(timeval))
+    elif tu == 'seconds':
+        realdate = refd + dt.timedelta(seconds=float(timeval))
+    elif tu == 'milliseconds':
+        realdate = refd + dt.timedelta(milliseconds=float(timeval))
+    else:
+          print errormsg
+          print '    timeref_datetime: time units "' + tu + '" not ready!!!!'
+          quit(-1)
+
+    return realdate
+
+def timeref_datetime_mat(refd, timeval, tu):
+    """ Function to transform from a [timeval] in [tu] units from the time referece [tref] to matrix with: year, day, month, hour, minute, second
+    refd: time of reference (as datetime object)
+    timeval: time value (as [tu] from [tref])
+    tu: time units
+    >>> timeref = date(1949,12,1,0,0,0)
+    >>> timeref_datetime(timeref, 229784.36, hours)
+    [1976    2   17    8   36   21]
+    """
+    import datetime as dt
+    import numpy as np
+
+
+    realdates = np.zeros(6, dtype=int)
+## Not in timedelta
+#    if tu == 'years':
+#        realdate = refdate + dt.timedelta(years=float(timeval))
+#    elif tu == 'months':
+#        realdate = refdate + dt.timedelta(months=float(timeval))
+    if tu == 'weeks':
+        realdate = refd + dt.timedelta(weeks=float(timeval))
+    elif tu == 'days':
+        realdate = refd + dt.timedelta(days=float(timeval))
+    elif tu == 'hours':
+        realdate = refd + dt.timedelta(hours=float(timeval))
+    elif tu == 'minutes':
+        realdate = refd + dt.timedelta(minutes=float(timeval))
+    elif tunits == 'seconds':
+        realdate = refd + dt.timedelta(seconds=float(timeval))
+    elif tunits == 'milliseconds':
+        realdate = refd + dt.timedelta(milliseconds=float(timeval))
+    else:
+          print errormsg
+          print '    timeref_datetime: time units "' + tu + '" not ready!!!!'
+          quit(-1)
+
+    realdates[0] = int(realdate.year)
+    realdates[1] = int(realdate.month)
+    realdates[2] = int(realdate.day)
+    realdates[3] = int(realdate.hour)
+    realdates[4] = int(realdate.second)
+    realdates[5] = int(realdate.minute)
+
+    return realdates
+
+def realdatetime_CFcompilant(times, Srefdate, tunits):
+    """ Function to transform a matrix with real time values ([year, month, day, hour, minute, second]) to a netCDF one
+    times= matrix with times
+    Srefdate= reference date ([YYYY][MM][DD][HH][MI][SS] format)
+    tunits= units of time respect to Srefdate
+    >>> realdatetime_CFcompilant(np.array([ [1976, 2, 17, 8, 20, 0], [1976, 2, 18, 8, 20, 0]], dtype=int), '19491201000000', 'hours')
+    [ 229784.33333333  229808.33333333]
+    """ 
+
+    import datetime as dt
+    yrref=int(Srefdate[0:4])
+    monref=int(Srefdate[4:6])
+    dayref=int(Srefdate[6:8])
+    horref=int(Srefdate[8:10])
+    minref=int(Srefdate[10:12])
+    secref=int(Srefdate[12:14])
+ 
+    refdate=dt.datetime(yrref, monref, dayref, horref, minref, secref)
+
+    dimt=times.shape[0]
+        
+    cfdates = np.zeros((dimt), dtype=np.float64)
+    if tunits == 'weeks':
+        for it in range(dimt):
+            cfdate = dt.datetime(times[it,0], times[it,1], times[it,2], times[it,3], times[it,4], times[it,5]) - refdate
+            cfdates[it] = (cfdate.days + cfdate.seconds/(3600.*24.))/7.
+    elif tunits == 'days':
+        for it in range(dimt):
+            cfdate = dt.datetime(times[it,0], times[it,1], times[it,2], times[it,3], times[it,4], times[it,5]) - refdate
+            cfdates[it] = cfdate.days + cfdate.seconds/(3600.*24.)
+    elif tunits == 'hours':
+        for it in range(dimt):
+            cfdate = dt.datetime(times[it,0], times[it,1], times[it,2], times[it,3], times[it,4], times[it,5]) - refdate
+            cfdates[it] = cfdate.days*24. + cfdate.seconds/3600.
+    elif tunits == 'minutes':
+        for it in range(dimt):
+            cfdate = dt.datetime(times[it,0], times[it,1], times[it,2], times[it,3], times[it,4], times[it,5]) - refdate
+            cfdates[it] = cfdate.days*24.*60. + cfdate.seconds/60.
+    elif tunits == 'seconds':
+        for it in range(dimt):
+            cfdate = dt.datetime(times[it,0], times[it,1], times[it,2], times[it,3], times[it,4], times[it,5]) - refdate
+            cfdates[it] = cfdate.days*24.*3600. + cfdate.seconds
+    elif tunits == 'milliseconds':
+        for it in range(dimt):
+            cfdate = dt.datetime(times[it,0], times[it,1], times[it,2], times[it,3], times[it,4], times[it,5]) - refdate
+            cfdates[it] = cfdate.days*1000.*24.*3600. + cfdate.seconds*1000.
+    elif tunits == 'microseconds':
+        for it in range(dimt):
+            cfdate = dt.datetime(times[it,0], times[it,1], times[it,2], times[it,3], times[it,4], times[it,5]) - refdate
+            cfdates[it] = cfdate.days*1000000.*24.*3600. + cfdate.seconds*1000000.
+    else:
+        print errormsg
+        print '  ' + fname + ': time units "' + tunits + '" is not ready!!!'
+        quit(-1)
+
+    return cfdates
+
+def netCDFdatetime_realdatetime(units, tcalendar, times):
+    """ Function to transfrom from netCDF CF-compilant times to real time
+    """
+    import datetime as dt
+
+    txtunits = units.split(' ')
+    tunits = txtunits[0]
+    Srefdate = txtunits[len(txtunits) - 1]
+
+# Calendar type
+##
+    is360 = False
+    if tcalendar is not None:
+      print '  netCDFdatetime_realdatetime: There is a calendar attribute'
+      if tcalendar == '365_day' or tcalendar == 'noleap':
+          print '    netCDFdatetime_realdatetime: No leap years!'
+          isleapcal = False
+      elif tcalendar == 'proleptic_gregorian' or tcalendar == 'standard' or tcalendar == 'gregorian':
+          isleapcal = True
+      elif tcalendar == '360_day':
+          is360 = True
+          isleapcal = False
+      else:
+          print errormsg
+          print '    netCDFdatetime_realdatetime: Calendar "' + tcalendar + '" not prepared!'
+          quit(-1)
+
+# Does reference date contain a time value [YYYY]-[MM]-[DD] [HH]:[MI]:[SS]
+##
+    timeval = Srefdate.find(':')
+
+    if not timeval == -1:
+        print '  netCDFdatetime_realdatetime: refdate with time!'
+        refdate = datetimeStr_datetime(txtunits[len(txtunits) - 2] + '_' + Srefdate)
+    else:
+        refdate = dateStr_date(Srefdate)
+
+    dimt = len(times)
+#    datetype = type(dt.datetime(1972,02,01))
+#    realdates = np.array(dimt, datetype)
+#    print realdates
+
+## Not in timedelta
+#  if tunits == 'years':
+#    for it in range(dimt):
+#      realdate = refdate + dt.timedelta(years=float(times[it]))
+#      realdates[it] = int(realdate.year)
+#  elif tunits == 'months':
+#    for it in range(dimt):
+#      realdate = refdate + dt.timedelta(months=float(times[it]))
+#      realdates[it] = int(realdate.year)
+#    realdates = []
+    realdates = np.zeros((dimt, 6), dtype=int)
+    if tunits == 'weeks':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(weeks=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'days':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(days=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'hours':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(hours=float(times[it]))
+#            if not isleapcal:
+#                Nleapdays = cal.leapdays(int(refdate.year), int(realdate.year))
+#                realdate = realdate - dt.timedelta(days=Nleapdays)
+#            if is360:
+#                Nyears360 = int(realdate.year) - int(refdate.year) + 1
+#                realdate = realdate -dt.timedelta(days=Nyears360*5)
+#            realdates[it] = realdate
+#        realdates = refdate + dt.timedelta(hours=float(times))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'minutes':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(minutes=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'seconds':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(seconds=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'milliseconds':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(milliseconds=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'microseconds':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(microseconds=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    else:
+        print errormsg
+        print '  netCDFdatetime_realdatetime: time units "' + tunits + '" is not ready!!!'
+        quit(-1)
+
+    return realdates
+
+class cls_time_information(object):
+    """ Classs to provide information about variable time
+    ncfu = netCDF unit name
+    tname = name of the variable time in [ncfu]
+    self.calendar: calendar of the variable time
+    self.unitsval: units value as it appears in attributes
+    self.units: units of variable time
+    self.Urefdate: reference date as it appears in the original 'units' section
+    self.Srefdate: reference date as string [YYYY][MM][DD][HH][MI][SS]
+    self.refdate: reference date
+    self.attributes: attributes of time variable
+    self.dimt: dimension of the time variable
+    self.dt: distance between first two time-steps in self.tunits
+    self.firstTu: first time value in self.units
+    self.firstTt: first time value as datetime object
+    self.firstTS: first time value as string [YYYY][MM][DD][HH][MI][SS]
+    self.firstTm: first time value as matrix (from datetime; [Y], [M], [D], [H], [M], [S])
+    self.lastTu: last time value in self.units
+    self.firstTt: last time value as datetime object
+    self.lastTS: last time value as string [YYYY][MM][DD][HH][MI][SS]
+    self.lastTm: last time value as matrix (from datetime; [Y], [M], [D], [H], [M], [S])
+    """
+
+    import datetime as dt 
+
+    def  __init__(self, ncfu, tname):
+
+        if ncfu is None:
+            self.unitsval = None
+            self.units = None
+            self.calendar = None
+            self.Urefdate = None
+            self.Srefdate = None
+            self.refdate = None
+            self.attributes = None
+            self.dimt = None
+            self.dt = None
+            self.firstTu = None
+            self.firstTt = None
+            self.firstTS = None
+            self.firstTm = None
+            self.lastTu = None
+            self.lastTt = None
+            self.lastTS = None
+            self.lastTm = None
+        else:
+            times = ncfu.variables[tname]
+            attvar = times.ncattrs() 
+            self.attributes = attvar
+            if not searchInlist(attvar, 'units'):
+                print errormsg
+                print '    cls_time_information: time variable "', tname, '" does not have attribute: "units"'
+                quit(-1)
+            else:
+                units = times.getncattr('units')
+
+            self.unitsval = units
+
+            if not searchInlist(attvar, 'calendar'):
+                print warnmsg
+                print '    cls_time_information: time variable "', tname, '" does not have attribute: "calendar"'
+                self.calendar = '-'
+            else:
+                self.calendar = times.getncattr('calendar')
+  
+            txtunits = units.split(' ')
+            self.units = txtunits[0]
+            Srefdate = txtunits[len(txtunits) - 1]
+# Does reference date contain a time value [YYYY]-[MM]-[DD] [HH]:[MI]:[SS]
+##
+            timeval = Srefdate.find(':')
+
+            if not timeval == -1:
+#        print '  refdate with time!'
+                self.refdate = datetimeStr_datetime(txtunits[len(txtunits) - 2] + '_' + Srefdate)
+                self.Urefdate = txtunits[len(txtunits) - 2] + ' ' + Srefdate
+            else:
+                self.refdate = datetimeStr_datetime(Srefdate + '_00:00:00')
+                self.Urefdate = Srefdate
+
+            self.Srefdate = self.refdate.strftime("%Y%m%d%H%M%S")
+            timev = times[:]
+
+            self.dimt = times.shape[0]
+            self.dt = timev[1]-timev[0]
+            self.firstTu = timev[0]
+            self.firstTt = timeref_datetime(self.refdate, self.firstTu, self.units)
+            self.firstTS = self.firstTt.strftime("%Y%m%d%H%M%S")
+            self.firstTm = timeref_datetime_mat(self.refdate, self.firstTu, self.units)
+            self.lastTu = timev[self.dimt-1]
+            self.lastTt = timeref_datetime(self.refdate, self.lastTu, self.units)
+            self.lastTS = self.lastTt.strftime("%Y%m%d%H%M%S")
+            self.lastTm = timeref_datetime_mat(self.refdate, self.lastTu, self.units)
+
+def time_information(ncfu, tname):
+    """ Function to provide information about variable time
+    ncfu = netCDF unit name
+    tname = name of the variable time in [ncfu]
+    """
+    times = ncfu.variables[tname]
+    timeinf = []
+
+    attvar = times.ncattrs()
+    if not searchInlist(attvar, 'units'):
+        print errormsg
+        print '    "time" does not have attribute: "units"'
+        quit(-1)
+    else:
+        units = times.getncattr('units')
+  
+    txtunits = units.split(' ')
+    tunits = txtunits[0]
+    Srefdate = txtunits[len(txtunits) - 1]
+# Does reference date contain a time value [YYYY]-[MM]-[DD] [HH]:[MI]:[SS]
+##
+    timeval = Srefdate.find(':')
+
+    if not timeval == -1:
+#        print '  refdate with time!'
+        refdate = datetimeStr_datetime(txtunits[len(txtunits) - 2] + '_' + Srefdate)
+    else:
+        refdate = dateStr_date(Srefdate)
+
+    timeinf.append(tunits)
+    timeinf.append(Srefdate)
+    timeinf.append(refdate)
+
+    return timeinf
+
+def CFtimes_datetime(ncfile, tname):
+    """ Provide date/time array from a file with a series of netCDF CF-compilant time variable
+    ncfile = netCDF file name
+    tname = name of the variable time in [ncfile]
+    output:
+      array(dimt, 0) = year
+      array(dimt, 1) = month
+      array(dimt, 2) = day
+      array(dimt, 3) = hour
+      array(dimt, 4) = minute
+      array(dimt, 5) = second
+    """
+    import datetime as dt
+
+    times = ncfile.variables[tname]
+    timevals = times[:]
+
+    attvar = times.ncattrs()
+    if not searchInlist(attvar, 'units'):
+        print errormsg
+        print '    CFtimes_datetime: "time" does not have attribute: "units"'
+        quit(-1)
+    else:
+        units = times.getncattr('units')
+  
+    txtunits = units.split(' ')
+    tunits = txtunits[0]
+    Srefdate = txtunits[len(txtunits) - 1]
+# Does reference date contain a time value [YYYY]-[MM]-[DD] [HH]:[MI]:[SS]
+##
+    timeval = Srefdate.find(':')
+
+    if not timeval == -1:
+#        print '  refdate with time!'
+        refdate = datetimeStr_datetime(txtunits[len(txtunits) - 2] + '_' + Srefdate)
+    else:
+        refdate = dateStr_date(Srefdate)
+
+    dimt = len(timevals)
+    realdates = np.zeros((dimt, 6), dtype=int)
+
+## Not in timedelta
+#    if tunits == 'years':
+#        for it in range(dimt):
+#            realdate = refdate + dt.timedelta(years=float(times[it]))
+#            realdates[it] = int(realdate.year)
+#    elif tunits == 'months':
+#        for it in range(dimt):
+#            realdate = refdate + dt.timedelta(months=float(times[it]))
+#            realdates[it] = int(realdate.year)
+    if tunits == 'weeks':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(weeks=float(times[it]))
+            realdates[it,0] = int(realdate.year)
+            realdates[it,1] = int(realdate.month)
+            realdates[it,2] = int(realdate.day)
+            realdates[it,3] = int(realdate.hour)
+            realdates[it,4] = int(realdate.second)
+            realdates[it,5] = int(realdate.minute)
+    elif tunits == 'days':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(days=float(times[it]))
+            realdates[it,0] = int(realdate.year)
+            realdates[it,1] = int(realdate.month)
+            realdates[it,2] = int(realdate.day)
+            realdates[it,3] = int(realdate.hour)
+            realdates[it,4] = int(realdate.second)
+            realdates[it,5] = int(realdate.minute)
+    elif tunits == 'hours':
+       for it in range(dimt):
+            realdate = refdate + dt.timedelta(hours=float(times[it]))
+            realdates[it,0] = int(realdate.year)
+            realdates[it,1] = int(realdate.month)
+            realdates[it,2] = int(realdate.day)
+            realdates[it,3] = int(realdate.hour)
+            realdates[it,4] = int(realdate.second)
+            realdates[it,5] = int(realdate.minute)
+    elif tunits == 'minutes':
+       for it in range(dimt):
+            realdate = refdate + dt.timedelta(minutes=float(times[it]))
+            realdates[it,0] = int(realdate.year)
+            realdates[it,1] = int(realdate.month)
+            realdates[it,2] = int(realdate.day)
+            realdates[it,3] = int(realdate.hour)
+            realdates[it,4] = int(realdate.second)
+            realdates[it,5] = int(realdate.minute)
+    elif tunits == 'seconds':
+       for it in range(dimt):
+            realdate = refdate + dt.timedelta(seconds=float(times[it]))
+            realdates[it,0] = int(realdate.year)
+            realdates[it,1] = int(realdate.month)
+            realdates[it,2] = int(realdate.day)
+            realdates[it,3] = int(realdate.hour)
+            realdates[it,4] = int(realdate.second)
+            realdates[it,5] = int(realdate.minute)
+    elif tunits == 'milliseconds':
+       for it in range(dimt):
+            realdate = refdate + dt.timedelta(milliseconds=float(times[it]))
+            realdates[it,0] = int(realdate.year)
+            realdates[it,1] = int(realdate.month)
+            realdates[it,2] = int(realdate.day)
+            realdates[it,3] = int(realdate.hour)
+            realdates[it,4] = int(realdate.second)
+            realdates[it,5] = int(realdate.minute)
+    else:
+          print errormsg
+          print '    CFtimes_datetime: time units "' + tunits + '" not ready!!!!'
+          quit(-1)
+
+    return realdates
+
+class variable_inf(object):
+    """ Class to provide the information from a given variable
+    var = object netCDF variable
+    self.name: name of the variable
+    self.dtype: type of the variable
+    self.attributes: list with the name of attributes
+    self.FillValue: value of the missing value
+    self.dimns: name of the dimensions of the variable
+    self.dims: dimensions of the variable
+    self.Ndims: number of dimensions
+    self.dimx: length of dimension along x-axis
+    self.dimy: length of dimension along y-axis
+    self.sname: standard name
+    self.lname: long name
+    self.corr: attribute 'coordinates'
+    self.units: units of the variable
+    """
+
+    def __init__(self, var):
+
+        if var is None:
+            self.name = None
+            self.dimns = None
+            self.dims = None
+            self.Ndims = None
+            self.dimx = None
+            self.dimy = None
+            self.sname = None
+            self.lname = None
+            self.corr = None
+            self.units = None
+            self.FillValue = None
+            self.dtype = None
+            self.attributes = None
+        else:
+            self.name = var._name
+            self.dimns = var.dimensions
+            self.dtype = var.dtype
+            self.attributes = var.ncattrs()
+            self.dims = var.shape
+
+            if searchInlist(self.attributes, 'standard_name'):
+                self.sname = var.getncattr('standard_name')
+            else:
+#                print '    variable_inf.classpy: variable "' + self.name + '" does not have attribute "standard_name"'
+                self.sname = None
+
+            if searchInlist(self.attributes, 'long_name'):
+                self.lname = var.getncattr('long_name')
+            else:
+#                print '    variable_inf.classpy: variable "' + self.name + '" does not have attribute "long_name"'
+                self.lname = None
+
+            if searchInlist(self.attributes, 'coordinates'):
+                self.coor = var.getncattr('coordinates')
+            else:
+#                print '    variable_inf.classpy: variable "' + self.name + '" does not have attribute "coordinates"'
+                self.coor = None
+
+            if searchInlist(self.attributes, 'units'):
+                self.units = var.getncattr('units')
+            else:
+#                print '    variable_inf.classpy: variable "' + self.name + '" does not have attribute "units"'
+                self.units = None
+
+            if searchInlist(self.attributes, '_FillValue'):
+                self.FillValue = var.getncattr('_FillValue')
+            else:
+#                print '    variable_inf.classpy: variable "' + self.name + '" does not have attribute "_FillValue"'
+                self.FillValue = None
+             
+            self.Ndims = len(self.dims)
+            if self.Ndims == 1:
+                self.dimx=self.dims[0]
+            if self.Ndims == 2:
+                self.dimy=self.dims[0]
+                self.dimx=self.dims[1]
+            if self.Ndims == 3:
+                self.dimy=self.dims[1]
+                self.dimx=self.dims[2]
+            if self.Ndims == 4:
+                self.dimy=self.dims[2]
+                self.dimx=self.dims[3]
+
+def subyrs(values, ncfile, varn):
+  """ Function to retrieve a series of years from a file
+  values = 
+    [year1]:[[year2]:...[yearn]] values for years [year1], [year2], ... [yearn]
+    [yearI]-[yearE] values for the period between [yearI] and [yearN]
+  ncfile = netCDF file name
+  varn = variable name
+  """
+  import datetime as dt
+  import calendar as cal
+  ofile = 'subsetyrs.nc'
+
+  ncf = NetCDFFile(ncfile,'r')
+
+  if not ncf.variables.has_key(varn):
+    print errormsg
+    print '   subyrs: File does not have variable "' + varn + '" !!!!'
+    print errormsg
+    ncf.close()
+    quit(-1)
+
+  times = ncf.variables['time']
+  timevals = times[:]
+  realdates = CFtimes_datetime(ncf, 'time')
+  dimt = len(timevals)
+
+# Checking years
+##
+  isper = values.find('-')
+
+  desiredvalues = np.array(dimt, dtype=bool)
+  desiredvaluesi = np.array(dimt, dtype=bool)
+  desiredvaluese = np.array(dimt, dtype=bool)
+
+  if not isper == -1:
+# Years list given as a period [YYYYi]-[YYYYf]
+    print '      subyrs: There is a period of years "' + values + '"'
+    iyr = int(values.split('-')[0])
+    eyr = int(values.split('-')[1])
+    desiredvaluesi = np.array(realdates[:,0] >= iyr)
+    desiredvaluese = np.array(realdates[:,0] <= eyr)
+
+    desiredvalues = desiredvaluesi*desiredvaluese
+
+  else:
+    yrs = values.split(':')
+    nyr = 1
+    for iyr in range(len(yrs)):
+      desiredvaluesi = np.array(realdates[:,0] == int(yrs[iyr]))
+      if nyr == 1:
+        desiredvalues = desiredvaluesi
+      else:
+        desiredvalues = desiredvaluesi+desiredvalues
+      nyr = nyr + 1
+
+  Ndesiredvalues = len(realdates[desiredvalues])
+
+  print '      subyrs: N values: ', Ndesiredvalues
+  if Ndesiredvalues == 0:
+    print errormsg
+    print '    subyrs: No values found for "' + values + '"!!'
+    ncf.close()
+    quit(-1)
+
+# Variable values (assuming time as first dimension)
+##
+  var = ncf.variables[varn]
+#  varvals = var[:]
+  vardims = var.shape
+  varshape = len(vardims)
+  print '      subyrs: Shape of data: ',varshape, ':' , vardims
+
+  if varshape == 1:
+    vardesiredvalues = np.arange(Ndesiredvalues)
+    vardesiredvalues = var[desiredvalues]
+  elif varshape == 2:
+    vardesiredvalues = np.arange(Ndesiredvalues*vardims[1]).reshape(Ndesiredvalues,vardims[1])
+    vardesiredvalues = var[desiredvalues, :]
+  elif varshape == 3:
+    vardesiredvalues = np.arange(Ndesiredvalues*vardims[1]*vardims[2]).reshape(Ndesiredvalues,                        \
+      vardims[1],vardims[2])
+    vardesiredvalues = var[desiredvalues, :, :]
+  elif varshape == 4:
+    vardesiredvalues = np.arange(Ndesiredvalues*vardims[1]*vardims[2]*vardims[3]).reshape(Ndesiredvalues,             \
+      vardims[1],vardims[2],vardims[3])
+    vardesiredvalues = var[desiredvalues, :, :, :]
+  elif varshape == 5:
+    vardesiredvalues = np.arange(Ndesiredvalues*vardims[1]*vardims[2]*vardims[3]*vardims[4]).reshape(Ndesiredvalues,  \
+      vardims[1],vardims[2],vardims[3],vardims[4])
+    vardesiredvalues = var[desiredvalues, :, :, :, :]
+  elif varshape == 6:
+    vardesiredvalues = np.arange(Ndesiredvalues*vardims[1]*vardims[2]*vardims[3]*vardims[4]*                          \
+      vardims[5]).reshape(Ndesiredvalues,vardims[1],vardims[2],vardims[3],vardims[4],vardims[5])
+    vardesiredvalues = var[desiredvalues, :, :, :, :, :]
+  else:
+     print errormsg
+     print '    subyrs: ', varshape, ' shape of matrix not prepared !'
+     ncf.close()
+     quit(-1)
+
+#  print '  shape of desired values: ', vardesiredvalues.shape
+# Creation of file
+##
+
+  ncfo = NetCDFFile( ofile, 'w')
+
+  vardims = var.dimensions
+  vartype = var.dtype
+  varattr = var.ncattrs()
+
+# Checking dimensions
+##
+  newdims = ncfo.dimensions
+  for rdim in vardims:
+      if not searchInlist(newdims, rdim):
+          if not rdim == 'time':
+              print '      subyrs: Adding dimension ' + rdim
+              ncfo.sync()
+              ncf.close()
+              ncfo.close()
+              fdimadd(ncfile + ',' + rdim, ofile)
+              ncf = NetCDFFile(ncfile,'r')
+              ncfo = NetCDFFile(ofile,'a')
+          else:
+              ncfo.createDimension('time', None)
+
+# Checking fill value
+## 
+  if searchInlist(varattr, '_FillValue'):
+      varfil = var._FillValue
+  else:
+      varfil = False
+
+  newvar = ncfo.createVariable(varn, vartype, vardims, fill_value=varfil)
+
+  if not varshape == 0:
+    newvar[:] = vardesiredvalues
+
+  newvar = ncfo.variables[varn]
+  for attr in varattr:
+      newvarattrs = newvar.ncattrs()
+      attrv = var.getncattr(attr)
+      if not searchInlist(newvarattrs, attr):     
+          newvar.setncattr(attr, attrv)
+
+  vardims = times.dimensions
+  vartype = times.dtype
+  varattr = times.ncattrs()
+
+  newvar = ncfo.createVariable('time', vartype, vardims, fill_value=varfil)
+  newvar = ncfo.variables['time']
+  newvar[:] = timevals[desiredvalues]
+
+  ncf.close()
+  ncfo.sync()
+  ncfo.close()
+  fattradd('time', ncfile + ':time', ofile)
+  fvaradd(ncfile + ':lon', ofile)
+  fvaradd(ncfile + ':lat', ofile)
+
+  ncfo = NetCDFFile(ofile,'a')
+  newvar = ncfo.variables['time']
+  newvarattrs = newvar.ncattrs()
+  if searchInlist(newvarattrs, 'bounds'):
+      if newvar.getncattr('bounds') == 'time_bnds':
+          ncf = NetCDFFile(ncfile,'r')
+          tbnds = ncf.variables['time_bnds']
+          vardims = tbnds.dimensions
+          vartype = tbnds.dtype
+          varattr = tbnds.ncattrs()
+          ncfo.createDimension('bnds', 2)
+          newvar = ncfo.createVariable('time_bnds', vartype, vardims, fill_value=varfil)
+          newvar[:] = tbnds[desiredvalues,:]
+
+          ncf.close()
+          ncfo.sync()
+          ncfo.close()
+          fattradd('time_bnds', ncfile + ':time_bnds', ofile)
+      else:
+          ncfo.close()
+  else:
+      ncfo.close()
+
+  fgaddattr(ncfile, ofile)
+
+  print '      subyrs: File "' + ofile + '" with a subset of ' + values + ' has been created'
+
+def submns(values, ncfile, varn):
+  """ Function to retrieve a series of months from a file
+  values = 
+    [mon1]:[[mion2]:...[monn]] values for months [mon1], [mon2], ... [monn]
+    [monI]-[monE] values for the period between [monI] and [monN]
+  ncfile = netCDF file name
+  varn = variable name
+  """
+  import datetime as dt
+  import calendar as cal
+
+  ofile = 'subsetmns.nc'
+
+  ncf = NetCDFFile(ncfile,'r')
+
+  if not ncf.variables.has_key(varn):
+    print errormsg
+    print '    submns: File "' + ncfile + '" does not have variable "' + varn + '" !!!!'
+    print errormsg
+    ncf.close()
+    quit(-1)
+
+  times = ncf.variables['time']
+  timevals = times[:]
+  realdates = CFtimes_datetime(ncf, 'time')
+  dimt = len(timevals)
+
+# Checking months
+##
+  isper =values.find('-')
+
+  desiredvalues = np.array(dimt, dtype=bool)
+  desiredvaluesi = np.array(dimt, dtype=bool)
+  desiredvaluese = np.array(dimt, dtype=bool)
+
+  if not isper == -1:
+# Months list given as a period [MMi]-[MMf]
+    print '      submns: There is a period of months "' + values + '"'
+    imn = int(values.split('-')[0])
+    emn = int(values.split('-')[1])
+    desiredvaluesi = np.array(realdates[:,1] >= imn)
+    desiredvaluese = np.array(realdates[:,1] <= emn)
+
+    desiredvalues = desiredvaluesi*desiredvaluese
+
+  else:
+    mns = values.split(':')
+    nmn = 1
+    for imn in range(len(mns)):
+      desiredvaluesi = np.array(realdates[:,1] == int(mns[imn]))
+      if nmn == 1:
+        desiredvalues = desiredvaluesi
+      else:
+        desiredvalues = desiredvaluesi+desiredvalues
+      nmn = nmn + 1
+
+  Ndesiredvalues = len(realdates[desiredvalues])
+
+  print '    submns: N values: ', Ndesiredvalues
+  if Ndesiredvalues == 0:
+    print errormsg
+    print '    submns: No values found for "' + values + '"!!'
+    ncf.close()
+    quit(-1)
+
+# Variable values (assuming time as first dimension)
+##
+  var = ncf.variables[varn]
+#  varvals = var[:]
+  vardims = var.shape
+  varshape = len(vardims)
+#  print '      submns: Shape of data: ',varshape, ':' , vardims
+
+  if varshape == 1:
+    vardesiredvalues = np.arange(Ndesiredvalues)
+    vardesiredvalues = var[desiredvalues]
+  elif varshape == 2:
+    vardesiredvalues = np.arange(Ndesiredvalues*vardims[1]).reshape(Ndesiredvalues,vardims[1])
+    vardesiredvalues = var[desiredvalues, :]
+  elif varshape == 3:
+    vardesiredvalues = np.arange(Ndesiredvalues*vardims[1]*vardims[2]).reshape(Ndesiredvalues,                        \
+      vardims[1],vardims[2])
+    vardesiredvalues = var[desiredvalues, :, :]
+  elif varshape == 4:
+    vardesiredvalues = np.arange(Ndesiredvalues*vardims[1]*vardims[2]*vardims[3]).reshape(Ndesiredvalues,             \
+      vardims[1],vardims[2],vardims[3])
+    vardesiredvalues = var[desiredvalues, :, :, :]
+  elif varshape == 5:
+    vardesiredvalues = np.arange(Ndesiredvalues*vardims[1]*vardims[2]*vardims[3]*vardims[4]).reshape(Ndesiredvalues,  \
+      vardims[1],vardims[2],vardims[3],vardims[4])
+    vardesiredvalues = var[desiredvalues, :, :, :, :]
+  elif varshape == 6:
+    vardesiredvalues = np.arange(Ndesiredvalues*vardims[1]*vardims[2]*vardims[3]*vardims[4]*                          \
+      vardims[5]).reshape(Ndesiredvalues,vardims[1],vardims[2],vardims[3],vardims[4],vardims[5])
+    vardesiredvalues = var[desiredvalues, :, :, :, :, :]
+  else:
+     print errormsg
+     print '    submns: ', varshape, ' shape of matrix not prepared !'
+     ncf.close()
+     quit(-1)
+
+#  print '  shape of desired values: ', vardesiredvalues.shape
+# Creation of file
+##
+
+  ncfo = NetCDFFile( ofile, 'w')
+
+  vardims = var.dimensions
+  vartype = var.dtype
+  varattr = var.ncattrs()
+
+# Checking dimensions
+##
+  newdims = ncfo.dimensions
+  for rdim in vardims:
+      if not searchInlist(newdims, rdim):
+          if not rdim == 'time':
+              print '      submns: Adding dimension ' + rdim
+              ncfo.sync()
+              ncf.close()
+              ncfo.close()
+              fdimadd(ncfile + ',' + rdim, ofile)
+              ncf = NetCDFFile(ncfile,'r')
+              ncfo = NetCDFFile(ofile,'a')
+          else:
+              ncfo.createDimension('time', None)
+
+# Checking fill value
+## 
+  if searchInlist(varattr, '_FillValue'):
+      varfil = var._FillValue
+  else:
+      varfil = False
+
+  newvar = ncfo.createVariable(varn, vartype, vardims, fill_value=varfil)
+
+  if not varshape == 0:
+    newvar[:] = vardesiredvalues
+
+  newvar = ncfo.variables[varn]
+  for attr in varattr:
+      newvarattrs = newvar.ncattrs()
+      attrv = var.getncattr(attr)
+      if not searchInlist(newvarattrs, attr):     
+          newvar.setncattr(attr, attrv)
+
+  vardims = times.dimensions
+  vartype = times.dtype
+  varattr = times.ncattrs()
+
+  newvar = ncfo.createVariable('time', vartype, vardims, fill_value=varfil)
+  newvar = ncfo.variables['time']
+  newvar[:] = timevals[desiredvalues]
+
+  ncf.close()
+  ncfo.sync()
+  ncfo.close()
+  fattradd('time', ncfile + ':time', ofile)
+  fvaradd(ncfile + ':lon', ofile)
+  fvaradd(ncfile + ':lat', ofile)
+
+  ncfo = NetCDFFile(ofile,'a')
+  newvar = ncfo.variables['time']
+  newvarattrs = newvar.ncattrs()
+  if searchInlist(newvarattrs, 'bounds'):
+      if newvar.getncattr('bounds') == 'time_bnds':
+          ncf = NetCDFFile(ncfile,'r')
+          tbnds = ncf.variables['time_bnds']
+          vardims = tbnds.dimensions
+          vartype = tbnds.dtype
+          varattr = tbnds.ncattrs()
+          ncfo.createDimension('bnds', 2)
+          newvar = ncfo.createVariable('time_bnds', vartype, vardims, fill_value=varfil)
+          newvar[:] = tbnds[desiredvalues,:]
+
+          ncf.close()
+          ncfo.sync()
+          ncfo.close()
+          fattradd('time_bnds', ncfile + ':time_bnds', ofile)
+      else:
+          ncfo.close()
+  else:
+      ncfo.close()
+
+  fgaddattr(ncfile, ofile)
+
+  print '      submns: File "' + ofile + '" with a subset of ' + values + ' has been created'
+
+class statsValWeigthed(object):
+  """Weigthed Statistics class providing:
+  vals = values (can be a matrix)
+  wgs = weights (can be a matrix)
+  self.meanv: mean weigthed value
+  self.mean2v: mean quadratic weigthed value
+  self.stdv: weigthed standard deviation
+  self.Nokvalue non None values of a list of values 
+  self.meanwgt: mean of the weigths
+  self.mean2wgt: cuadratic mean of the weigths
+  self.stdwgt: standard deviation of the weigths
+  """
+
+  def __init__(self, vals, wgs):
+    if vals is None:
+      self.Nv = None
+      self.meanv = None
+      self.mean2v = None
+      self.stdv = None
+      self.Nokvalues = None
+      self.meanwgt = None
+      self.mean2wgt = None
+      self.stdwgt = None
+    else:
+      values = vals.flatten() 
+      weights = wgs.flatten()
+      self.Nv=len(values)
+      self.meanv=0.
+      self.mean2v=0.
+      self.stdv=0.
+      self.meanwgt = 0.
+      self.mean2wgt = 0.
+      self.stdwgt = 0.
+      self.Nokvalues = 0
+
+      for inum in range(self.Nv):
+        if not values[inum] is None:
+          self.Nokvalues = self.Nokvalues + 1
+          self.meanv = self.meanv+values[inum]*weights[inum]
+          self.mean2v = self.mean2v+values[inum]*weights[inum]*values[inum]
+          self.meanwgt = self.meanwgt+weights[inum]
+          self.mean2wgt = self.mean2wgt+weights[inum]*weights[inum]
+
+      self.meanv = self.meanv/float(self.meanwgt)
+      self.mean2v = self.mean2v/float(self.meanwgt)
+      self.stdv = np.sqrt(self.mean2v-self.meanv*self.meanv)
+      self.meanwgt = self.meanwgt/float(self.Nokvalues)
+      self.mean2wgt = self.mean2wgt/float(self.Nokvalues)
+      self.stdwgt = np.sqrt(self.mean2wgt-self.meanwgt*self.meanwgt)
+
+class statsValWeighted_missVal(object):
+  """Weighted Statistics taking into account a missing value class providing:
+  vals = values (can be a matrix)
+  wgs = weights (can be a matrix)
+  missVal= missing value
+  self.meanv: mean weigthed value
+  self.mean2v: mean quadratic weigthed value
+  self.stdv: weigthed standard deviation
+  self.Nokvalue non None values of a list of values 
+  self.meanwgt: mean of the weigths
+  self.mean2wgt: cuadratic mean of the weigths
+  self.stdwgt: standard deviation of the weigths
+  self.quantilesv: quantiles of the weighted values
+  """
+
+  def __init__(self, vals, wgs, missVal):
+
+    fname='statsValWeigthed_missVal'
+    if vals is None:
+      self.Nv = None
+      self.meanv = None
+      self.mean2v = None
+      self.stdv = None
+      self.Nokvalues = None
+      self.meanwgt = None
+      self.mean2wgt = None
+      self.stdwgt = None
+      self.quantilesv = None
+    else:    
+      Npt = 1
+      for idim in range(len(vals.shape)):
+        Npt = Npt * vals.shape[idim]
+      if np.sum(vals >= missVal) == Npt:
+          print errormsg
+          print '  ' + fname + ' all values get missing!!'
+          print errormsg
+          quit(-1)
+      vals0 = np.where(vals >= missVal, None, vals)
+      values = vals0.flatten() 
+      weights = wgs.flatten()
+      self.Nv=Npt
+      self.meanv=0.
+      self.mean2v=0.
+      self.stdv=0.
+      self.meanwgt = 0.
+      self.mean2wgt = 0.
+      self.stdwgt = 0.
+      self.Nokvalues = 0
+
+      valswgt = values
+      for inum in range(self.Nv):
+        if not values[inum] is None:
+          self.Nokvalues = self.Nokvalues + 1
+          valswgt[inum] = valswgt[inum]*weights[inum]
+          self.meanv = self.meanv+values[inum]*weights[inum]
+          self.mean2v = self.mean2v+values[inum]*weights[inum]*values[inum]
+          self.meanwgt = self.meanwgt+weights[inum]
+          self.mean2wgt = self.mean2wgt+weights[inum]*weights[inum]
+
+      self.meanv = self.meanv/float(self.meanwgt)
+      self.mean2v = self.mean2v/float(self.meanwgt)
+      self.stdv = np.sqrt(self.mean2v-self.meanv*self.meanv)
+      valswgt = valswgt/np.float(self.meanwgt)
+      self.meanwgt = self.meanwgt/float(self.Nokvalues)
+      self.mean2wgt = self.mean2wgt/float(self.Nokvalues)
+      self.stdwgt = np.sqrt(self.mean2wgt-self.meanwgt*self.meanwgt)
+      valsq=Quantiles(valswgt, 20)
+      self.quantilesv=valsq.quantilesv
+
+class stats2Val(object):
+  """two variables Statistics class providing:
+  vals1 = variable 1
+  vals2 = variable 2
+  power = power of the polynomial fitting to apply between both variables
+  self.min[var], self.max[var], self.mean[var], self.mean2[var], self.std[var] of 
+    [var] = var1+var2[v1Av2], var1-var2[v1Sv2], var1/var2[v1Dv2], var1*var2[v1Pv2]
+  self.Nokvalues1: number of correct values of variable 1
+  self.Nokvalues2: number of correct values of variable 2
+  self.Nokvalues12: number of correct coincident values of variable 1 and variable 2
+  self.mae=mean(abs(var1-var2)) 
+  self.rmse=sqrt((var1-var2)**2) 
+  self.correlation (and p-value) 
+  self.linRegress: linear regression [trend, intercept, regression coefficient, p_value, standard error]
+  self.polRegress: polinomial Regresion  of degree [power] [coef**[power], coef**[power-1], ...., coef**0]
+  """
+
+  def __init__(self, vals1, vals2, power):
+    import numpy as np
+    from scipy import stats as sts
+
+    if vals1 is None:
+      self.Nv = None
+      self.Nokvalues1 = None
+      self.Nokvalues2 = None
+      self.Nokvalues12 = None
+      self.NDvalNone = None
+      self.minv1Av2 = None
+      self.maxv1Av2 = None
+      self.meanv1Av2 = None
+      self.mean2v1Av2 = None
+      self.stdv1Av2 = None
+      self.minv1Sv2 = None
+      self.maxv1Sv2 = None
+      self.meanv1Sv2 = None
+      self.mean2v1Sv2 = None
+      self.stdv1Sv2 = None
+      self.minv1Dv2 = None
+      self.maxv1Dv2 = None
+      self.meanv1Dv2 = None
+      self.mean2v1Dv2 = None
+      self.stdv1Dv2 = None
+      self.minv1Pv2 = None
+      self.maxv1Pv2 = None
+      self.meanv1Pv2 = None
+      self.mean2v1Pv2 = None
+      self.stdv1Pv2 = None
+      self.mae = None
+      self.rmse = None
+      self.corr = None
+      self.linRegress = None
+      self.polRegress = None
+      self.polRegressResidual = None
+      self.polRegressRes = None
+      self.polRegressSingVal = None
+    else:
+      values1 = vals1.flatten() 
+      values2 = vals2.flatten() 
+
+      if not len(values1) == len(values2):
+        print errormsg
+        print '    stats2Val: lengths of variables differ!! Lvar1: ', len(values1), ' Lvar2: ',len(values2),' statistics between them can not be computed!'
+        quit(-1)
+
+      self.Nv=len(values1)
+      self.minv1Av2=10000000000.
+      self.maxv1Av2=-self.minv1Av2
+      self.meanv1Av2=0.
+      self.mean2v1Av2=0.
+      self.stdv1Av2=0.
+      self.minv1Sv2=self.minv1Av2
+      self.maxv1Sv2=-self.minv1Av2
+      self.meanv1Sv2=0.
+      self.mean2v1Sv2=0.
+      self.stdv1Sv2=0.
+      self.minv1Dv2=self.minv1Av2
+      self.maxv1Dv2=-self.minv1Av2
+      self.meanv1Dv2=0.
+      self.mean2v1Dv2=0.
+      self.stdv1Dv2=0.
+      self.minv1Pv2=self.minv1Av2
+      self.maxv1Pv2=-self.minv1Av2
+      self.meanv1Pv2=0.
+      self.mean2v1Pv2=0.
+      self.stdv1Pv2=0.
+      self.mae = 0.
+      self.rmse = 0.
+      self.corr = np.array([0., 0.])
+      self.linRegress = np.zeros(5, float)
+      self.polRegress = np.zeros(power+1, float)
+      self.polRegressResidual = 0.
+      self.polRegressSingVal = np.zeros(power+1, float)
+
+# v1 [+ / - / / / *] v2
+##
+      self.Nokvalues1 = 0
+      self.Nokvalues2 = 0
+      self.Nokvalues12 = 0
+      self.NDvalNone = 0
+      for inum in range(self.Nv):
+        if not values1[inum] is None:
+          self.Nokvalues1 = self.Nokvalues1 + 1
+        if not values2[inum] is None:
+          self.Nokvalues2 = self.Nokvalues2 + 1
+        if not values1[inum] is None and not values2[inum] is None:
+          self.Nokvalues12 = self.Nokvalues12 + 1
+          Aval = values1[inum] + values2[inum]
+          Sval = values1[inum] - values2[inum]
+          Pval = values1[inum] * values2[inum]
+          if np.isinf(values1[inum] / values2[inum]) or np.isnan(values1[inum] / values2[inum]):
+            if self.NDvalNone < 1:
+               print warnmsg
+               print '      stats2Val: val1/val2 inf or Nan!!!!'
+            Dval = None
+            self.NDvalNone = self.NDvalNone + 1
+          else:
+            Dval = values1[inum] / values2[inum]
+
+          self.mae = self.mae + abs(Sval)
+          self.rmse = self.rmse + Sval**2
+
+          if Aval < self.minv1Av2:
+            self.minv1Av2 = Aval
+          if Aval > self.maxv1Av2:
+            self.maxv1Av2 = Aval
+          if Sval < self.minv1Sv2:
+            self.minv1Sv2 = Sval
+          if Sval > self.maxv1Sv2:
+            self.maxv1Sv2 = Sval
+          if not Dval is None and Dval < self.minv1Dv2:
+            self.minv1Dv2 = Dval
+          if not Dval is None and  Dval > self.maxv1Dv2:
+            self.maxv1Dv2 = Dval
+          if Pval < self.minv1Pv2:
+            self.minv1Pv2 = Pval
+          if Pval > self.maxv1Pv2:
+            self.maxv1Pv2 = Pval
+
+          self.meanv1Av2 = self.meanv1Av2+Aval
+          self.mean2v1Av2 = self.mean2v1Av2+Aval*Aval
+          self.meanv1Sv2 = self.meanv1Sv2+Sval
+          self.mean2v1Sv2 = self.mean2v1Sv2+Sval*Sval
+          if not Dval is None:
+            self.meanv1Dv2 = self.meanv1Dv2+Dval
+            self.mean2v1Dv2 = self.mean2v1Dv2+Dval*Dval
+          self.meanv1Pv2 = self.meanv1Pv2+Pval
+          self.mean2v1Pv2 = self.mean2v1Pv2+Pval*Pval
+
+##      print 'Nokvalues1: ', self.Nokvalues1, 'Nokvalues2: ', self.Nokvalues2, 'Nokvalues12: ', float(self.Nokvalues12), 'NDvalNone: ',self.NDvalNone
+      self.meanv1Av2 = self.meanv1Av2/float(self.Nokvalues12)
+      self.mean2v1Av2 = self.mean2v1Av2/float(self.Nokvalues12)
+      self.stdv1Av2 = np.sqrt(self.mean2v1Av2-self.meanv1Av2*self.meanv1Av2)
+      self.meanv1Sv2 = self.meanv1Sv2/float(self.Nokvalues12)
+      self.mean2v1Sv2 = self.mean2v1Sv2/float(self.Nokvalues12)
+      self.stdv1Sv2 = np.sqrt(self.mean2v1Sv2-self.meanv1Sv2*self.meanv1Sv2)
+      if self.Nokvalues12 - self.NDvalNone == 0:
+          self.meanv1Dv2 = None
+          self.mean2v1Dv2 = None
+          self.stdv1Dv2 = None
+          print warnmsg
+          print '      stats2Val: all values of val1/val2 are None!'
+      else:
+          self.meanv1Dv2 = self.meanv1Dv2/(float(self.Nokvalues12 - self.NDvalNone))
+          self.mean2v1Dv2 = self.mean2v1Dv2/(float(self.Nokvalues12 - self.NDvalNone))
+          self.stdv1Dv2 = np.sqrt(self.mean2v1Dv2-self.meanv1Dv2*self.meanv1Dv2)
+      self.meanv1Pv2 = self.meanv1Pv2/float(self.Nokvalues12)
+      self.mean2v1Pv2 = self.mean2v1Pv2/float(self.Nokvalues12)
+      self.stdv1Pv2 = np.sqrt(self.mean2v1Pv2-self.meanv1Pv2*self.meanv1Pv2)
+
+      self.mae = self.mae/self.Nokvalues12
+      self.rmse = np.sqrt(self.rmse/self.Nokvalues12)
+
+      self.corr = sts.pearsonr(values1, values2)
+
+      self.linRegress[0], self.linRegress[1], self.linRegress[2], self.linRegress[3], self.linRegress[4] = sts.linregress(values1, values2)
+
+      polyfitvals=np.polyfit(values1, values2, power, full = True)
+
+      self.polRegress = polyfitvals[0]
+      self.polRegressRes = polyfitvals[1]
+      self.polRegressSingVal = polyfitvals[3]
+
+class stats2Val_missVal(object):
+  """two variables Statistics taking into account a missing value class providing:
+  vals1 = variable 1
+  vals2 = variable 2
+  missVal = missing value
+  power = power of the polynomial fitting to apply between both variables
+  self.min[var], self.max[var], self.mean[var], self.mean2[var], self.std[var] of 
+    [var] = var1+var2[v1Av2], var1-var2[v1Sv2], var1/var2[v1Dv2], var1*var2[v1Pv2]
+  self.Nokvalues1: number of correct values of variable 1
+  self.Nokvalues2: number of correct values of variable 2
+  self.Nokvalues12: number of correct coincident values of variable 1 and variable 2
+  self.mae=mean(abs(var1-var2)) 
+  self.rmse=sqrt((var1-var2)**2) 
+  self.correlation (and p-value) 
+  self.linRegress: linear regression [trend, intercept, regression coefficient, p_value, standard error]
+  self.polRegress: polinomial Regresion  of degree [power] [coef**[power], coef**[power-1], ...., coef**0]
+  """
+
+  def __init__(self, vals1, vals2, power, missVal):
+    import numpy as np
+    from scipy import stats as sts
+
+    fname='stats2Val_missVal'
+    if vals1 is None:
+      self.Nv = None
+      self.Nokvalues1 = None
+      self.Nokvalues2 = None
+      self.Nokvalues12 = None
+      self.NDvalNone = None
+      self.minv1Av2 = None
+      self.maxv1Av2 = None
+      self.meanv1Av2 = None
+      self.mean2v1Av2 = None
+      self.stdv1Av2 = None
+      self.minv1Sv2 = None
+      self.maxv1Sv2 = None
+      self.meanv1Sv2 = None
+      self.mean2v1Sv2 = None
+      self.stdv1Sv2 = None
+      self.minv1Dv2 = None
+      self.maxv1Dv2 = None
+      self.meanv1Dv2 = None
+      self.mean2v1Dv2 = None
+      self.stdv1Dv2 = None
+      self.minv1Pv2 = None
+      self.maxv1Pv2 = None
+      self.meanv1Pv2 = None
+      self.mean2v1Pv2 = None
+      self.stdv1Pv2 = None
+      self.mae = None
+      self.rmse = None
+      self.corr = None
+      self.linRegress = None
+      self.polRegress = None
+      self.polRegressResidual = None
+      self.polRegressRes = None
+      self.polRegressSingVal = None
+    else:
+      Npt1 = 1
+      for idim in range(len(vals1.shape)):
+        Npt1 = Npt1 * vals1.shape[idim]
+      if np.sum(vals1 >= missVal) == Npt1:
+          print errormsg
+          print '  ' + fname + ' all values 1 get missing!!'
+          print errormsg
+          quit(-1)
+      Npt2 = 1
+      for idim in range(len(vals2.shape)):
+        Npt2 = Npt2 * vals2.shape[idim]
+      if np.sum(vals2 >= missVal) == Npt2:
+          print errormsg
+          print '  ' + fname + ' all values 2 get missing!!'
+          print errormsg
+          quit(-1)
+      vals10 = np.where(abs(vals1) >= missVal, None, vals1)
+      vals20 = np.where(abs(vals2) >= missVal, None, vals2)
+      values1 = vals10.flatten() 
+      values2 = vals20.flatten() 
+
+      if not len(values1) == len(values2):
+        print errormsg
+        print '    stats2Val: lengths of variables differ!! Lvar1: ', len(values1), ' Lvar2: ',len(values2),' statistics between them can not be computed!'
+        quit(-1)
+
+      self.Nv=Npt1
+      self.minv1Av2=10000000000.
+      self.maxv1Av2=-self.minv1Av2
+      self.meanv1Av2=0.
+      self.mean2v1Av2=0.
+      self.stdv1Av2=0.
+      self.minv1Sv2=self.minv1Av2
+      self.maxv1Sv2=-self.minv1Av2
+      self.meanv1Sv2=0.
+      self.mean2v1Sv2=0.
+      self.stdv1Sv2=0.
+      self.minv1Dv2=self.minv1Av2
+      self.maxv1Dv2=-self.minv1Av2
+      self.meanv1Dv2=0.
+      self.mean2v1Dv2=0.
+      self.stdv1Dv2=0.
+      self.minv1Pv2=self.minv1Av2
+      self.maxv1Pv2=-self.minv1Av2
+      self.meanv1Pv2=0.
+      self.mean2v1Pv2=0.
+      self.stdv1Pv2=0.
+      self.mae = 0.
+      self.rmse = 0.
+      self.corr = np.array([0., 0.])
+      self.linRegress = np.zeros(5, float)
+      self.polRegress = np.zeros(power+1, float)
+      self.polRegressResidual = 0.
+      self.polRegressSingVal = np.zeros(power+1, float)
+
+# v1 [+ / - / / / *] v2
+##
+      self.Nokvalues1 = 0
+      self.Nokvalues2 = 0
+      self.Nokvalues12 = 0
+      self.NDvalNone = 0
+      for inum in range(self.Nv):
+        if not values1[inum] is None:
+          self.Nokvalues1 = self.Nokvalues1 + 1
+        if not values2[inum] is None:
+          self.Nokvalues2 = self.Nokvalues2 + 1
+        if not values1[inum] is None and not values2[inum] is None:
+          self.Nokvalues12 = self.Nokvalues12 + 1
+          Aval = values1[inum] + values2[inum]
+          Sval = values1[inum] - values2[inum]
+          Pval = values1[inum] * values2[inum]
+          if np.isinf(values1[inum] / values2[inum]) or np.isnan(values1[inum] / values2[inum]):
+            if self.NDvalNone < 1:
+               print warnmsg
+               print '      stats2Val: val1/val2 inf or Nan!!!!'
+            Dval = None
+            self.NDvalNone = self.NDvalNone + 1
+          else:
+            Dval = values1[inum] / values2[inum]
+
+          self.mae = self.mae + abs(Sval)
+          self.rmse = self.rmse + Sval**2
+
+          if Aval < self.minv1Av2:
+            self.minv1Av2 = Aval
+          if Aval > self.maxv1Av2:
+            self.maxv1Av2 = Aval
+          if Sval < self.minv1Sv2:
+            self.minv1Sv2 = Sval
+          if Sval > self.maxv1Sv2:
+            self.maxv1Sv2 = Sval
+          if not Dval is None and Dval < self.minv1Dv2:
+            self.minv1Dv2 = Dval
+          if not Dval is None and  Dval > self.maxv1Dv2:
+            self.maxv1Dv2 = Dval
+          if Pval < self.minv1Pv2:
+            self.minv1Pv2 = Pval
+          if Pval > self.maxv1Pv2:
+            self.maxv1Pv2 = Pval
+
+          self.meanv1Av2 = self.meanv1Av2+Aval
+          self.mean2v1Av2 = self.mean2v1Av2+Aval*Aval
+          self.meanv1Sv2 = self.meanv1Sv2+Sval
+          self.mean2v1Sv2 = self.mean2v1Sv2+Sval*Sval
+          if not Dval is None:
+            self.meanv1Dv2 = self.meanv1Dv2+Dval
+            self.mean2v1Dv2 = self.mean2v1Dv2+Dval*Dval
+          self.meanv1Pv2 = self.meanv1Pv2+Pval
+          self.mean2v1Pv2 = self.mean2v1Pv2+Pval*Pval
+
+##      print 'Nokvalues1: ', self.Nokvalues1, 'Nokvalues2: ', self.Nokvalues2, 'Nokvalues12: ', float(self.Nokvalues12), 'NDvalNone: ',self.NDvalNone
+      self.meanv1Av2 = self.meanv1Av2/float(self.Nokvalues12)
+      self.mean2v1Av2 = self.mean2v1Av2/float(self.Nokvalues12)
+      self.stdv1Av2 = np.sqrt(self.mean2v1Av2-self.meanv1Av2*self.meanv1Av2)
+      self.meanv1Sv2 = self.meanv1Sv2/float(self.Nokvalues12)
+      self.mean2v1Sv2 = self.mean2v1Sv2/float(self.Nokvalues12)
+      self.stdv1Sv2 = np.sqrt(self.mean2v1Sv2-self.meanv1Sv2*self.meanv1Sv2)
+      if self.Nokvalues12 - self.NDvalNone == 0:
+          self.meanv1Dv2 = None
+          self.mean2v1Dv2 = None
+          self.stdv1Dv2 = None
+          print warnmsg
+          print '      stats2Val: all values of val1/val2 are None!'
+      else:
+          self.meanv1Dv2 = self.meanv1Dv2/(float(self.Nokvalues12 - self.NDvalNone))
+          self.mean2v1Dv2 = self.mean2v1Dv2/(float(self.Nokvalues12 - self.NDvalNone))
+          self.stdv1Dv2 = np.sqrt(self.mean2v1Dv2-self.meanv1Dv2*self.meanv1Dv2)
+      self.meanv1Pv2 = self.meanv1Pv2/float(self.Nokvalues12)
+      self.mean2v1Pv2 = self.mean2v1Pv2/float(self.Nokvalues12)
+      self.stdv1Pv2 = np.sqrt(self.mean2v1Pv2-self.meanv1Pv2*self.meanv1Pv2)
+
+      self.mae = self.mae/self.Nokvalues12
+      self.rmse = np.sqrt(self.rmse/self.Nokvalues12)
+
+      vals1Nomiss = np.ones(len(values1), dtype=bool)
+      vals2Nomiss = np.ones(len(values1), dtype=bool)
+
+      for i in range(len(values1)):
+          if values1[i] is None:
+              vals1Nomiss[i] = False
+
+      for i in range(len(values2)):
+          if values2[i] is None:
+              vals2Nomiss[i] = False
+
+      v1 = np.array(values1[vals1Nomiss], dtype=float)
+      v2 = np.array(values2[vals2Nomiss], dtype=float)
+
+      if not v1.shape == v2.shape:
+          print errormsg
+          print '  ' + fname + ': variables without missing values v1: ',v1.shape , ' and v2: ',v2.shape ,' do not have the same shape! '
+          print errormsg
+          quit(-1)
+
+      self.corr = sts.pearsonr(v1, v2)
+
+      self.linRegress[0], self.linRegress[1], self.linRegress[2], self.linRegress[3], self.linRegress[4] = sts.linregress(v1, v2)
+
+      polyfitvals=np.polyfit(v1, v2, power, full = True)
+
+      self.polRegress = polyfitvals[0]
+      self.polRegressRes = polyfitvals[1]
+      self.polRegressSingVal = polyfitvals[3]
+
+def mask_2masked(vals1, vals2):
+    """ Function to provide the boolean matrix (in opposite way as it is in the mask) as combination of mask from to masked matrices
+    """
+    import numpy.ma as ma
+    fname = 'mask_2masked'
+
+#    if len(vals1.shape) != len(vals2.shape):
+#        print errormsg
+#        print '  ' + fname + ' matrix 1 :', len(vals1.shape), ' and matrix 2 ', len(vals2.shape), ' have different size!'
+#        print errormsg
+#        quit(-1)
+
+#    for idim in range(len(vals1.shape)):
+#        if vals1.shape[idim] != vals2.shape[idim]:
+#            print errormsg
+#            print '  ' + fname + ' dimension ', idim,' from matrix 1 :', vals1.shape[idim], ' and matrix 2 ', \
+#                vals2.shape[idim], ' have different size!'
+#            print errormsg
+#            quit(-1)
+
+    if type(vals1) == type(ma.array(1)):
+        mask1array=np.where(ma.getmaskarray(vals1) == False, True, False)
+    else:
+        mask1array=np.ones(vals1.shape, dtype=bool)
+
+    if type(vals2) == type(ma.array(1)):
+        mask2array=np.where(ma.getmaskarray(vals2) == False, True, False)
+    else:
+        mask2array=np.ones(vals2.shape, dtype=bool)
+
+    mask12 = mask1array*mask2array
+
+    return mask12
+
+def mask_pearsonr(xvals, yvals):
+    """ Function to compute a pearson correlation from mask matrices
+    """
+    from scipy import stats as sts
+    fillVal = 1.e20
+    maskxy = mask_2masked(xvals, yvals)
+
+    if np.sum(maskxy) > 1:
+        pearsonr = sts.pearsonr(xvals[maskxy], yvals[maskxy])
+        if np.isnan(pearsonr[0]) or np.isnan(pearsonr[1]): 
+           pearsonr = ( fillVal, fillVal)
+    else:
+        pearsonr = (fillVal, fillVal)
+
+    return pearsonr
+
+def mask_quantiles(maskmat, Nquants):
+    """ Function to provide the quantiles of a masked array 20 for %5 bins (21 in total)
+    """
+    import numpy.ma as ma
+
+    fillValue = 1.e20
+
+    sortmat = maskmat.flatten().copy()
+    sortmat.sort()
+    quants = np.zeros(Nquants+1, dtype=type(maskmat[0]))
+    Nv = ma.size(maskmat)
+    NoMask=maskmat.count()
+
+    if NoMask < Nquants:
+        quants[:] = fillValue
+    else:
+        for iq in range(Nquants):
+            quants[iq] = sortmat[int((NoMask-1)*iq/(Nquants))]
+
+        quants[Nquants] = sortmat[NoMask-1]
+
+    return quants
+
+def percendone(nvals,tot,percen,msg):
+    """ Function to provide the percentage of an action across the matrix
+    nvals=number of values
+    tot=total number of values
+    percen=percentage frequency for which the message is wanted
+    msg= message
+    """
+    from sys import stdout
+
+    num = int(tot * percen/100)
+    if (nvals%num == 0): 
+        print '\r        ' + msg + '{0:8.3g}'.format(nvals*100./tot) + ' %',
+        stdout.flush()
+
+    return ''
+
+def mask_linregres(vals1, vals2):
+    """ Function to compute a linear regression from masked data
+    vals1: x-values for the regresion
+    vals2: y-values for the regresion
+    """
+    import numpy.ma as ma
+
+    fname = 'mask_linregres'
+
+    missval1 = vals1.get_fill_value()    
+    missval2 = vals2.get_fill_value()    
+
+    vals10 = np.where(abs(vals1) >= abs(missval1*0.9), None, vals1)
+    vals20 = np.where(abs(vals2) >= abs(missval2*0.9), None, vals2)
+
+    values1 = vals10.flatten() 
+    values2 = vals20.flatten() 
+
+    vals1Nomiss = np.ones(len(values1), dtype=bool)
+    vals2Nomiss = np.ones(len(values2), dtype=bool)
+
+    for i in range(len(values1)):
+        if values1[i] is None:
+            vals1Nomiss[i] = False
+    for i in range(len(values2)):
+        if values2[i] is None:
+            vals2Nomiss[i] = False
+
+    v1 = np.array(values1[vals1Nomiss], dtype=float)
+    v2 = np.array(values2[vals2Nomiss], dtype=float)
+
+    if len(v1) != len(v2):
+        print errormsg
+        print fname + ': length of masked matrices mat1:',len(v1),'and mat2:',len(v2),'does not match!'
+        print errormsg
+        quit(-1)
+
+    linregres = np.array(sts.linregress(v1, v2), dtype= np.float64)
+
+    return linregres
+
+def mask_space_stats(maskmat,statsvals,dim):
+    """ Function to give back the multi-dimensional statisitcs of a given masked array
+    maskmat=multidimensional masked array
+    statsvals=[statn]:[values] 
+      [statn]: statistics to do: 
+        'quant', quantiles
+      [values]: value for the statistics: Nquantiles
+    dim= dimension to run the statistics
+    """
+    from sys import stdout
+
+    fname = 'mask_space_stats'
+
+    statn=statsvals.split(':')[0]
+    if len(statsvals.split(':')) > 1:
+        values=statsvals.split(':')[1]
+
+    maskshape = maskmat.shape
+    Ndims = len(maskshape)
+    if statn == 'quant':
+        if len(statsvals.split(':')) == 1:
+            print errormsg
+            print fname + ': statistics "' + statn + '" requires a value!!!'
+            print errormsg
+            quit(-1)
+        Nquants=int(values)
+        if Ndims == 2:
+            if dim == 0:
+                statval = np.ones((21, maskshape[1]), dtype=np.float64)*fillValue
+                for i in range(maskshape[1]):
+                   percendone(i, maskshape[1], 5, 'quantiles')
+                   statval[:,i] = mask_quantiles(maskmat[:,i],Nquants)
+            if dim == 1:
+                statval = np.ones((21, maskshape[0]), dtype=np.float64)*fillValue
+                for i in range(maskshape[0]):
+                   percendone(i, maskshape[0], 5, 'quantiles')
+                   statval[:,i] = mask_quantiles(statval[i,:],Nquants)
+        elif Ndims == 3:
+            if dim == 0:
+                statval = np.ones((21, maskshape[1], maskshape[2]), dtype=np.float64)*fillValue
+                for i in range(maskshape[1]):
+                    for j in range(maskshape[2]):
+                        percendone(i*maskshape[2] + j, maskshape[1]*maskshape[2], 5, 'quantiles')
+                        statval[:,i,j] = mask_quantiles(maskmat[:,i,j],Nquants)
+            if dim == 1:
+                statval = np.ones((21, maskshape[0], maskshape[2]), dtype=np.float64)*fillValue
+                for i in range(maskshape[0]):
+                    for j in range(maskshape[2]):
+                        percendone(i*maskshape[2] + j, maskshape[0]*maskshape[2], 5, 'quantiles')
+                        statval[:,i,j] = mask_quantiles(maskmat[i,:,j],Nquants)
+            if dim == 2:
+                statval = np.ones((21, maskshape[0], maskshape[1]), dtype=np.float64)*fillValue
+                for i in range(maskshape[0]):
+                    for j in range(maskshape[1]):
+                        percendone(i*maskshape[1] + j, maskshape[0]*maskshape[1], 5, 'quantiles')
+                        statval[:,i,j] = mask_quantiles(maskmat[i,j,:],Nquants)
+        elif Ndims == 4:
+            if dim == 0:
+                statval = np.ones((21, maskshape[1], maskshape[2], maskshape[3]), dtype=np.float64)*fillValue
+                for i in range(maskshape[1]):
+                    for j in range(maskshape[2]):
+                        for k in range(maskshape[3]):
+                            percendone(i*maskshape[1]*maskshape[2] + j*maskshape[2] + k, maskshape[1]*maskshape[2]*maskshape[3], 5, 'quantiles')
+                            statval[:,i,j,k] = mask_quantiles(maskmat[:,i,j,k],Nquants)
+            if dim == 1:
+                statval = np.ones((21, maskshape[0], maskshape[2], maskshape[3]), dtype=np.float64)*fillValue
+                for i in range(maskshape[0]):
+                    for j in range(maskshape[2]):
+                        for k in range(maskshape[3]):
+                            percendone(i*maskshape[0]*maskshape[2] + j*maskshape[2] + k, maskshape[0]*maskshape[2]*maskshape[3], 5, 'quantiles')
+                            statval[:,i,j,k] = mask_quantiles(maskmat[i,:,j,k],Nquants)
+            if dim == 2:
+                statval = np.ones((21, maskshape[0], maskshape[1], maskshape[3]), dtype=np.float64)*fillValue
+                for i in range(maskshape[0]):
+                    for j in range(maskshape[1]):
+                        for k in range(maskshape[3]):
+                            percendone(i*maskshape[0]*maskshape[1] + j*maskshape[1] + k, maskshape[0]*maskshape[1]*maskshape[3], 5, 'quantiles')
+                            statval[:,i,j,k] = mask_quantiles(maskmat[i,j,:,k],Nquants)
+            if dim == 3:
+                statval = np.ones((21, maskshape[0], maskshape[1], maskshape[2]), dtype=np.float64)*fillValue
+                for i in range(maskshape[0]):
+                    for j in range(maskshape[1]):
+                        for k in range(maskshape[2]):
+                            percendone(i*maskshape[0]*maskshape[1] + j*maskshape[1] + k, maskshape[0]*maskshape[1]*maskshape[2], 5, 'quantiles')
+                            statval[:,i,j,k] = mask_quantiles(maskmat[i,j,k,:],Nquants)
+        else:
+            print errormsg
+            print fname + ': size of matrix ', Ndims,'not ready!!!'
+            print errormsg
+            quit(-1)
+
+    else:
+        print errormsg
+        print fname + ':  statistics "' + statn + '" not ready!!!!'
+        print errormsg
+        quit(-1)
+
+    print stdout.write("\n")
+    
+    return statval
+
+class statsVal(object):
+  """Statistics class providing
+  vals = variable
+  self.Nv = number of values
+  self.minv = minimum value
+  self.maxv = maximum value
+  self.meanv = mean value
+  self.mean2v = cuadratic mean value
+  self.stdv = standard deviation value
+  self.Nokvalues = number of correct values of variable
+  self.quantilesv = quantiles (%5 bins) of the variable
+  """
+
+  def __init__(self, vals):
+    if vals is None:
+      self.Nv = None
+      self.minv = None
+      self.maxv = None
+      self.meanv = None
+      self.mean2v = None
+      self.stdv = None
+      self.Nokvalues = None
+      self.quantilesv = None
+    else:
+      values = vals.flatten() 
+      self.Nv=len(values)
+      self.minv=10000000000.
+      self.maxv=-100000000.
+      self.meanv=0.
+      self.mean2v=0.
+      self.stdv=0.
+
+      sortedvalues = sorted(values)
+
+      self.Nokvalues = 0
+      for inum in range(self.Nv):
+        if not values[inum] is None:
+          self.Nokvalues = self.Nokvalues + 1
+          if values[inum] < self.minv:
+            self.minv = values[inum]
+          if values[inum] > self.maxv:
+            self.maxv = values[inum]
+
+          self.meanv = self.meanv+values[inum]
+          self.mean2v = self.mean2v+values[inum]*values[inum]
+
+      self.meanv = self.meanv/float(self.Nokvalues)
+      self.mean2v = self.mean2v/float(self.Nokvalues)
+      self.stdv = np.sqrt(self.mean2v-self.meanv*self.meanv)
+      self.quantilesv = []
+      for iq in range(20):
+        self.quantilesv.append(sortedvalues[int((self.Nv-1)*iq/20)])
+
+      self.quantilesv.append(sortedvalues[self.Nv-1])
+      self.medianv = self.quantilesv[10]
+
+class Quantiles(object):
+    """ Class to provide quantiles from a given arrayof values
+    """
+
+    def __init__(self, values, Nquants):
+        import numpy.ma as ma
+
+        if values is None:
+            self.quantilesv = None
+
+        else:
+            self.quantilesv = []
+
+            vals0 = values.flatten()
+            Nvalues = len(vals0)
+            vals = ma.masked_equal(vals0, None)
+            Nvals=len(vals.compressed())
+
+            sortedvals = sorted(vals.compressed())
+            for iq in range(Nquants):
+                self.quantilesv.append(sortedvals[int((Nvals-1)*iq/Nquants)])
+
+            self.quantilesv.append(sortedvals[Nvals-1])
+
+class statsVal_missVal(object):
+  """Statistics class tacking into account a missing value providing
+  vals = variable
+  missval = missing value
+  self.Nv = number of values
+  self.minv = minimum value
+  self.maxv = maximum value
+  self.meanv = mean value
+  self.mean2v = cuadratic mean value
+  self.stdv = standard deviation value
+  self.Nokvalues = number of correct values of variable
+  self.quantilesv = quantiles (%5 bins) of the variable
+  """
+
+  def __init__(self, vals, missVal):
+    fname='statsVal_missVal'
+  
+    if vals is None:
+      self.Nv = None
+      self.minv = None
+      self.maxv = None
+      self.meanv = None
+      self.mean2v = None
+      self.stdv = None
+      self.Nokvalues = None
+      self.quantilesv = None
+    else:
+      Npt = 1
+      for idim in range(len(vals.shape)):
+        Npt = Npt * vals.shape[idim]
+      if np.sum(vals >= missVal) == Npt:
+          print errormsg
+          print '  ' + fname + ' all values get missing!!'
+          print errormsg
+          quit(-1)
+
+      vals1 = np.where(abs(vals) >= missVal, None, vals)
+      vals0 = np.where(np.isnan(vals1), None, vals1)
+
+      values = vals0.flatten() 
+      self.Nv=Npt
+      self.minv=10000000000.
+      self.maxv=-100000000.
+      self.meanv=0.
+      self.mean2v=0.
+      self.stdv=0.
+
+      sortedvalues = sorted(values)
+
+      self.Nokvalues = 0
+      for inum in range(self.Nv):
+        if not values[inum] is None:
+          self.Nokvalues = self.Nokvalues + 1
+          if values[inum] < self.minv:
+            self.minv = values[inum]
+          if values[inum] > self.maxv:
+            self.maxv = values[inum]
+
+          self.meanv = self.meanv+values[inum]
+          self.mean2v = self.mean2v+values[inum]*values[inum]
+
+      self.meanv = self.meanv/float(self.Nokvalues)
+      self.mean2v = self.mean2v/float(self.Nokvalues)
+      self.stdv = np.sqrt(self.mean2v-self.meanv*self.meanv)
+      self.quantilesv = []
+      for iq in range(20):
+        self.quantilesv.append(sortedvalues[int((self.Nv-1)*iq/20)])
+
+      self.quantilesv.append(sortedvalues[self.Nv-1])
+      self.medianv = self.quantilesv[10]
+
+def spacemean(ncfile, varn):
+  """ Function to retrieve a space mean series from a multidimensional variable of a file
+  ncfile = netCDF file name
+  varn = variable name
+  """
+  import datetime as dt
+  import calendar as cal
+
+  ofile = 'spacemean_' + varn + '.nc'
+  varfil=1.e20
+  statsn = ['min', 'max', 'mean', 'mean2', 'stdv', 'meanwgt', 'mean2wgt', 'stdvwgt', 'quant']
+  statslongn = ['minimum', 'maximum', 'mean', 'quadratic mean', 'standard deviation', 'weigthed mean',  'weigthed quadratic mean', 'weigthed standard deviation', 'quantiles']
+
+  ncf = NetCDFFile(ncfile,'r')
+
+  if not ncf.variables.has_key(varn):
+    print errormsg
+    print '    spacemean: File "' + ncfile + '" does not have variable "' + varn + '" !!!!'
+    print errormsg
+    ncf.close()
+    quit(-1)
+
+  times = ncf.variables['time']
+  timevals = times[:]
+
+  attvar = times.ncattrs()
+  if not searchInlist(attvar, 'units'):
+    print errormsg
+    print '    spacemean: "time" does not have attribute: "units"'
+    ncf.close()
+    quit(-1)
+  else:
+    units = times.getncattr('units')
+  
+  txtunits = units.split(' ')
+  tunits = txtunits[0]
+  Srefdate = txtunits[len(txtunits) - 1]
+# Does reference date contain a time value [YYYY]-[MM]-[DD] [HH]:[MI]:[SS]
+##
+  timeval = Srefdate.find(':')
+
+  if not timeval == -1:
+    print '      spacemean: refdate with time!'
+    refdate = datetimeStr_datetime(txtunits[len(txtunits) - 2] + '_' + Srefdate)
+  else:
+    refdate = dateStr_date(Srefdate)
+
+  dimt = len(timevals)
+  realdates = np.zeros((dimt, 6), dtype=int)
+  print realdates.shape
+
+## Not in timedelta
+#  if tunits == 'years':
+#    for it in range(dimt):
+#      realdate = refdate + dt.timedelta(years=float(times[it]))
+#      realdates[it] = int(realdate.year)
+#  elif tunits == 'months':
+#    for it in range(dimt):
+#      realdate = refdate + dt.timedelta(months=float(times[it]))
+#      realdates[it] = int(realdate.year)
+  if tunits == 'weeks':
+    for it in range(dimt):
+      realdate = refdate + dt.timedelta(weeks=float(times[it]))
+      realdates[it,0] = int(realdate.year)
+      realdates[it,1] = int(realdate.month)
+      realdates[it,2] = int(realdate.day)
+      realdates[it,3] = int(realdate.hour)
+      realdates[it,4] = int(realdate.second)
+      realdates[it,5] = int(realdate.minute)
+  elif tunits == 'days':
+    for it in range(dimt):
+      realdate = refdate + dt.timedelta(days=float(times[it]))
+      realdates[it,0] = int(realdate.year)
+      realdates[it,1] = int(realdate.month)
+      realdates[it,2] = int(realdate.day)
+      realdates[it,3] = int(realdate.hour)
+      realdates[it,4] = int(realdate.second)
+      realdates[it,5] = int(realdate.minute)
+  elif tunits == 'hours':
+    for it in range(dimt):
+      realdate = refdate + dt.timedelta(hours=float(times[it]))
+      realdates[it,0] = int(realdate.year)
+      realdates[it,1] = int(realdate.month)
+      realdates[it,2] = int(realdate.day)
+      realdates[it,3] = int(realdate.hour)
+      realdates[it,4] = int(realdate.second)
+      realdates[it,5] = int(realdate.minute)
+  elif tunits == 'minutes':
+    for it in range(dimt):
+      realdate = refdate + dt.timedelta(minutes=float(times[it]))
+      realdates[it,0] = int(realdate.year)
+      realdates[it,1] = int(realdate.month)
+      realdates[it,2] = int(realdate.day)
+      realdates[it,3] = int(realdate.hour)
+      realdates[it,4] = int(realdate.second)
+      realdates[it,5] = int(realdate.minute)
+  elif tunits == 'seconds':
+    for it in range(dimt):
+      realdate = refdate + dt.timedelta(seconds=float(times[it]))
+      realdates[it,0] = int(realdate.year)
+      realdates[it,1] = int(realdate.month)
+      realdates[it,2] = int(realdate.day)
+      realdates[it,3] = int(realdate.hour)
+      realdates[it,4] = int(realdate.second)
+      realdates[it,5] = int(realdate.minute)
+  elif tunits == 'milliseconds':
+    for it in range(dimt):
+      realdate = refdate + dt.timedelta(milliseconds=float(times[it]))
+      realdates[it,0] = int(realdate.year)
+      realdates[it,1] = int(realdate.month)
+      realdates[it,2] = int(realdate.day)
+      realdates[it,3] = int(realdate.hour)
+      realdates[it,4] = int(realdate.second)
+      realdates[it,5] = int(realdate.minute)
+  else:
+    print errormsg
+    print '    spacemean: time units "' + tunits + '" not ready!!!!'
+    ncf.close()
+    quit(-1)
+
+# Variable values (assuming time as first dimension)
+##
+  var = ncf.variables[varn]
+  varinf = variable_inf(var)
+  if searchInlist(varinf.attributes, 'scale_factor'):
+    scalefact = var.getncattr('scale_factor')
+    print '      spacemean: data has a scale factor of ', scalefact
+    varinf.dtype=type(np.float(1.))
+  else:
+    scalefact = 1.
+
+  if searchInlist(varinf.attributes, 'add_offset'):
+    offset = var.getncattr('add_offset')
+    print '      spacemean: data has an offset of ', offset
+  else:
+    offset = 0.
+
+#  varvals = var[:]
+  vardims = var.shape
+  varshape = len(vardims)
+  vardimns = var.dimensions
+##  print '      spacemean: Shape of data: ',varshape, ':' , vardims
+  dimt=vardims[0]
+  vardnames = []
+
+# Spatial average spatial weigthed
+## 
+  lonvar = ncf.variables['lon']
+  latvar = ncf.variables['lat']
+
+  if not len(lonvar.shape) == 2:
+    lonv = lonvar[:]
+    latv = latvar[:]
+    dx=lonvar.shape[0]
+    dy=latvar.shape[0]
+    lonval = np.zeros((dy, dx), dtype=np.float64)    
+    latval = np.zeros((dy, dx), dtype=np.float64)    
+    for iy in range(dy):
+      lonval[iy,:] = lonv
+    for ix in range(dx):
+      latval[:,ix] = latv
+  else:
+    lonval = lonvar[:]
+    latval = latvar[:]
+
+  weightsv = abs(np.cos(latval*np.pi/180.))
+
+  if varinf.Ndims == 1:
+    print errormsg
+    print '    spacemean: You can not compute a space mean for a ', varinf.Ndims, 'D var!!!'
+    ncf.close()
+    quit(-1)
+  elif varinf.Ndims== 2:
+    print errormsg
+    print '    spacemean: You can not compute a space mean for a ', varinf.Ndims, 'D var!!!'
+    ncf.close()
+    quit(-1)
+  elif varinf.Ndims == 3:
+    varstats = np.ones((dimt, 8), dtype=np.float64)
+    varstats = varstats*varfil
+    varquant = np.ones((dimt, 21), dtype=np.float64)
+    varquant = varquant*varfil
+    vardnames.append(vardimns[0])
+    dy=vardims[1]
+    dx=vardims[2]
+    for it in range(dimt):
+      if not varinf.FillValue is None:
+        varvl = var[it,:,:]
+        varval = np.where(varvl == varinf.FillValue, None, varvl)
+      else:
+        varval = var[it,:,:]
+      percendone(it,dimt,5,'computed space statistics')
+      varst = statsVal(varval)
+      varstwgt  = statsValWeigthed(varval, weightsv)
+      varstats[it,0] = varst.minv
+      varstats[it,1] = varst.maxv
+      varstats[it,2] = varst.meanv
+      varstats[it,3] = varst.mean2v
+      varstats[it,4] = varst.stdv
+      varquant[it,:] = varst.quantilesv
+      varstats[it,5] = varstwgt.meanv
+      varstats[it,6] = varstwgt.mean2v
+      varstats[it,7] = varstwgt.stdv
+  elif varshape == 4:
+    varstats = np.ones((dimt, vardims[1], 8), dtype=np.float64)
+    varstats = varstats*varfil
+    varquant = np.ones((dimt, vardims[1], 21), dtype=np.float64)
+    varquant = varquant*varfil
+    vardimnames = (str(vardimns[0]), str(vardimns[1]))
+    vardnames.append(vardimns[0])
+    vardnames.append(vardimns[1])
+    dy=vardims[2]
+    dx=vardims[3]
+    for it in range(dimt):
+      for ik in range(vardims[1]):
+        if not varinf.FillValue is None:
+          varvl = var[it,ik,:,:]
+          varval = np.where(varvl == varinf.FillValue, None, varvl)
+        else:
+          varval = var[it,ik,:,:]
+        percendone(it*vardims[1]+ik,dimt*vardims[1],5,'computed space statistics')
+        varst = statsVal(varval)
+        varstwgt  = statsValWeigthed(varval, weightsv)
+        varstats[it,ik,0] = varst.minv
+        varstats[it,ik,1] = varst.maxv
+        varstats[it,ik,2] = varst.meanv
+        varstats[it,ik,3] = varst.mean2v
+        varstats[it,ik,4] = varst.stdv
+        varquant[it,ik,:] = varst.quantilesv
+        varstats[it,ik,5] = varstwgt.meanv
+        varstats[it,ik,6] = varstwgt.mean2v
+        varstats[it,ik,7] = varstwgt.stdv
+  elif varshape == 5:
+    varstats = np.ones((dimt, vardims[1], vardims[2], 8), dtype=np.float64)
+    varstats = varstats*varfil
+    varquant = np.ones((dimt,  vardims[1], vardims[2], 21), dtype=np.float64)
+    varquant = varquant*varfil
+    vardnames.append(vardimns[0])
+    vardnames.append(vardimns[1])
+    vardnames.append(vardimns[2])
+    dy=vardims[3]
+    dx=vardims[4]
+    for it in range(dimt):
+      for ik in range(vardims[1]):
+        for il in range(vardims[2]):
+          if not varinf.FillValue is None:
+            varvl = var[it,ik,il,:,:]
+            varval = np.where(varvl == varinf.FillValue, None, varvl)
+          else:
+            varval = var[it,ik,il,:,:]
+
+          percendone(it*vardims[1]*vardims[2]+ik*vardims[1]+il,dimt*vardims[1]*vardims[2],5,'computed space statistics')
+          varst = statsVal(varval)
+          varstwgt  = statsValWeigthed(varval, weightsv)
+          varstats[it,ik,il,0] = varst.minv
+          varstats[it,ik,il,1] = varst.maxv
+          varstats[it,ik,il,2] = varst.meanv
+          varstats[it,ik,il,3] = varst.mean2v
+          varstats[it,ik,il,4] = varst.stdv
+          varquant[it,ik,il,:] = varst.quantilesv
+          varstats[it,ik,il,5] = varstwgt.meanv
+          varstats[it,ik,il,6] = varstwgt.mean2v
+          varstats[it,ik,il,7] = varstwgt.stdv
+  else:
+     print errormsg
+     print '    spacemean: ', varshape, ' shape of matrix not prepared !'
+     ncf.close()
+     quit(-1)
+
+  vardimnames = tuple(vardnames)
+#  print '  shape of desired values: ', vardesiredvalues.shape
+# Creation of file
+##
+
+  ncfo = NetCDFFile( ofile, 'w')
+
+  vartype = var.dtype
+  varattr = var.ncattrs()
+
+# Checking dimensions
+##
+  newdims = ncfo.dimensions
+  Nvardnames = len(vardimnames)
+  for idim in range(Nvardnames):
+      rdim = vardimnames[idim] 
+      if not searchInlist(newdims, rdim):
+          if not rdim == 'time':
+              print '      spacemean: Adding dimension ' + rdim
+              ncfo.sync()
+              ncf.close()
+              ncfo.close()
+              fdimadd(ncfile + ',' + rdim, ofile)
+              ncf = NetCDFFile(ncfile,'r')
+              ncfo = NetCDFFile(ofile,'a')
+          else:
+              ncfo.createDimension('time', None)
+
+# Checking fill value
+## 
+  if searchInlist(varattr, '_FillValue'):
+      varfil = var._FillValue
+  else:
+      varfil = False
+
+  Nstats = len(statsn)
+  for ist in range(Nstats):
+    if statsn[ist] == 'quant':
+      print ist, statsn[ist]##, ': ', varquant[int(dimt/2),10]
+      newdim = ncfo.createDimension('quant', 21)
+      newvardnames = list(vardnames)
+      newvardnames.append('quant')
+      newvar = ncfo.createVariable(varn + statsn[ist], varinf.dtype, tuple(newvardnames), fill_value=varfil)
+      newvar[:] = varquant
+    else:
+      print ist, statsn[ist]##, ': ', varstats[int(dimt/2),ist]
+      newvar = ncfo.createVariable(varn + statsn[ist], varinf.dtype, vardimnames, fill_value=varfil)
+      if varshape == 3:
+        newvar[:] = varstats[:,ist]*1.
+      elif varshape == 4:
+        newvar[:] = varstats[:,:,ist]*1.
+      elif varshape == 5:
+        newvar[:] = varstats[:,:,:,ist]*1.
+
+    newvar = ncfo.variables[varn + statsn[ist]]
+    for attr in varattr:
+         newvarattrs = newvar.ncattrs()
+         attrv = var.getncattr(attr)
+         if not searchInlist(newvarattrs, attr):
+             if attr != 'scale_factor' and attr != 'add_offset' and attr != 'valid_range' \
+                and attr != 'unpacked_valid_range' and attr != 'actual_range' :
+#                 if not statsn[ist] == 'stdv' and not statsn[ist] == 'stdvwgt':
+                     print 'attr:', attr
+                     newvar.setncattr(attr, attrv)
+#             else:
+#                 newvar.setncattr(attr, attrv)
+    
+    newvar.setncattr('cell_methods', 'space ' + statslongn[ist] + ' all domain ' + str(dy) + 'x' + str(dx))
+
+##  print '  Adding time variable'
+  vartdims = times.dimensions
+  vartype = times.dtype
+  varattr = times.ncattrs()
+
+  newvar = ncfo.createVariable('time', vartype, vartdims, fill_value=varfil)
+  newvar = ncfo.variables['time']
+  newvar[:] = times
+
+  ncf.close()
+  ncfo.sync()
+  ncfo.close()
+  fattradd('time', ncfile + ':time', ofile)
+  fvaradd(ncfile + ':lon', ofile)
+  fvaradd(ncfile + ':lat', ofile)
+
+  ncfo = NetCDFFile(ofile,'a')
+  newvar = ncfo.variables['time']
+  newvarattrs = newvar.ncattrs()
+  if searchInlist(newvarattrs, 'bounds'):
+      if newvar.getncattr('bounds') == 'time_bnds':
+          ncf = NetCDFFile(ncfile,'r')
+          tbnds = ncf.variables['time_bnds']
+          vardims = tbnds.dimensions
+          vartype = tbnds.dtype
+          varattr = tbnds.ncattrs()
+          ncfo.createDimension('bnds', 2)
+          newvar = ncfo.createVariable('time_bnds', vartype, vardims, fill_value=varfil)
+          newvar[:] = tbnds[:]
+
+          ncf.close()
+          ncfo.sync()
+          ncfo.close()
+          fattradd('time_bnds', ncfile + ':time_bnds', ofile)
+      else:
+          ncfo.close()
+  else:
+      ncfo.close()
+
+  fgaddattr(ncfile, ofile)
+
+  print '    spacemean: File "' + ofile + '" as space mean of "' + varn + '" has been created'
+
+def timemean(values, ncfile, varn):
+  """ Function to retrieve a time mean series from a multidimensional variable of a file
+  values = power of the polynomial fitting with time to be applied
+  ncfile = netCDF file name
+  varn = variable name
+  """
+  import datetime as dt
+  import calendar as cal
+
+  powerv=int(values)
+  ofile = 'timemean_' + varn + '.nc'
+  varfil=1.e20
+  statsn = ['min', 'max', 'mean', 'mean2', 'stdv', 'quant','linregress','polregress']
+  statslongn = ['minimum', 'maximum', 'mean', 'quadratic mean', 'standard deviation', 'quantiles', \
+    'linear regression', 'polynomial regression']
+
+  ncf = NetCDFFile(ncfile,'r')
+
+  if not ncf.variables.has_key(varn):
+    print errormsg
+    print '    timemean: File  "' + ncfile + '" does not have variable ' + varn + ' !!!!'
+    print errormsg
+    ncf.close()
+    quit(-1)
+
+  times = ncf.variables['time']
+  timevals = times[:]
+
+  attvar = times.ncattrs()
+  if not searchInlist(attvar, 'units'):
+    print errormsg
+    print '    timemean: "time" does not have attribute: "units"'
+    ncf.close()
+    quit(-1)
+  else:
+    units = times.getncattr('units')
+  
+  txtunits = units.split(' ')
+  tunits = txtunits[0]
+  Srefdate = txtunits[len(txtunits) - 1]
+# Does reference date contain a time value [YYYY]-[MM]-[DD] [HH]:[MI]:[SS]
+##
+  timeval = Srefdate.find(':')
+
+  if not timeval == -1:
+    print '      timemean: refdate with time!'
+    refdate = datetimeStr_datetime(txtunits[len(txtunits) - 2] + '_' + Srefdate)
+  else:
+    refdate = dateStr_date(Srefdate)
+
+  dimt = len(timevals)
+  realdates = np.zeros((dimt, 6), dtype=int)
+  print realdates.shape
+
+## Not in timedelta
+#  if tunits == 'years':
+#    for it in range(dimt):
+#      realdate = refdate + dt.timedelta(years=float(times[it]))
+#      realdates[it] = int(realdate.year)
+#  elif tunits == 'months':
+#    for it in range(dimt):
+#      realdate = refdate + dt.timedelta(months=float(times[it]))
+#      realdates[it] = int(realdate.year)
+  if tunits == 'weeks':
+    for it in range(dimt):
+      realdate = refdate + dt.timedelta(weeks=float(times[it]))
+      realdates[it,0] = int(realdate.year)
+      realdates[it,1] = int(realdate.month)
+      realdates[it,2] = int(realdate.day)
+      realdates[it,3] = int(realdate.hour)
+      realdates[it,4] = int(realdate.second)
+      realdates[it,5] = int(realdate.minute)
+  elif tunits == 'days':
+    for it in range(dimt):
+      realdate = refdate + dt.timedelta(days=float(times[it]))
+      realdates[it,0] = int(realdate.year)
+      realdates[it,1] = int(realdate.month)
+      realdates[it,2] = int(realdate.day)
+      realdates[it,3] = int(realdate.hour)
+      realdates[it,4] = int(realdate.second)
+      realdates[it,5] = int(realdate.minute)
+  elif tunits == 'hours':
+    for it in range(dimt):
+      realdate = refdate + dt.timedelta(hours=float(times[it]))
+      realdates[it,0] = int(realdate.year)
+      realdates[it,1] = int(realdate.month)
+      realdates[it,2] = int(realdate.day)
+      realdates[it,3] = int(realdate.hour)
+      realdates[it,4] = int(realdate.second)
+      realdates[it,5] = int(realdate.minute)
+  elif tunits == 'minutes':
+    for it in range(dimt):
+      realdate = refdate + dt.timedelta(minutes=float(times[it]))
+      realdates[it,0] = int(realdate.year)
+      realdates[it,1] = int(realdate.month)
+      realdates[it,2] = int(realdate.day)
+      realdates[it,3] = int(realdate.hour)
+      realdates[it,4] = int(realdate.second)
+      realdates[it,5] = int(realdate.minute)
+  elif tunits == 'seconds':
+    for it in range(dimt):
+      realdate = refdate + dt.timedelta(seconds=float(times[it]))
+      realdates[it,0] = int(realdate.year)
+      realdates[it,1] = int(realdate.month)
+      realdates[it,2] = int(realdate.day)
+      realdates[it,3] = int(realdate.hour)
+      realdates[it,4] = int(realdate.second)
+      realdates[it,5] = int(realdate.minute)
+  elif tunits == 'milliseconds':
+    for it in range(dimt):
+      realdate = refdate + dt.timedelta(milliseconds=float(times[it]))
+      realdates[it,0] = int(realdate.year)
+      realdates[it,1] = int(realdate.month)
+      realdates[it,2] = int(realdate.day)
+      realdates[it,3] = int(realdate.hour)
+      realdates[it,4] = int(realdate.second)
+      realdates[it,5] = int(realdate.minute)
+  else:
+    print errormsg
+    print '    timemean: time units "' + tunits + '" not ready!!!!'
+    ncf.close()
+    quit(-1)
+
+  timesv = (realdates[:,0] - realdates[0,0])*12 + realdates[:,1]
+
+# Variable values (assuming time as first dimension)
+##
+  var = ncf.variables[varn]
+  varinf = variable_inf(var)
+
+#  varvals = var[:]
+  vardims = varinf.dims
+  varshape = varinf.Ndims
+  vardimns = var.dimensions
+
+##  print '     timemean: Shape of data: ',varshape, ':' , vardims
+  dimt=vardims[0]
+  vardnames = []
+
+  if varshape == 1:
+    print errormsg
+    print '    timemean: You can not compute a time mean for a ', varshape, 'D var!!!'
+    ncf.close()    
+    quit(-1)
+  elif varshape == 2:
+    dx=vardims[1]
+    varstats = np.ones((5, dx), dtype=np.float64)
+    varstats = varstats*varfil
+    varquant = np.ones((21, dx), dtype=np.float64)
+    varquant = varquant*varfil
+    varlregress = np.ones((5, dx), dtype=np.float64)
+    varlregress = varlregress*varfil
+    varpregress = np.ones((powerv+1, dx), dtype=np.float64)
+    varpregress = varpregress*varfil
+    varpregressres = np.ones((dx), dtype=np.float64)
+    varpregressres = varpregressres*varfil
+    varpregresssingval = varpregress.copy()
+    varpregresssingval = varpregresssingval*varfil
+    vardnames.append(vardimns[1])
+    for ix in range(dx):
+      if not varinf.FillValue is None:
+        varvl = var[:,ix]
+        varval = np.where(varvl == varinf.FillValue, None, varvl)
+      else:
+        varval = var[:,ix]
+      percendone(ix,dx,5,'computed time statistics')
+
+      varst = statsVal(varval)
+      var2st = stats2Val(timesv, varval, powerv)
+      varstats[0,ix] = varst.minv
+      varstats[1,ix] = varst.maxv
+      varstats[2,ix] = varst.meanv
+      varstats[3,ix] = varst.mean2v
+      varstats[4,ix] = varst.stdv
+      varquant[:,ix] = varst.quantilesv
+      varlregress[:,ix] = var2st.linRegress
+      varpregress[:,ix] = var2st.polRegress
+      varpregressres[ix] = var2st.polRegressRes
+      varpregresssingval[:,ix] = var2st.polRegressSingVal
+  elif varshape == 3:
+    dy=vardims[1]
+    dx=vardims[2]
+    varstats = np.ones((5,dy, dx), dtype=np.float64)
+    varstats = varstats*varfil
+    varquant = np.ones((21,dy, dx), dtype=np.float64)
+    varquant = varquant*varfil
+    varlregress = np.ones((5,dy, dx), dtype=np.float64)
+    varlregress = varlregress*varfil
+    varpregress = np.ones((powerv+1,dy, dx), dtype=np.float64)
+    varpregress = varpregress*varfil
+    varpregressres = np.ones((dy,dx), dtype=np.float64)
+    varpregressres = varpregressres*varfil
+    varpregresssingval = varpregress.copy()
+    varpregresssingval = varpregresssingval*varfil
+    vardnames.append(vardimns[1])
+    vardnames.append(vardimns[2])
+    for iy in range(dy):
+      for ix in range(dx):
+        
+        if not varinf.FillValue is None:
+          varvl = var[:,iy,ix]
+          varval = np.where(varvl == varinf.FillValue, None, varvl)
+        else:
+          varval = var[:,iy,ix]
+      
+        percendone(iy*dx+ix,dy*dx,5,'computed time statistics')
+        varst = statsVal(varval)
+        var2st = stats2Val(timesv, varval, powerv)
+        varstats[0,iy,ix] = varst.minv
+        varstats[1,iy,ix] = varst.maxv
+        varstats[2,iy,ix] = varst.meanv
+        varstats[3,iy,ix] = varst.mean2v
+        varstats[4,iy,ix] = varst.stdv
+        varquant[:,iy,ix] = varst.quantilesv
+        varlregress[:,iy,ix] = var2st.linRegress
+        varpregress[:,iy,ix] = var2st.polRegress
+        varpregressres[iy,ix] = var2st.polRegressRes
+        varpregresssingval[:,iy,ix] = var2st.polRegressSingVal
+  elif varshape == 4:
+    dz=vardims[1]
+    dy=vardims[2]
+    dx=vardims[3]
+    varstats = np.ones((5, dz, dy, dx), dtype=np.float64)
+    varstats = varstats*varfil
+    varquant = np.ones((21, dz, dy, dx), dtype=np.float64)
+    varquant = varquant*varfil
+    varlregress = np.ones((5, dz, dy, dx), dtype=np.float64)
+    varlregress = varlregress*varfil
+    varpregress = np.ones((powerv+1, dz, dy, dx), dtype=np.float64)
+    varpregress = varpregress*varfil
+    varpregressres = np.ones((dz,dy,dx), dtype=np.float64)
+    varpregressres = varpregressres*varfil
+    varpregresssingval = varpregress.copy()
+    varpregresssingval = varpregresssingval*varfil
+    vardnames.append(vardimns[1])
+    vardnames.append(vardimns[2])
+    vardnames.append(vardimns[3])
+    for iz in range(dz):
+      for iy in range(dy):
+        for ix in range(dx):
+          if not varinf.FillValue is None:
+            varvl = var[:,iz,iy,ix]
+            varval = np.where(varvl == varinf.FillValue, None, varvl)
+          else:
+            varval = var[:,iz,iy,ix]
+      
+          percendone(iz*dy*dx+iy*dx+ix,dz*dx*dy,5,'computed time statistics')
+          varst = statsVal(varval)
+          var2st = stats2Val(timesv, varval, powerv)
+          varstats[0,iz,iy,ix] = varst.minv
+          varstats[1,iz,iy,ix] = varst.maxv
+          varstats[2,iz,iy,ix] = varst.meanv
+          varstats[3,iz,iy,ix] = varst.mean2v
+          varstats[4,iz,iy,ix] = varst.stdv
+          varquant[:,iz,iy,ix] = varst.quantilesv
+          varlregress[:,iz,iy,ix] = var2st.linRegress
+          varpregress[:,iz,iy,ix] = var2st.polRegress
+          varpregressres[iz,iy,ix] = var2st.polRegressRes
+          varpregresssingval[:,iz,iy,ix] = var2st.polRegressSingVal
+
+  elif varshape == 5:
+    dn=vardims[1]
+    dz=vardims[2]
+    dy=vardims[3]
+    dx=vardims[4]
+    varstats = np.ones((5, dn, dz, dy, dx), dtype=np.float64)
+    varstats = varstats*varfil
+    varquant = np.ones((21, dn, dz, dy, dx), dtype=np.float64)
+    varquant = varquant*varfil
+    varlregress = np.ones((5, dn, dz, dy, dx), dtype=np.float64)
+    varlregress = varlregress*varfil
+    varpregress = np.ones((powerv+1, dn, dz, dy, dx), dtype=np.float64)
+    varpregress = varpregress*varfil
+    varpregressres = np.ones((dn,dz,dy,dx), dtype=np.float64)
+    varpregressres = varpregressres*varfil
+    varpregresssingval = varpregress.copy()
+    varpregresssingval = varpregresssingval*varfil
+    vardnames.append(vardimns[1])
+    vardnames.append(vardimns[2])
+    vardnames.append(vardimns[3])
+    vardnames.append(vardimns[4])
+    for iN in range(dn):
+      for iz in range(dz):
+        for iy in range(dy):
+          for ix in range(dx):
+            if not varinf.FillValue is None:
+              varvl = var[:,iN,iz,iy,ix]
+              varval = np.where(varvl == varinf.FillValue, None, varvl)
+            else:
+              varval = var[:,iN,iz,iy,ix]
+      
+            percendone(iN*dy*dx*dz+iz*dy*dx+iy*dx+ix,dn*dz*dx*dy,5,'computed time statistics')
+            varst = statsVal(varval)
+            var2st = stats2Val(timesv, varval, powerv)
+            varstats[0,iN,iz,iy,ix] = varst.minv
+            varstats[1,iN,iz,iy,ix] = varst.maxv
+            varstats[2,iN,iz,iy,ix] = varst.meanv
+            varstats[3,iN,iz,iy,ix] = varst.mean2v
+            varstats[4,iN,iz,iy,ix] = varst.stdv
+            varquant[:,iN,iz,iy,iiN,x] = varst.quantilesv
+            varlregress[:,iN,iz,iy,ix] = var2st.linRegress
+            varpregress[:,iN,iz,iy,ix] = var2st.polRegress
+            varpregressres[iN,iz,iy,ix] = var2st.polRegressRes
+            varpregresssingval[:,iN,iz,iy,ix] = var2st.polRegressSingVal
+
+  else:
+     print errormsg
+     print '    timemean: ', varshape, ' shape of matrix not prepared !'
+     ncf.close()
+     quit(-1)
+
+  vardimnames = tuple(vardnames)
+#  print '  shape of desired values: ', vardesiredvalues.shape
+# Creation of file
+##
+
+  ncfo = NetCDFFile( ofile, 'w')
+
+  vartype = var.dtype
+  varattr = var.ncattrs()
+
+# Checking dimensions
+##
+  newdims = ncfo.dimensions
+  Nvardnames = len(vardimnames)
+  for idim in range(Nvardnames):
+      rdim = vardimnames[idim] 
+      if not searchInlist(newdims, rdim):
+          if not rdim == 'time':
+##              print '      timemean: Adding dimension ' + rdim
+              ncfo.sync()
+              ncf.close()
+              ncfo.close()
+              fdimadd(ncfile + ',' + rdim, ofile)
+              ncf = NetCDFFile(ncfile,'r')
+              ncfo = NetCDFFile(ofile,'a')
+          else:
+              print '      timemean: No time dimension!'
+
+# Checking fill value
+## 
+  if searchInlist(varattr, '_FillValue'):
+      varfil = var._FillValue
+  else:
+      varfil = False
+
+  Nstats = len(statsn)
+  for ist in range(Nstats):
+    newvardnames = []
+    if statsn[ist] == 'quant':
+      print ist, statsn[ist]##, ': ', varquant[int(dimt/2),10]
+      newdim = ncfo.createDimension('quant', 21)
+      newvardnames.append('quant')
+      newvardnames = newvardnames + list(vardnames)
+      newvar = ncfo.createVariable(varn + statsn[ist], vartype, tuple(newvardnames), fill_value=varfil)
+      newvar[:] = varquant
+    elif statsn[ist] == 'linregress':
+      print ist, statsn[ist]##, ': ', varquant[int(dimt/2),10]
+      newdim = ncfo.createDimension('lregress', 5)
+      newvar = ncfo.createVariable('lregressn', str, ('lregress',))
+      newvar[0] = 'slope'
+      newvar[1] = 'intercept'
+      newvar[2] = 'r_value'
+      newvar[3] = 'p_value'
+      newvar[4] = 'std_err'
+      newvardnames.append('lregress')
+      newvardnames = newvardnames + list(vardnames)
+      newvar = ncfo.createVariable(varn + statsn[ist], 'f4', tuple(newvardnames), fill_value=varfil)
+      newvar[:] = varlregress*1.
+
+    elif statsn[ist] == 'polregress':
+      print ist, statsn[ist]##, ': ', varquant[int(dimt/2),10]
+      newdim = ncfo.createDimension('pregress', powerv+1)
+      newvar = ncfo.createVariable('pregressn', str, ('pregress',))
+      for ip in range(powerv+1):
+        newvar[ip]='coefficient**' + str(powerv-ip)
+      newvardnames.append('pregress')
+      newvardnames = newvardnames + list(vardnames)
+      newvar = ncfo.createVariable(varn + statsn[ist], 'f4', tuple(newvardnames), fill_value=varfil)
+      newvar[:] = varpregress*1.
+      newvar.setncattr('power',powerv)
+      newvar.setncattr('values','Polynomial coefficients, highest power first')
+      newvar = ncfo.createVariable(varn + statsn[ist] + '_Residual', vartype, tuple(vardnames), fill_value=varfil)
+      newvar[:] = varpregressres
+      newvar.setncattr('power',powerv)
+      newvar.setncattr('values','Polynomial residuals')
+      newvar = ncfo.createVariable(varn + statsn[ist] + '_VandermondeSingularVector', vartype, tuple(newvardnames), fill_value=varfil)
+      newvar[:] = varpregresssingval
+      newvar.setncattr('power',powerv)
+      newvar.setncattr('values','Polynomial coefficients, highest power first')
+    else:
+      print ist, statsn[ist]##, ': ', varstats[int(dimt/2),ist]
+      if statsn[ist] == 'mean' or statsn[ist] == 'stdv' or statsn[ist] == 'mean2' or statsn[ist] == 'polregress_Residual' \
+        or statsn[ist] == 'polregress_VandermondeSingularVector' and searchInlist(varattr, 'scale_factor'):
+        newvar = ncfo.createVariable(varn + statsn[ist], 'f4', vardimnames, fill_value=varfil)
+        if varshape == 2:
+          newvar[:] = varstats[ist,:]*1.
+        elif varshape == 3:
+          newvar[:] = varstats[ist,:,:]*1.
+        elif varshape == 4:
+          newvar[:] = varstats[ist,:,:,:]*1.
+        elif varshape == 5:
+          newvar[:] = varstats[ist,:,:,:,:]*1.
+      else:
+        newvar = ncfo.createVariable(varn + statsn[ist], vartype, vardimnames, fill_value=varfil)
+        if varshape == 2:
+          newvar[:] = varstats[ist,:]
+        elif varshape == 3:
+          newvar[:] = varstats[ist,:,:]
+        elif varshape == 4:
+          newvar[:] = varstats[ist,:,:,:]
+        elif varshape == 5:
+          newvar[:] = varstats[ist,:,:,:,:]
+
+    newvar = ncfo.variables[varn + statsn[ist]]
+    for attr in varattr:
+         newvarattrs = newvar.ncattrs()
+         attrv = var.getncattr(attr)
+         if not searchInlist(newvarattrs, attr):
+              if attr == 'scale_factor' or attr == 'add_offset' or attr == 'valid_range' \
+                or attr == 'unpacked_valid_range' or attr == 'actual_range' :
+                  if not statsn[ist] == 'mean' and not statsn[ist] == 'stdv' and not statsn[ist] == 'mean2' and not \
+                    statsn[ist] == 'linregress' and not statsn[ist] == 'polregress' \
+                    and not statsn[ist] == 'polregress_Residual' and not \
+                    statsn[ist] == 'polregress_VandermondeSingularVector':
+                      newvar.setncattr(attr, attrv)
+              else:
+                  newvar.setncattr(attr, attrv)
+    
+    newvar.setncattr('cell_methods', 'time ' + statslongn[ist] + ' all period in file ' + str(dimt) + ' time steps')
+
+  ncfo.sync()
+  ncfo.close()
+
+  fvaradd(ncfile + ':lon', ofile)
+  fvaradd(ncfile + ':lat', ofile)
+
+  fgaddattr(ncfile, ofile)
+
+  print '    timemean: File "' + ofile + '" as time mean of "' + varn + '" has been created'
+
+def printing_class(classobj):
+    """ Function to print all the values of a given class
+    """
+
+    valscls = vars(classobj)
+    for attrcls in valscls:
+        print attrcls, ':', valscls[attrcls]
+
+def fmtprinting_class(classobj):
+    """ Function to print all the values of a given class
+    """
+
+    valscls = vars(classobj)
+    for attrcls in valscls:
+        print '@' + attrcls + '@', ':', valscls[attrcls]
+
+def flipdim(values, filename, varn):
+    """ flips the value following one dimension [Nflipdim]
+    values=[Nflipdim]:[flipdim]
+      [Nflipdim]: number of the dimension to flip
+      [flipdim]: has also the corresondant variable dimensinon be flipped? (yes/no)
+    filename= netCDF file name
+    varn= variable name
+    """
+    ncf = NetCDFFile(filename,'a')
+
+    Nflipdim=int(values.split(':')[0])
+    flipdim=values.split(':')[1]
+
+    if not ncf.variables.has_key(varn):
+        print errormsg
+        print '    flipdim: File  "' + filename + '" does not have variable ' + varn + ' !!!!'
+        print errormsg
+        ncf.close()
+        quit(-1)
+
+    varnc = ncf.variables[varn]
+    varinf = variable_inf(varnc)
+
+    if varinf.Ndims < Nflipdim:
+        print errormsg
+        print '    flipdim: variable "' + varn + '" has less dimensions ', varinf.Ndims, 'than the required to flip "', Nflipdim, '!!!!'
+        print errormsg
+        quit(-1)
+ 
+    if flipdim == 'yes':
+        flipdimname = varinf.dimns[Nflipdim]
+        print '  flipdim: Flipping also associated dimension variable "' + flipdimname + '"'
+
+        flipdim = ncf.variables[flipdimname]
+
+        if len(flipdim.shape) == 1:
+            newdim = flipdim[:]
+            flipdim[:] = newdim[::-1]
+        elif len(flipdim.shape) == 2:
+            if Nflipdim == varinf.Ndims:
+                for i in range(flipdim.shape[0]):
+                    newdim = flipdim[i,:]
+                    flipdim[i,:] = newdim[::-1]
+            if Nflipdim == varinf.Ndims - 1:
+                for i in range(flipdim.shape[1]):
+                    newdim = flipdim[:,i]
+                    flipdim[:,:] = newdim[::-1]
+        else:
+            print errormsg
+            print '    flipdim: dimension to flip has ', len(flipdim.shape), ' dimensions, not ready to be flipped !!!'
+            print errormsg
+            quit(-1) 
+
+    newvar = np.ones(varinf.dims, dtype=varinf.dtype)
+    if varinf.Ndims == 1:
+        newvar = varnc[:]
+        varnc[:] = newvar[::-1]
+    elif varinf.Ndims == 2:
+        if Nflipdim == 1:
+            for i in range(varinf.dims[0]):
+                newvar[i,:] = varnc[i,:]
+                varnc[i,:] = newvar[i,::-1]
+        elif Nflipdim == 0:
+            for i in range(varinf.dims[1]):
+                newvar[:,i] = varnc[:,i]
+                varnc[:,i] = newvar[::-1,i]
+    elif varinf.Ndims == 3:
+        if Nflipdim == 2:
+            for i in range(varinf.dims[0]):
+                for j in range(varinf.dims[1]):
+                    newvar[i,j,:] = varnc[i,j,:]
+                    varnc[i,j,:] = newvar[i,j,::-1]
+        elif Nflipdim == 1:
+            for i in range(varinf.dims[0]):
+                for j in range(varinf.dims[2]):
+                    newvar[i,:,j] = varnc[i,:,j]
+                    varnc[i,:,j] = newvar[i,::-1,j]
+        elif Nflipdim == 0:
+            for i in range(varinf.dims[1]):
+                for j in range(varinf.dims[2]):
+                    newvar[:,i,j] = varnc[:,i,j]
+                    varnc[:,i,j] = newvar[::-1,i,j]
+    elif varinf.Ndims == 4:
+        if Nflipdim == 3:
+            for i in range(varinf.dims[0]):
+                for j in range(varinf.dims[1]):
+                    for k in range(varinf.dims[2]):
+                        newvar[i,j,k,:] = varnc[i,j,k,:]
+                        varnc[i,j,k,:] = newvar[i,j,k,::-1]
+        if Nflipdim == 2:
+            for i in range(varinf.dims[0]):
+                for j in range(varinf.dims[1]):
+                    for k in range(varinf.dims[3]):
+                        newvar[i,j,:,k] = varnc[i,j,:,k]
+                        varnc[i,j,:,k] = newvar[i,j,::-1,k]
+        if Nflipdim == 1:
+            for i in range(varinf.dims[0]):
+                for j in range(varinf.dims[2]):
+                    for k in range(varinf.dims[3]):
+                        newvar[i,:,j,k] = varnc[i,:,j,k]
+                        varnc[i,:,j,k] = newvar[i,::-1,j,k]
+        if Nflipdim == 0:
+            for i in range(varinf.dims[1]):
+                for j in range(varinf.dims[2]):
+                    for k in range(varinf.dims[3]):
+                        newvar[:,i,j,k] = varnc[:,i,j,k]
+                        varnc[:,i,j,k] = newvar[::-1,i,j,k]
+    elif varinf.Ndims == 5:
+        if Nflipdim == 4:
+            for i in range(varinf.dims[0]):
+                for j in range(varinf.dims[1]):
+                    for k in range(varinf.dims[2]):
+                        for l in range(varinf.dims[3]):
+                            newvar[i,j,k,l,:] = varnc[i,j,k,l,:]
+                            varnc[i,j,k,l,:] = newvar[i,j,k,l,::-1]
+        if Nflipdim == 3:
+            for i in range(varinf.dims[0]):
+                for j in range(varinf.dims[1]):
+                    for k in range(varinf.dims[2]):
+                        for l in range(varinf.dims[4]):
+                            newvar[i,j,k,:,l] = varnc[i,j,k,:,l]
+                            var[i,j,k,:,l] = newvar[i,j,k,::-1,l]
+        if Nflipdim == 2:
+            for i in range(varinf.dims[0]):
+                for j in range(varinf.dims[1]):
+                    for k in range(varinf.dims[3]):
+                        for l in range(varinf.dims[4]):
+                            newvar[i,j,:,k,l] = varnc[i,j,:,k,l]
+                            varnc[i,j,:,k,l] = newvar[i,j,::-1,k,l]
+        if Nflipdim == 1:
+            for i in range(varinf.dims[0]):
+                for j in range(varinf.dims[2]):
+                    for k in range(varinf.dims[3]):
+                        for l in range(varinf.dims[4]):
+                            newvar[i,:,j,k,l] = varnc[i,:,j,k,l]
+                            varnc[i,:,j,k,l] = newvar[i,::-1,j,k,l]
+        if Nflipdim == 0:
+            for i in range(varinf.dims[1]):
+                for j in range(varinf.dims[2]):
+                    for k in range(varinf.dims[3]):
+                        for l in range(varinf.dims[4]):
+                            newvar[:,i,j,k,l] = varnc[:,i,j,k,l]
+                            varnc[:,i,j,k,l] = newvar[::-1,i,j,k,l]
+    else:
+        print errormsg
+        print '    flipdim: Number of dimensions ', varinf.Ndims, ' not ready!!!!'
+        print errormsg
+        quit(-1)
+
+    ncf.sync()
+    ncf.close()
+
+def cycl_incr(cyclval,cycle,ninc):
+    """ Function to increment a cyclic value [cyclval] with a cycle [cycle] a given number [ninc] of times
+    >>> cycl_incr(1,4,1)
+    2
+    >>> cycl_incr(3,4,1)
+    0
+    >>> cycl_incr(1,4,10)
+    3
+    """
+
+    if ninc >= cycle:
+        print 'cycl_incr: WARNING -- warning -- WARNING -- warning'
+        print '    given increment: ', ninc,' is larger than the cycle !!'
+        ninc = ninc - cycle*int(ninc/cycle)
+        print '    reducing it to: ', ninc
+
+    val=cyclval + ninc
+    if val >= cycle:
+        val=cyclval + ninc - cycle
+
+    return val
+
+def times_4seasons(tvals, integrity):
+    """ Function to split a time series in matricial date format ([:,year,mon,day,hour,minute,second]) in the four stations DJF,MAM,JJA,SON
+    tvals= matrix withe times as [:,year,mon,day,hour,minute,second]
+    integrity= only give values for entire seasons [True, 3 months for the season], or just split the values by seasons [False] 
+    """
+    fillVal=1.e20
+
+#    print tvals
+
+    dt=tvals.shape[0]
+    seasons=np.ones((dt,4),dtype=bool)
+    seasons=seasons*False
+
+    monseas=[12,3,6,9]
+    firstseas=False
+
+    for it in range(dt):
+        if not firstseas:
+            if integrity:
+                for iseas in range(4):
+                    if tvals[it,1] == monseas[iseas]:
+                        nseas=iseas
+                        seasons[it,nseas]=True
+                        firstseas=True
+                        begseas=it
+            else:
+                for iseas in range(4):
+                    for imon in range(3):
+                        if tvals[it,1] == cycl_incr(monseas[iseas],12,imon):
+                            nseas=iseas
+                            seasons[it,nseas]=True
+                            firstseas=True                    
+        else:
+            newseas=cycl_incr(nseas,4,1)
+            if tvals[it,1] == monseas[newseas]:
+                seasons[it,newseas] = True
+                nseas=newseas
+                begseas=it
+            else:
+                seasons[it,nseas] = True
+
+    endseas = it
+##    print 'Last season: ',nseas,' beginnig: ',begseas,' ending: ',endseas
+
+# Checking integrity of last season (has to have 3 months)
+##
+    if integrity:
+        fullseas=True
+        Nmon=np.unique(tvals[begseas:endseas+1,1])
+        for it in range(begseas,endseas): fullseas=fullseas*seasons[it,nseas]
+        if len(Nmon) < 3 or not fullseas:
+            seasons[begseas:endseas+1,nseas] = False
+
+    return seasons
+
+def realdatetime_CFcompilant(times, Srefdate, tunits):
+    """ Function to transform a matrix with real time values ([year, month, day, hour, minute, second]) to a netCDF one
+    times= matrix with times
+    Srefdate= reference date ([YYYY][MM][DD][HH][MI][SS] format)
+    tunits= units of time respect to Srefdate
+    >>> realdatetime_CFcompilant(np.array([ [1976, 2, 17, 8, 20, 0], [1976, 2, 18, 8, 20, 0]], dtype=int), '19491201000000', 'hours')
+    [ 229784.33333333  229808.33333333]
+    """ 
+
+    import datetime as dt
+    yrref=int(Srefdate[0:4])
+    monref=int(Srefdate[4:6])
+    dayref=int(Srefdate[6:8])
+    horref=int(Srefdate[8:10])
+    minref=int(Srefdate[10:12])
+    secref=int(Srefdate[12:14])
+ 
+    refdate=dt.datetime(yrref, monref, dayref, horref, minref, secref)
+
+    dimt=times.shape[0]
+        
+    cfdates = np.zeros((dimt), dtype=np.float64)
+    if tunits == 'weeks':
+        for it in range(dimt):
+            cfdate = dt.datetime(times[it,0], times[it,1], times[it,2], times[it,3], times[it,4], times[it,5]) - refdate
+            cfdates[it] = (cfdate.days + cfdate.seconds/(3600.*24.))/7.
+    elif tunits == 'days':
+        for it in range(dimt):
+            cfdate = dt.datetime(times[it,0], times[it,1], times[it,2], times[it,3], times[it,4], times[it,5]) - refdate
+            cfdates[it] = cfdate.days + cfdate.seconds/(3600.*24.)
+    elif tunits == 'hours':
+        for it in range(dimt):
+            cfdate = dt.datetime(times[it,0], times[it,1], times[it,2], times[it,3], times[it,4], times[it,5]) - refdate
+            cfdates[it] = cfdate.days*24. + cfdate.seconds/3600.
+    elif tunits == 'minutes':
+        for it in range(dimt):
+            cfdate = dt.datetime(times[it,0], times[it,1], times[it,2], times[it,3], times[it,4], times[it,5]) - refdate
+            cfdates[it] = cfdate.days*24.*60. + cfdate.seconds/60.
+    elif tunits == 'seconds':
+        for it in range(dimt):
+            cfdate = dt.datetime(times[it,0], times[it,1], times[it,2], times[it,3], times[it,4], times[it,5]) - refdate
+            cfdates[it] = cfdate.days*24.*3600. + cfdate.seconds
+    elif tunits == 'milliseconds':
+        for it in range(dimt):
+            cfdate = dt.datetime(times[it,0], times[it,1], times[it,2], times[it,3], times[it,4], times[it,5]) - refdate
+            cfdates[it] = cfdate.days*1000.*24.*3600. + cfdate.seconds*1000.
+    elif tunits == 'microseconds':
+        for it in range(dimt):
+            cfdate = dt.datetime(times[it,0], times[it,1], times[it,2], times[it,3], times[it,4], times[it,5]) - refdate
+            cfdates[it] = cfdate.days*1000000.*24.*3600. + cfdate.seconds*1000000.
+    else:
+        print errormsg
+        print '  ' + fname + ': time units "' + tunits + '" is not ready!!!'
+        quit(-1)
+
+    return cfdates
+
+def realdatetime1_CFcompilant(time, Srefdate, tunits):
+    """ Function to transform a matrix with a real time value ([year, month, day, 
+      hour, minute, second]) to a netCDF one
+        time= matrix with time
+        Srefdate= reference date ([YYYY][MM][DD][HH][MI][SS] format)
+        tunits= units of time respect to Srefdate
+    >>> realdatetime1_CFcompilant([1976, 2, 17, 8, 20, 0], '19491201000000', 'hours')
+    229784.33333333
+    """ 
+
+    import datetime as dt
+    yrref=int(Srefdate[0:4])
+    monref=int(Srefdate[4:6])
+    dayref=int(Srefdate[6:8])
+    horref=int(Srefdate[8:10])
+    minref=int(Srefdate[10:12])
+    secref=int(Srefdate[12:14])
+ 
+    refdate=dt.datetime(yrref, monref, dayref, horref, minref, secref)
+
+    if tunits == 'weeks':
+        cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5])-refdate
+        cfdates = (cfdate.days + cfdate.seconds/(3600.*24.))/7.
+    elif tunits == 'days':
+        cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5]) - refdate
+        cfdates = cfdate.days + cfdate.seconds/(3600.*24.)
+    elif tunits == 'hours':
+        cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5]) - refdate
+        cfdates = cfdate.days*24. + cfdate.seconds/3600.
+    elif tunits == 'minutes':
+        cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5]) - refdate
+        cfdates = cfdate.days*24.*60. + cfdate.seconds/60.
+    elif tunits == 'seconds':
+        cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5]) - refdate
+        cfdates = cfdate.days*24.*3600. + cfdate.seconds
+    elif tunits == 'milliseconds':
+        cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],time[5]) - refdate
+        cfdates = cfdate.days*1000.*24.*3600. + cfdate.seconds*1000.
+    elif tunits == 'microseconds':
+        cfdate = dt.datetime(time[0],time[1],time[2],time[3],time[4],times[5]) - refdate
+        cfdates = cfdate.days*1000000.*24.*3600. + cfdate.seconds*1000000.
+    else:
+        print errormsg
+        print '  ' + fname + ': time units "' + tunits + '" is not ready!!!'
+        quit(-1)
+
+    return cfdates
+
+def netCDFdatetime_realdatetime(units, tcalendar, times):
+    """ Function to transfrom from netCDF CF-compilant times to real time
+    [units]= CF time units [tunits] since [YYYY]-[MM]-[HH] [[HH]:[MI]:[SS]]
+    [tcalendar]= time calendar
+    [times]= CF time values
+    """
+    import datetime as dt
+
+    txtunits = units.split(' ')
+    tunits = txtunits[0]
+    Srefdate = txtunits[len(txtunits) - 1]
+
+# Calendar type
+##
+    is360 = False
+    if tcalendar is not None:
+      print '  netCDFdatetime_realdatetime: There is a calendar attribute'
+      if tcalendar == '365_day' or tcalendar == 'noleap':
+          print '    netCDFdatetime_realdatetime: No leap years!'
+          isleapcal = False
+      elif tcalendar == 'proleptic_gregorian' or tcalendar == 'standard' or tcalendar == 'gregorian':
+          isleapcal = True
+      elif tcalendar == '360_day':
+          is360 = True
+          isleapcal = False
+      else:
+          print errormsg
+          print '    netCDFdatetime_realdatetime: Calendar "' + tcalendar + '" not prepared!'
+          quit(-1)
+
+# Does reference date contain a time value [YYYY]-[MM]-[DD] [HH]:[MI]:[SS]
+##
+    timeval = Srefdate.find(':')
+
+    if not timeval == -1:
+        print '  netCDFdatetime_realdatetime: refdate with time!'
+        refdate = datetimeStr_datetime(txtunits[len(txtunits) - 2] + '_' + Srefdate)
+    else:
+        refdate = dateStr_date(Srefdate)
+
+    dimt = len(times)
+#    datetype = type(dt.datetime(1972,02,01))
+#    realdates = np.array(dimt, datetype)
+#    print realdates
+
+## Not in timedelta
+#  if tunits == 'years':
+#    for it in range(dimt):
+#      realdate = refdate + dt.timedelta(years=float(times[it]))
+#      realdates[it] = int(realdate.year)
+#  elif tunits == 'months':
+#    for it in range(dimt):
+#      realdate = refdate + dt.timedelta(months=float(times[it]))
+#      realdates[it] = int(realdate.year)
+#    realdates = []
+    realdates = np.zeros((dimt, 6), dtype=int)
+    if tunits == 'weeks':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(weeks=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'days':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(days=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'hours':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(hours=float(times[it]))
+#            if not isleapcal:
+#                Nleapdays = cal.leapdays(int(refdate.year), int(realdate.year))
+#                realdate = realdate - dt.timedelta(days=Nleapdays)
+#            if is360:
+#                Nyears360 = int(realdate.year) - int(refdate.year) + 1
+#                realdate = realdate -dt.timedelta(days=Nyears360*5)
+#            realdates[it] = realdate
+#        realdates = refdate + dt.timedelta(hours=float(times))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'minutes':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(minutes=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'seconds':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(seconds=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'milliseconds':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(milliseconds=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    elif tunits == 'microseconds':
+        for it in range(dimt):
+            realdate = refdate + dt.timedelta(microseconds=float(times[it]))
+            realdates[it,:]=[realdate.year, realdate.month, realdate.day, realdate.hour, realdate.minute, realdate.second]
+    else:
+        print errormsg
+        print '  netCDFdatetime_realdatetime: time units "' + tunits + '" is not ready!!!'
+        quit(-1)
+
+    return realdates
+
+class cls_yearly_means(object):
+    """ Class to compute the yearly mean of a time series of values
+      tvals=time values (year, month, day, hour, minute, second) format
+      values=time-series of values
+      dateref= reference date [YYYY][MM][DD][HH][MI][SS] format
+      tunits= time units
+      self.dimt = Number of values
+      self.yrv = yearly mean values
+      self.yrt = years of the mean values
+    >>> timesv = netCDFdatetime_realdatetime('days since 1949-12-01 00:00:00', 'standard', np.arange(1129))
+    >>> valuesv = np.zeros((1129), dtype=np.float)
+    >>> valuesv[0:31] = 0.
+    >>> valuesv[31:394] = 1.
+    >>> valuesv[395:761] = 2.
+    >>> valuesv[761:1127] = 3.
+    >>> valuesv[1127:1129] = 4.
+
+    >>> yrlmeans = cls_yearly_means(timesv, valuesv, '19491201000000', 'days')
+    >>> print yrlmeans.dimt,yrlmeans.yrv, yrlmeans.yrt 
+    5 [ 0.  1.  2.  3.  4.] [ 1949.  1950.  1951.  1952.  1953.]
+    """
+    def __init__(self, tvals, values, dateref, tunits):
+
+        import numpy.ma as ma
+        fillVal=1.e20
+        fname = 'cls_yearly_means'
+
+        if tvals is None:
+            self.dimt = None
+            self.yrv = None
+            self.yrt = None
+
+        elif tvals == 'h':
+            print fname + '_____________________________________________________________'
+            print cls_yearly_means.__doc__
+            quit()
+
+        else:
+            dt=len(values)
+            if dt > 0:
+                years = np.unique(tvals[:,0])
+                Nyrs = len(years)
+                yrmean = np.zeros((Nyrs), dtype=np.float)
+                yrt = np.zeros((Nyrs), dtype=np.float)
+
+                iiyr = tvals[0,0]
+                yrmean[0] = values[0]
+                yrt[0] = iiyr
+                iit = 0
+                for iyr in range(Nyrs):
+                    nvals = 1
+                    for it in range(iit+1,dt):
+#                        print iyr, iiyr, it, tvals[it,0],':',values[it],'->',yrmean[iyr]
+                        if tvals[it,0] == iiyr:
+                            yrmean[iyr] = yrmean[iyr] + values[it]
+                            nvals = nvals + 1
+                        else:
+                            yrmean[iyr] = yrmean[iyr] / (nvals*1.)
+                            iiyr = tvals[it,0]
+                            yrmean[iyr + 1] = values[it]
+                            yrt[iyr+1] = iiyr
+                            iit = it
+                            break
+
+                yrmean[Nyrs-1] = yrmean[Nyrs-1]/nvals
+                self.dimt = Nyrs
+                self.yrv = yrmean
+                self.yrt = yrt
+            else:
+                print errormsg
+                print '  ' + fname + ': No values passed!'
+                print '    values:', values
+                quit(-1)
+
+
+class cls_seasonal_means(object):
+    """ Class to compute the seasonal mean of a time series of values
+    tvals=time values (year, month, day, hour, minute, second) format
+    values=time-series of values
+    dateref= reference date [YYYY][MM][DD][HH][MI][SS] format
+    tunits= time units
+    self.dimt = Number of values
+    self.seasv = seasonal mean values
+    self.seast = seasonal time mean values
+    """
+    def __init__(self, tvals, values, dateref, tunits):
+
+        import numpy.ma as ma
+        fillVal=1.e20
+        fname = 'cls_seasonal_means'
+
+        if tvals is None:
+            self.dimt = None
+            self.seasv = None
+            self.seast = None
+
+        else:
+            tseasons=times_4seasons(tvals, True)
+
+            dt=len(values)
+            seasvals=np.ones((dt/12,4), dtype=np.float64)*fillVal
+            seastimes=np.zeros((dt/12,4), dtype=np.float64)
+            dates = realdatetime_CFcompilant(tvals, dateref, tunits)
+
+            for iseas in range(4):
+                for it in range(dt):
+                    if tseasons[it,iseas]:
+                        tfirstseas=int(it/11)
+                        firstseas=True
+##                        print '  first time-step of season ', iseas, ' is: ',it,' position: ',tfirstseas
+                        break
+                for itt in range(it, dt-1,12):
+                    seasvals[int(itt/12),iseas]=(values[itt] + values[itt+1] + values[itt+2])/3.
+                    seastimes[int(itt/12),iseas]=dates[itt] + (dates[itt+2] - dates[itt])/2.
+##                    print itt, values[itt], values[itt+1], values[itt+2], '--->', seasvals[int(itt/12),iseas]
+
+            self.dimt = dt/12
+            self.seasv = ma.masked_equal(seasvals, fillVal)
+            self.seast = ma.masked_equal(seastimes, fillVal)
+
+class cls_seasonal_accums(object):
+    """ Class to compute the seasonal accumulations of a time series of values
+    tvals=time values (year, month, day, hour, minute, second) format
+    values=time-series of values
+    dateref= reference date [YYYY][MM][DD][HH][MI][SS] format
+    tunits= time units
+    self.dimt = Number of values
+    self.seasv = seasonal mean values
+    self.seast = seasonal time mean values
+    """
+    def __init__(self, tvals, values, dateref, tunits):
+        import numpy.ma as ma
+        fillVal=1.e20
+
+        if tvals is None:
+            self.dimt = None
+            self.seasv = None
+            self.seast = None
+
+        else:
+            tseasons=times_4seasons(tvals, True)
+
+            dt=len(values)
+            seasvals=np.ones((dt/12,4), dtype=np.float64)*fillVal
+            seastimes=np.zeros((dt/12,4), dtype=np.float64)
+            dates = realdatetime_CFcompilant(tvals, dateref, tunits)
+
+            for iseas in range(4):
+                for it in range(dt):
+                    if tseasons[it,iseas]:
+                        tfirstseas=int(it/11)
+                        firstseas=True
+#                        print '  first time-step of season ', iseas, ' is: ',it,' position: ',tfirstseas
+                        break
+                for itt in range(it, dt-1,12):
+                    seasvals[int(itt/12),iseas]=values[itt] + values[itt+1] + values[itt+2]
+                    seastimes[int(itt/12),iseas]=dates[itt] + (dates[itt+2] - dates[itt])/2.
+
+            self.dimt = dt/12
+            self.seasv = ma.masked_equal(seasvals, fillVal)
+            self.seast = ma.masked_equal(seastimes, fillVal)
+
+def seasonal_means(tvals, values):
+    """ Function to compute the seasonal mean of a time series of values
+    tvals=time values (year, month, day, hour, minute, second) format
+    values=time-series of values
+    """
+    fillVal=1.e20
+
+    tseasons=times_4seasons(tvals, True)
+
+    dt=len(values)
+    seasvals=np.ones((dt/4,4), dtype=np.float64)
+    seasvals=seasvals*fillVal
+
+    for iseas in range(4):
+        for it in range(dt):
+            if tseasons[it,iseas]:
+                tfirstseas=int(it/11)
+                firstseas=True
+#                print '  first time-step of season ', iseas, ' is: ',it,' position: ',tfirstseas
+                break
+        for itt in range(it, dt-1,12):
+            seasvals[int(itt/12),iseas]=(values[itt] + values[itt+1] + values[itt+2])/3.
+
+    return seasvals
+
+def seasonal_accum(tvals, values):
+    """ Function to compute the seasonal accumulation of a time series of values
+    tvals=time values (year, month, day, hour, minute, second) format
+    values=time-series of values
+    """
+    fillVal=1.e20
+
+    tseasons=times_4seasons(tvals, True)
+
+    dt=len(values)
+    seasvals=np.ones((dt/4,4), dtype=np.float64)
+    seasvals=seasvals*fillVal
+
+    for iseas in range(4):
+        for it in range(dt):
+            if tseasons[it,iseas]:
+                tfirstseas=int(it/11)
+                firstseas=True
+#                print '  first time-step of season ', iseas, ' is: ',it,' position: ',tfirstseas
+                break
+        for itt in range(it, dt-1,12):
+            seasvals[int(itt/11),iseas]=values[itt] + values[itt+1] + values[itt+2]
+
+    return seasvals
+
+def seasmean(timename, filename, varn):
+    """ Function to compute the seasonal mean of a variable
+    timename= name of the variable time in the file
+    filename= netCDF file name
+    varn= name of the variable
+    """
+    fillValue=1.e20
+
+    ncf = NetCDFFile(filename,'a')
+    ofile = 'seasmean_' + varn + '.nc'
+
+    if not ncf.variables.has_key(varn):
+        print errormsg
+        print '    seasmean: File  "' + filename + '" does not have variable ' + varn + ' !!!!'
+        print errormsg
+        ncf.close()
+        quit(-1)
+
+    varobj = ncf.variables[varn]
+    varinf = variable_inf(varobj)
+    timeobj = ncf.variables[timename]
+    timeinf = cls_time_information(ncf, timename)
+
+    timevals=timeobj[:]
+    netcdftimes = netCDFdatetime_realdatetime(timeinf.units + ' since ' + timeinf.Urefdate, timeinf.calendar, timevals)
+    
+    timeseasons=times_4seasons(netcdftimes, True)
+
+    timeseasvals=seasonal_means(netcdftimes, timevals)
+    
+    ncfnew = NetCDFFile(ofile,'w')
+    ncfnew.createDimension('seastime', timeinf.dimt/4)
+    ncfnew.createDimension('seas', 4)
+
+    newvarobj = ncfnew.createVariable('seastime', 'f4', ('seastime', 'seas',), fill_value=fillValue)
+    newvarobj[:]=timeseasvals
+    attr = newvarobj.setncattr('calendar', timeinf.calendar)
+    attr = newvarobj.setncattr('units', timeinf.units)
+
+    newvarobj = ncfnew.createVariable('seasn', str, ('seas'))
+    attr = newvarobj.setncattr('standard_name', 'seasn')
+    attr = newvarobj.setncattr('long_name', 'name of the season')
+    attr = newvarobj.setncattr('units', '3-months')
+    newvarobj[0]='DJF'
+    newvarobj[1]='MAM'
+    newvarobj[2]='JJA'
+    newvarobj[3]='SON'
+
+    newdims=[]
+    idim = 0
+
+    for ndim in varinf.dimns:
+        if ndim == timename:
+            newdims.append(unicode('seastime'))
+            if not idim == 0:
+                print errormsg
+                print '  seasmean: File  "' + filename + '" does not have time dimension "' + timename + '" as the first one. It has it as # ', idim, ' !!!!'
+                print errormsg
+                ncf.close()
+                quit(-1)
+        else:
+            newdims.append(ndim)
+
+        if not ncfnew.dimensions.has_key(ndim):
+            ncfnew.sync()
+            ncfnew.close()
+            ncf.close()            
+
+            fdimadd(filename + ',' + ndim, ofile)
+            ncf = NetCDFFile(filename,'r')
+            ncfnew = NetCDFFile(ofile,'a')
+
+    print ncfnew.dimensions
+    namedims=tuple(newdims)
+    print namedims
+
+    varobj = ncf.variables[varn]
+    varinf = variable_inf(varobj)
+
+    newvarobj=ncfnew.createVariable(varn + '_seasmean', 'f4', namedims, fill_value=fillValue)
+    attr = newvarobj.setncattr('standard_name', varn + '_seasmean')
+    attr = newvarobj.setncattr('long_name', 'seasonal mean of ' + varn)
+    attr = newvarobj.setncattr('units', varinf.units)
+
+    newvar = np.ones(varinf.dims[0], dtype=varinf.dtype)
+    if varinf.Ndims == 1:
+        newvar = newvarobj[:]
+        newvarobj[:] = seasonal_means(netcdftimes, newvar)
+    if varinf.Ndims == 2:
+        for i in range(varinf.dims[1]):
+            newvar = newvarobj[:,i]
+            newvarobj[:,i] = seasonal_means(netcdftimes, newvar)
+    if varinf.Ndims == 3:
+        for i in range(varinf.dims[1]):
+            for j in range(varinf.dims[2]):
+                newvar = newvarobj[:,i,j]
+                newvarobj[:,i,j] = seasonal_means(netcdftimes, newvar)
+    if varinf.Ndims == 4:
+        for i in range(varinf.dims[1]):
+            for j in range(varinf.dims[2]):
+                for k in range(varinf.dims[3]):
+                    newvar = newvarobj[:,i,j,k]
+                    newvarobj[:,i,j,k] = seasonal_means(netcdftimes, newvar)
+    if varinf.Ndims == 5:
+        for i in range(varinf.dims[1]):
+            for j in range(varinf.dims[2]):
+                for k in range(varinf.dims[3]):
+                    for l in range(varinf.dims[4]):
+                        newvar = newvarobj[:,i,j,k,l]
+                        newvarobj[:,i,j,k,l] = seasonal_means(netcdftimes, newvar)
+    if varinf.Ndims == 6:
+        for i in range(varinf.dims[1]):
+            for j in range(varinf.dims[2]):
+                for k in range(varinf.dims[3]):
+                    for l in range(varinf.dims[4]):
+                        for m in range(varinf.dims[5]):
+                            newvar = newvarobj[:,i,j,k,l,m]
+                            newvarobj[:,i,j,k,l,m] = seasonal_means(netcdftimes, newvar)
+    else:
+        print errormsg
+        print '  seasmean: number of dimensions ', varinf.Ndims, ' not ready !!!!'
+        print errormsg
+        ncf.close()
+        quit(-1)
+
+    ncfnew.sync()
+    ncfnew.close()
+
+    print 'seasmean: Seasonal mean file "' + ofile + '" written!'
+
+def load_variable_lastdims(var, prevdims, Nlastdims):
+    """ Function to load the last [Nlastdims] dimensions of a variable [var] at the other dimensions at [prevdims]
+    >>> load_variable_lastdims(np.array(range(5*5*5)).reshape(5,5,5), [1,2], 1)
+    [35 36 37 38 39]
+    """
+    fname='load_variable_lastdims'
+
+    dims=var.shape
+    Ndims=len(dims)
+
+    Nprevdims = len(prevdims)
+    if not Nprevdims + Nlastdims == Ndims:
+        print erromsg
+        print '  ' + fname + ': number of dimensions previous (',Nprevdim,') and last (',Nlastdims, ') does not match with variable size: ',Ndims,' !!!!'
+        print errormsg
+        quit(-1)
+
+    if Nlastdims > Ndims-1:
+        print errormsg
+        print '  ' + fname + ': number of last dimensions ', Nlastdims,' >= than the number of dimensions of the variable ', Ndims,' !!!!'
+        print errormsg
+        quit(-1)
+
+    if Ndims == 1:
+        loadvar = var[:]
+    elif Ndims == 2:
+        loadvar = var[prevdims[0], :]
+    elif Ndims == 3:
+        if Nlastdims == 1:
+            loadvar = var[prevdims[0], prevdims[1], :]
+        else:
+            loadvar = var[prevdims[0], :, :]
+    elif Ndims == 4:
+        if Nlastdims == 1:
+            loadvar = var[prevdims[0], prevdims[1], prevdims[2], :]
+        elif Nlastdims == 2:
+            loadvar = var[prevdims[0], prevdims[1], :, :]
+        else:
+            loadvar = var[prevdims[0], :, :, :]
+    elif Ndims == 5:
+        if Nlastdims == 1:
+            loadvar = var[prevdims[0], prevdims[1], prevdims[2], prevdims[3], :]
+        elif Nlastdims == 2:
+            loadvar = var[prevdims[0], prevdims[1], prevdims[2], :, :]
+        elif Nlastdims == 3:
+            loadvar = var[prevdims[0], prevdims[1], :, :, :]
+        else:
+            loadvar = var[prevdims[0], :, :, :, :]
+    elif Ndims == 6:
+        if Nlastdims == 1:
+            loadvar = var[prevdims[0], prevdims[1], prevdims[2], prevdims[3], prevdims[4], :]
+        elif Nlastdims == 2:
+            loadvar = var[prevdims[0], prevdims[1], prevdims[2], prevdims[3], :, :]
+        elif Nlastdims == 3:
+            loadvar = var[prevdims[0], prevdims[1], prevdims[2], :, :, :]
+        elif Nlastdims == 4:
+            loadvar = var[prevdims[0], prevdims[1], :, :, :, :]
+        else:
+            loadvar = var[prevdims[0], :, :, :, :]
+    else:
+        print errormsg
+        print '  ' + fname + ' variable size ', Ndims, ' not ready!!!'
+        print errormsg
+        quit(-1)
+
+    return loadvar
+
+def load_ncvariable_lastdims(ncf, varn, prevdims, Nlastdims):
+    """ Function to load the last [Nlastdims] dimensions of a variable [varn] from a netCDF object at the other dimensions at [prevdims]
+    ncf= netCDF object
+    varn= variable name
+    prevdims= values at the previous dimensions
+    Nlastims= number of last dimensions
+    """
+    fname='load_ncvariable_lastdims'
+
+    var=ncf.variables[varn]
+
+    dims=var.shape
+    Ndims=len(dims)
+
+    Nprevdims = len(prevdims)
+    if not Nprevdims + Nlastdims == Ndims:
+        print erromsg
+        print '  ' + fname + ': number of dimensions previous (',Nprevdim,') and last (',Nlastdims, ') does not match with variable size: ',Ndims,' !!!!'
+        print errormsg
+        quit(-1)
+
+    if Nlastdims > Ndims-1:
+        print errormsg
+        print '  ' + fname + ': number of last dimensions ', Nlastdims,' >= than the number of dimensions of the variable ', Ndims,' !!!!'
+        print errormsg
+        quit(-1)
+
+    if Ndims == 1:
+        loadvar = var[:]
+    elif Ndims == 2:
+        loadvar = var[prevdims[0], :]
+    elif Ndims == 3:
+        if Nlastdims == 1:
+            loadvar = var[prevdims[0], prevdims[1], :]
+        else:
+            loadvar = var[prevdims[0], :, :]
+    elif Ndims == 4:
+        if Nlastdims == 1:
+            loadvar = var[prevdims[0], prevdims[1], prevdims[2], :]
+        elif Nlastdims == 2:
+            loadvar = var[prevdims[0], prevdims[1], :, :]
+        else:
+            loadvar = var[prevdims[0], :, :, :]
+    elif Ndims == 5:
+        if Nlastdims == 1:
+            loadvar = var[prevdims[0], prevdims[1], prevdims[2], prevdims[3], :]
+        elif Nlastdims == 2:
+            loadvar = var[prevdims[0], prevdims[1], prevdims[2], :, :]
+        elif Nlastdims == 3:
+            loadvar = var[prevdims[0], prevdims[1], :, :, :]
+        else:
+            loadvar = var[prevdims[0], :, :, :, :]
+    elif Ndims == 6:
+        if Nlastdims == 1:
+            loadvar = var[prevdims[0], prevdims[1], prevdims[2], prevdims[3], prevdims[4], :]
+        elif Nlastdims == 2:
+            loadvar = var[prevdims[0], prevdims[1], prevdims[2], prevdims[3], :, :]
+        elif Nlastdims == 3:
+            loadvar = var[prevdims[0], prevdims[1], prevdims[2], :, :, :]
+        elif Nlastdims == 4:
+            loadvar = var[prevdims[0], prevdims[1], :, :, :, :]
+        else:
+            loadvar = var[prevdims[0], :, :, :, :]
+    else:
+        print errormsg
+        print '  ' + fname + ' variable size ', Ndims, ' not ready!!!'
+        print errormsg
+        quit(-1)
+
+    return loadvar
+
+def fill_ncvariable_lastdims(ncf, varn, prevdims, Nlastdims, fillvals):
+    """ Function to fill the last [Nlastdims] dimensions of a variable [varn] from a netCDF object at the other dimensions at [prevdims]
+      with as given set of [fillvals] values
+    ncf= netCDF object
+    varn= variable name
+    prevdims= values at the previous dimensions
+    Nlastims= number of last dimensions
+    fillvals= values to use to fill
+    """
+    fname='fill_ncvariable_lastdims'
+
+    var=ncf.variables[varn]
+
+    dims=var.shape
+    Ndims=len(dims)
+
+    Nprevdims = len(prevdims)
+    if not Nprevdims + Nlastdims == Ndims:
+        print erromsg
+        print '  ' + fname + ': number of dimensions previous (',Nprevdim,') and last (',Nlastdims, ') does not match with variable size: ',Ndims,' !!!!'
+        print errormsg
+        quit(-1)
+
+    if Nlastdims > Ndims-1:
+        print errormsg
+        print '  ' + fname + ': number of last dimensions ', Nlastdims,' >= than the number of dimensions of the variable ', Ndims,' !!!!'
+        print errormsg
+        quit(-1)
+
+    if Ndims == 1:
+        var[:] = fillvals
+    elif Ndims == 2:
+        var[prevdims[0], :] = fillvals
+    elif Ndims == 3:
+        if Nlastdims == 1:
+            var[prevdims[0], prevdims[1], :] = fillvals
+        else:
+            var[prevdims[0], :, :] = fillvals
+    elif Ndims == 4:
+        if Nlastdims == 1:
+            var[prevdims[0], prevdims[1], prevdims[2], :] = fillvals
+        elif Nlastdims == 2:
+            var[prevdims[0], prevdims[1], :, :] = fillvals
+        else:
+            var[prevdims[0], :, :, :] = fillvals
+    elif Ndims == 5:
+        if Nlastdims == 1:
+            var[prevdims[0], prevdims[1], prevdims[2], prevdims[3], :] = fillvals
+        elif Nlastdims == 2:
+            var[prevdims[0], prevdims[1], prevdims[2], :, :] = fillvals
+        elif Nlastdims == 3:
+            var[prevdims[0], prevdims[1], :, :, :] = fillvals
+        else:
+            var[prevdims[0], :, :, :, :] = fillvals
+    elif Ndims == 6:
+        if Nlastdims == 1:
+            var[prevdims[0], prevdims[1], prevdims[2], prevdims[3], prevdims[4], :] = fillvals
+        elif Nlastdims == 2:
+            var[prevdims[0], prevdims[1], prevdims[2], prevdims[3], :, :] = fillvals
+        elif Nlastdims == 3:
+            var[prevdims[0], prevdims[1], prevdims[2], :, :, :] = fillvals
+        elif Nlastdims == 4:
+            var[prevdims[0], prevdims[1], :, :, :, :] = fillvals
+        else:
+            var[prevdims[0], :, :, :, :] = fillvals
+    else:
+        print errormsg
+        print '  ' + fname + ' variable size ', Ndims, ' not ready!!!'
+        print errormsg
+        quit(-1)
+
+def maskvar(values, filename, varn):
+    """ Function to mask a variable using a mask. It is assumed that mask[...,dimM,dimJ,dimK] and 
+      var[...,dimM,dimJ,dimK] share the last dimensions
+    values= [maskfilename]:[maskvar]:[dimsmask]:[timename]
+      [maskfilename]= file with the mask
+      [maskvar]= name of the variable with the mask
+      [dimsmask]= dimensions d1,d2,d3,... to use from variable [mask] (ahead of the sharing ones with [var])
+      [timename]= name of the variable time in [filename]
+    filename= netCF file name
+    varn= variable name
+    """
+    fname='maskvar'
+
+    fillValue=1.e20
+    ofile = 'mask_' + varn + '.nc'
+
+    maskfilename = values.split(':')[0]
+    maskvar = values.split(':')[1]
+    maskdims = np.array(values.split(':')[2].split(','), dtype=int)
+    timename = values.split(':')[3]
+
+    ncf = NetCDFFile(filename,'r')
+
+    if not ncf.variables.has_key(varn):
+        print errormsg
+        print '    ' + fname + ': File  "' + filename + '" does not have variable "' + varn + '" !!!!'
+        print errormsg
+        ncf.close()
+        quit(-1)
+
+    varobj = ncf.variables[varn]
+    varinf = variable_inf(varobj)
+    timeobj = ncf.variables[timename]
+    timeinf = cls_time_information(ncf, timename)
+
+    ncfmask = NetCDFFile(maskfilename,'r')
+
+    if not ncfmask.variables.has_key(maskvar):
+        print errormsg
+        print '    ' + fname + ': File  "' + maskfilename + '" does not have variable mask "' + maskvar + '" !!!!'
+        print errormsg
+        ncf.close()
+        ncfmask.close()
+        quit(-1)
+
+    varmaskobj = ncfmask.variables[maskvar]
+    varmaskinf = variable_inf(varmaskobj)
+
+    sdims=[]
+    for ivdim in range(varinf.Ndims):
+        vardim = varinf.Ndims - ivdim - 1
+        maskdim = varmaskinf.Ndims - ivdim - 1
+        if varinf.dims[vardim] == varmaskinf.dims[vardim]:
+            sdims.append(varinf.dims[vardim])
+        else:
+            break
+
+    samedims = sdims[::-1]
+    print '  ' + fname + ': variable: ', varinf.dims, ' and mask: ', varmaskinf.dims,' share: ', samedims
+
+# masking
+##
+    Nsamedims=len(samedims)
+
+    if not Nsamedims + len(maskdims) == varmaskinf.Ndims:
+        print errormsg
+        print '  ' + fname + ': desired dimensions of mask ', maskdims, ' and coincident dims with variable ',Nsamedims, ' does not match mask dims ',varmaskinf.Ndims,' !!!!'
+        print errormsg
+        ncf.close()
+        ncfmask.close()
+        quit(-1)
+
+    if varmaskinf.Ndims > Nsamedims:
+        maskvals = load_ncvariable_lastdims(ncfmask, maskvar, maskdims, Nsamedims)
+    else:
+        maskvals = maskvarobj[:]
+
+    ncfmask.close()
+
+# Creation of the new file
+##
+    ncfnew = NetCDFFile(ofile,'w')
+   
+    for idim in range(varinf.Ndims):
+        newdimv = ncf.dimensions[varinf.dimns[idim]]
+        if newdimv.isunlimited():
+            ncfnew.createDimension(varinf.dimns[idim], None)
+        else:
+            ncfnew.createDimension(varinf.dimns[idim], varinf.dims[idim])
+
+    newvar = ncfnew.createVariable(varn, varinf.dtype, varinf.dimns, fill_value=fillValue)
+    for attrn in varinf.attributes:
+        if not attrn == '_FillValue':
+            attr = newvar.setncattr(attrn, varobj.getncattr(attrn))
+
+    attr = newvar.setncattr('mask', 'variable masked using ' + values.split(':')[2] + ' of variable ' + maskvar + ' from file ' + maskfilename)
+
+    ncfnew.sync()
+    ncfnew.close()
+
+    for varns in ncf.variables:
+        if not varns == varn:
+            fvaradd(filename + ':' + varns, ofile)
+
+    ncfnew = NetCDFFile(ofile,'a')
+
+    Nptmask = 1
+    for isdim in range(Nsamedims):
+        Nptmask = Nptmask * samedims[isdim]
+
+    Nvarloop = 1
+    varsecdims = []
+    for insdim in range(varinf.Ndims - Nsamedims):
+        Nvarloop = Nvarloop * varinf.dims[insdim]
+        varsecdims.append(0)
+
+    Nsecdims = len(varsecdims)
+
+    for iloop in range(Nvarloop):
+        varval = load_ncvariable_lastdims(ncf, varn, varsecdims, Nsamedims)
+        newvarval = np.where(maskvals == 1, varval, fillValue)
+        if np.sum(newvarval == fillValue) == Nptmask:
+            print errormsg
+            print '  ' + fname + ': all values got masked!!!'
+            print erromsg
+            quit(-1)
+
+        fill_ncvariable_lastdims(ncfnew,varn,varsecdims,Nsamedims,newvarval)
+
+        varsecdims[Nsecdims -1] = varsecdims[Nsecdims - 1] + 1
+        if varsecdims[Nsecdims - 1] > varinf.dims[Nsecdims - 1] - 1:
+            varsecdims[Nsecdims - 1] = 0
+            for jdim in range(Nsecdims - 1):
+                varsecdims[Nsecdims - 2 - jdim] = varsecdims[Nsecdims - 2 - jdim] + 1
+                if varsecdims[Nsecdims - 2 - jdim] <= varinf.dims[Nsecdims - 2 - jdim] - 1:
+                    break
+                else:
+                    varsecdims[Nsecdims - 2 - jdim] = 0
+                    
+    print 'variable: ', varinf.dims, ' and mask: ', varmaskinf.dims,' share: ', samedims, Nvarloop
+
+    ncfnew.sync()
+    ncfnew.close()
+    ncf.close()
+
+    print 'masked file "' + ofile + '" generated !!!'
+
+def lonlat2D(ncfobj, lonn, latn):
+    """ Function to create 2D matricies of longitudes and latitudes from the file
+    ncfobj= netCDF object file
+    lonn= longitude name
+    latn= latitude name
+    """
+    fname='lonlat2D'
+
+    lonvar = ncfobj.variables[lonn]
+    latvar = ncfobj.variables[latn]
+
+    loninf = variable_inf(lonvar)
+    latinf = variable_inf(latvar)
+
+    if loninf.Ndims == 1:
+        lonv = lonvar[:]
+        latv = latvar[:]
+        dx=loninf.dims[0]
+        dy=latinf.dims[0]
+        lonval = np.zeros((dy, dx), dtype=float)    
+        latval = np.zeros((dy, dx), dtype=float)    
+        for iy in range(dy):
+            lonval[iy,:] = lonv
+        for ix in range(dx):
+            latval[:,ix] = latv
+    elif loninf.Ndims == 2:
+        lonval = lonvar[:]
+        latval = latvar[:]
+    elif loninf.Ndims == 3:
+        lonval = lonvar[0,:,:]
+        latval = latvar[0,:,:]
+    else:
+        print errormsg
+        print '  ' + fname + ' dimension ', lonvar.Ndims, ' of the lon/lat matrices not ready !!!!'
+
+    return lonval, latval
+
+def indices_mask(mask):
+    """ Function to retrieve the indices from a 2D mask
+    mask= 2D mask matrix
+    mat=np.array(range(100), dtype=float).reshape((10,10))
+    >>> mask1= mat >= 45. 
+    >>> mask2= mat <= 55.
+    >>> mask = mask1 * mask2
+    indices_mask(mask)
+    [[4 5]
+    [4 6]
+    [4 7]
+    [4 8]
+    [4 9]
+    [5 0]
+    [5 1]
+    [5 2]
+    [5 3]
+    [5 4]
+    [5 5]]
+    """
+    dy=mask.shape[0]
+    dx=mask.shape[1]
+
+    Nptmask = np.sum(mask)
+    maskindices = np.zeros((Nptmask,2), dtype=int)
+    ij=0
+    for j in range(dy):
+        for i in range(dx):
+            if mask[j,i] == True:
+                maskindices[ij,0] = j
+                maskindices[ij,1] = i
+                ij = ij + 1
+
+    return maskindices
+
+def chgtimestep(values, origfile, varN):
+    """ Function to change the values of a given time-step of a variable inside a netCDF for values from a nother file
+    [values]=[origtime_step]:[newfile]:[newtime_step]
+      [origtime_step]: desired original time step to change: 'first', 'last', 'middle', '[num]'
+      [newfile]: new netCDF file name
+      [newtime_step]: desired new time step to change: 'first', 'last', 'middle', '[num]' 'zeros', 'fillVal'
+        'first': first time-step
+        'last': last time-step
+        'middle': middle time-step
+        '[num]': [num] time-step
+        'zeros': fill time-step with zeros
+        'fillVal': fill time-step with fill_Values [FillValue]
+    [varN]= variable name
+    [origfile]= original netCDF file name
+    """
+    fname = 'chgtimestep'
+    ermsg = fname + ': ERROR -- error -- ERROR -- error'
+
+    vals = values.split(':')
+    origtime_step = vals[0]
+    newfile = vals[1]
+    newtime_step = vals[2]
+    if len(vals) == 4:
+       FillValue = np.float(vals[3])
+
+    filexist(origfile, ermsg, 'original')
+    filexist(newfile, ermsg, 'new')
+
+    print 'origfile: ',origfile
+    ncofile = NetCDFFile(origfile,'a')
+    varinfile(ncofile, origfile, ermsg, 'change', varN)
+
+    ncnfile = NetCDFFile(newfile,'r')
+    varinfile(ncofile, newfile, ermsg, 'new', varN)
+    ncnfile.close()
+
+    if newtime_step == 'zeros':
+        newvals = uploading_timestep(newfile, varN, 'first')
+        newvals = 0.
+    elif newtime_step == 'fillVal':
+        newvals = uploading_timestep(newfile, varN, 'first')
+        newvals = FillValue
+    else:
+        newvals = uploading_timestep(newfile, varN, newtime_step)
+
+    varobj = ncofile.variables[varN]
+    Ndims = len(varobj.shape)
+
+    dimt = varobj.shape[0]
+    if origtime_step == 'first':
+        oval = 0
+    elif origtime_step == 'middle':
+        oval = int(dimt/2)
+    elif origtime_step == 'last':
+        oval = dimt-1
+    else:
+        oval = int(origtime_step)
+
+    if Ndims == 1:
+        varobj[oval] = newvals
+    elif Ndims == 2:
+        varobj[oval,:] = newvals
+    elif Ndims == 3:
+        varobj[oval,:,:] = newvals
+    elif Ndims == 4:
+        varobj[oval,:,:,:] = newvals
+    elif Ndims == 5:
+        varobj[oval,:,:,:,:] = newvals
+    elif Ndims == 6:
+        varobj[oval,:,:,:,:,:] = newvals
+    else:
+        print ermsg
+        print '  variable size', Ndims, 'not ready !'
+        print ermsg
+        quit(-1)
+
+    ncofile.sync()
+    ncofile.close()
+
+def uploading_timestep(ncfile, varN, time_step):
+    """ Function to upload a given time-step of a variable inside a netCDF
+    [ncfile]= netCDF file name
+    [varN]= variable name
+    [time_step]= desired time step: 'first', 'last', 'middle', '[num]'
+      'first': first time-step
+      'last': last time-step
+      'middle': middle time-step
+      '[num]': [num] time-step
+    """
+    fname = 'uploading_timestep'
+    ermsg = fname + ': ERROR -- error -- ERROR -- error'
+
+    filexist(ncfile, ermsg, 'uploading')
+    ncufile = NetCDFFile(ncfile,'r')
+
+    varinfile(ncufile, ncfile, ermsg, 'uploading', varN)
+
+    varobj = ncufile.variables[varN]
+
+    Ndims = len(varobj.shape)
+
+    dimt = varobj.shape[0]
+    if time_step == 'first':
+        upval = 0
+    elif time_step == 'middle':
+        upval = int(dimt/2)
+    elif time_step == 'last':
+        upval = dimt-1
+    else:
+        upval = int(time_step)
+
+    if Ndims == 1:
+        uploadvar = varobj[upval]
+    elif Ndims == 2:
+        uploadvar = varobj[upval,:]
+    elif Ndims == 3:
+        uploadvar = varobj[upval,:,:]
+    elif Ndims == 4:
+        uploadvar = varobj[upval,:,:,:]
+    elif Ndims == 5:
+        uploadvar = varobj[upval,:,:,:,:]
+    elif Ndims == 6:
+        uploadvar = varobj[upval,:,:,:,:,:]
+    else:
+        print ermsg
+        print '  variable size', Ndims, 'not ready !'
+        print ermsg
+        quit(-1)
+
+    return uploadvar
+
+def timeshiftvar(values, fileN, varN, FillVal=1.e20):
+    """ Function to temporaly shift a number of time-steps a given variable inside a netCDF file
+    [values]=[nsteps]:[[FillValue]]
+      [nsteps]: desired number of time step to move
+      [FillValue]: value to fill the empty time-steps
+    [fileobj]= original netCDF object
+    [varN]= variable name
+    """
+    from sys import stdout
+
+    fname = 'timesfhitvar'
+    ermsg = fname + ': ERROR -- error -- ERROR -- error'
+
+    nsteps = int(values.split(':')[0])
+    if len(values.split(':')) == 2:
+        FillVal = np.float(values.split(':')[1])
+
+    fileobj = NetCDFFile(fileN,'a')
+
+    varobj = fileobj.variables[varN]
+    vardims = varobj.shape
+    vartype = varobj.dtype
+    Ndims = len(vardims)
+
+    dimt = vardims[0]
+    if nsteps > 0:
+        inimov = nsteps
+        endmov = dimt
+        iniplace = 0
+        endplace = dimt - nsteps 
+    else:
+        inimov = 0
+        endmov = dimt + nsteps 
+        iniplace = -nsteps
+        endplace = dimt
+
+    print '  ' + fname + ': moving', nsteps, '___ __ _'
+    print '    from (', inimov, ',', endmov, ') to (',iniplace,',',endplace,')' 
+
+    if Ndims == 1:
+        vals = np.ones(vardims, dtype=vartype)*FillVal
+        vals[iniplace:endplace] = varobj[inimov:endmov]
+        varobj[:] = vals
+    elif Ndims == 2:
+        vals = np.ones(vardims, dtype=vartype)*FillVal
+        vals[iniplace:endplace,:] = varobj[inimov:endmov,:]
+        varobj[:] = vals
+    elif Ndims == 3:
+        vals = np.ones((vardims[0], vardims[1]), dtype=vartype)*FillVal
+        for i in range(vardims[2]):
+            if (i%10 == 0): 
+                print '\r  shifted ' + '{0:5.2g}'.format(i*100./vardims[2]) + ' %',
+                stdout.flush()
+
+            vals[iniplace:endplace,:] = varobj[inimov:endmov,:,i]
+            varobj[:,:,i] = vals
+    elif Ndims == 4:
+        vals = np.ones((vardims[0], vardims[1]), dtype=vartype)*FillVal
+        for i in range(vardims[2]):
+            for j in range(vardims[3]):
+                nvals=i*vardims[3] + j
+                if (nvals%100 == 0): 
+                    print '\r  shifted ' + '{0:5.2g}'.format(nvals*100./(vardims[2]*vardims[3])) + ' %',
+                    stdout.flush()
+
+                vals[iniplace:endplace,:] = varobj[inimov:endmov,:,i,j]
+                varobj[:,:,i,j] = vals
+    elif Ndims == 5:
+        vals = np.ones((vardims[0], vardims[1]), dtype=vartype)*FillVal
+        for i in range(vardims[2]):
+            for j in range(vardims[3]):
+                for k in range(vardims[4]):
+                    nvals=i*vardims[3]*vardims[4] + j*vardims[4] + k
+                    if (nvals%1000 == 0): 
+                        print '\r  shifted ' + '{0:5.2g}'.format(nvals*100./(vardims[2]*vardims[3]*vardims[4])) + ' %',
+                        stdout.flush()
+
+                    vals[iniplace:endplace,:] = varobj[inimov:endmov,:,i,j,k]
+                    varobj[:,:,i,j,k] = vals
+    elif Ndims == 6:
+        vals = np.ones((vardims[0], vardims[1]), dtype=vartype)*FillVal
+        for i in range(vardims[2]):
+            for j in range(vardims[3]):
+                for k in range(vardims[4]):
+                    for l in range(vardims[5]):
+                        nvals=i*vardims[3]*vardims[4]*vardims[5] + j*vardims[4]*vardims[5] + k*vardims[5] + l
+                        if (nvals%10000 == 0): 
+                            print '\r  shifted ' + \
+                             '{0:5.2g}'.format(nvals*100./(vardims[2]*vardims[3]*vardims[4]*vardims[5])) + ' %',
+                            stdout.flush()
+
+                        vals[iniplace:endplace,:] = varobj[inimov:endmov,:,i,j,k,l]
+                        varobj[:,:,i,j,k,l] = vals
+    else:
+        print ermsg
+        print '  variable size', Ndims, 'not ready !'
+        print ermsg
+        quit(-1)
+
+    print stdout.write("\n")
+
+    fileobj.sync()
+    fileobj.close()
+
+def typemod(value, typeval):
+    """ Function to give back a value in a given dtype
+    >>> print(typemod(8.2223, 'np.float64'))
+    <type 'numpy.float64'>
+    >>> print(typemod(8.2223, 'tuple'))
+    <type 'tuple'>
+    """
+    fname='typemod'
+
+    if typeval == 'int':
+        return int(value)
+    elif typeval == 'long':
+        return long(value)
+    elif typeval == 'float':
+        return float(value)
+    elif typeval == 'complex':
+        return complex(value)
+    elif typeval == 'str':
+        return str(value)
+    elif typeval == 'bool':
+        return bool(value)
+    elif typeval == 'list':
+        newval = []
+        newval.append(value)
+        return newval
+    elif typeval == 'dic':
+        newval = {}
+        newval[value] = value
+        return newval
+    elif typeval == 'tuple':
+        newv = []
+        newv.append(value)
+        newval = tuple(newv)
+        return newval
+    elif typeval == 'np.int8':
+        return np.int8(value)
+    elif typeval == 'np.int16':
+        return np.int16(value)
+    elif typeval == 'np.int32':
+        return np.int32(value)
+    elif typeval == 'np.int64':
+        return np.int64(value)
+    elif typeval == 'np.uint8':
+        return np.uint8(value)
+    elif typeval == 'np.uint16':
+        return np.uint16(value)
+    elif typeval == 'np.np.uint32':
+        return np.uint32(value)
+    elif typeval == 'np.uint64':
+        return np.uint64(value)
+    elif typeval == 'np.float':
+        return np.float(value)
+    elif typeval == 'np.float16':
+        return np.float16(value)
+    elif typeval == 'np.float32':
+        return np.float32(value)
+    elif typeval == 'float32':
+        return np.float32(value)
+    elif typeval == 'np.float64':
+        return np.float64(value)
+    elif typeval == 'float64':
+        return np.float64(value)
+    elif typeval == 'np.complex':
+        return np.complex(value)
+    elif typeval == 'np.complex64':
+        return np.complex64(value)
+    elif typeval == 'np.complex128':
+        return np.complex128(value)
+    else:
+        print errormsg
+        print fname + ':  data type "' + typeval + '" is not ready !'
+        print errormsg
+        quit(-1)
+
+def addvals(values, filename, varN):
+    """ Function to add values to a given variable at a given dimension
+    values = [dimension]:[position]:[Nvals]:[addval]
+      [dimension]: dimension at which the variable wants to be increased
+      [position]: position within the dimension at which the variable wants to be increased
+        'first': first position of the dimension
+        'middle': middle position of the dimension
+        'last': last position of the dimension
+        'num': before given value
+      [Nvals]: number of values
+      [addval]: value to give to the added values
+        'val': a given value
+        'missing': as a missing value
+    filename = name of the netCDF file
+    varN = name of the variable
+    """
+    import subprocess as sub
+    fname = 'addvals'
+    
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print addvals.__doc__
+        quit()
+
+    newf = 'addvals.nc'
+
+    dimension=int(values.split(':')[0])
+    position=values.split(':')[1]
+    Nvals=int(values.split(':')[2])
+    addval=values.split(':')[3]
+
+    filexist(filename, errormsg, 'add values')
+    ncfa = NetCDFFile(filename,'r')
+
+    varinfile(ncfa, filename, errormsg, 'adding', varN)
+    varobj=ncfa.variables[varN]
+
+    varinf=variable_inf(varobj)
+
+    newdims=list(varinf.dims)
+    newdims[dimension] = newdims[dimension] + Nvals
+    newdims=tuple(newdims)
+
+    dmodname = varinf.dimns[dimension]
+    print '      ' + fname + ' increassed dimension "' + dmodname + '"'
+
+    if position == 'first':
+        pos=0
+    elif position == 'middle':
+        pos=(varinf.dims[dimension])/2
+    elif position == 'last':
+        pos=varinf.dims[dimension]
+    else:
+        pos=int(position)
+    
+    if pos > varinf.dims[dimension]:
+        print errormsg
+        print fname + ': position given ', pos,' is too big for the size of the dimension ',varinf.dims[dimension], '!!!!'
+        print errormsg
+        quit(-1)
+
+##    print 'starting position: ', pos
+
+    if addval == 'missing':
+        addvaln = 1.e20
+    else:
+        addvaln = addval
+    addvalv=typemod(addvaln, str(varinf.dtype))
+
+    newnc = NetCDFFile(newf,'w')
+
+# Dimensions
+## 
+    for dim in ncfa.dimensions.values():
+        dname = dim._name
+        dsize = dim.__len__()
+        if dim.isunlimited():
+            dsize=None 
+        else:
+            if dname == varinf.dimns[dimension]:
+                dsize=newdims[dimension]
+
+        newnc.createDimension(dname, size=dsize)
+
+# Variables
+## 
+    for var in ncfa.variables.values():
+        vname = var._name
+        vkind = var.dtype
+        vdims = var.dimensions
+
+        varattrs = var.ncattrs()
+        if searchInlist(varattrs, '_FillValue'):
+            fillval = var.getncattr('_FillValue')
+            newvarobj = newnc.createVariable(vname, vkind, vdims, fill_value=fillval)
+        elif vname == varN and addval == 'missing':
+            newvarobj = newnc.createVariable(vname, vkind, vdims, fill_value=typemod(addvaln, str(varinf.dtype)))
+        else:
+            newvarobj = newnc.createVariable(vname, vkind, vdims)
+         
+        varobj=ncfa.variables[vname]
+        vals = varobj[:]
+
+        if vname == varN:
+             for ival in range(Nvals):
+##                 print '      ' + fname + ': adding',ival+1,' values'
+                 newvar = np.insert(vals, pos, addvalv, axis=dimension)
+                 vals=newvar.copy()
+             newvarobj[:] = newvar
+        else:
+            if vname == dmodname:
+# Increassing dimension variable values
+##
+                dvals=ncfa.variables[dmodname][:]
+                if position == 'first':
+                    valB = -(dvals[1] - dvals[0])
+                    valA=dvals[pos] + valB
+                elif position == 'last':
+                    valB=-(dvals[1] - dvals[0])
+                    valA=dvals[pos-1] - valB*Nvals
+                else:
+                    valB=-(dvals[pos] - dvals[pos-1])/(Nvals+1)
+                    valA=dvals[pos-1] - valB*Nvals
+
+                for ival in range(Nvals):
+                     addvalvar=valA + valB*ival
+##                     print '    ' + fname + ' adding to dimension variable "', dmodname ,'" value ',addvalvar
+                     newvar = np.insert(vals, pos, addvalvar, axis=0)
+                     vals=newvar.copy()
+                newvarobj[:] = newvar
+
+            else:
+                vardims=list(var.dimensions)
+                if searchInlist(vardims,varinf.dimns[dimension]):
+##                    print '    ' + fname + ' variable ' + vname + ' has also the increased dimension!'
+                    vardim=vardims.index(varinf.dimns[dimension])
+                    for ival in range(Nvals):
+                        addvalvar = addval
+                        newvar = np.insert(vals, pos, addvalvar, axis=vardim)
+                        vals=newvar.copy()
+                    newvarobj[:] = newvar
+                else:
+                    newvarobj[:] = vals
+
+        for vattr in varobj.ncattrs():
+            if not vattr == '_FillValue':
+                vattrval = var.getncattr(vattr)
+                newvarobj = set_attribute(newvarobj, vattr, vattrval)
+
+# Global attributes
+##
+    for gattr in ncfa.ncattrs():
+        gattrval = ncfa.getncattr(gattr)
+        newnc = set_attribute(newnc, gattr, gattrval)
+
+    newnc.sync()
+    newnc.close()
+    ncfa.close()
+    try:
+        ins = 'cp ' + newf + ' ' + filename
+        syscode = sub.call(ins, shell=True)
+ 
+        if not syscode == 0:
+            print errmsg
+            print "  Copy to the new file failed!"
+            print ins
+            print syscode
+            quit()
+        else:
+            sub.call('rm ' + newf, shell=True)
+
+    except OSError, e:
+        print errmsg
+        print "   Copy failed!"
+        print e
+        quit(-1)    
+
+def TimeInf(filename, tname):
+    """ Function to print all the information from the variable time
+    filename= netCDF file name
+    tname= name of the variable time
+    """
+
+    ncfobj = NetCDFFile(filename,'r')
+    timeinf = cls_time_information(ncfobj, tname)
+    fmtprinting_class(timeinf)
+    ncfobj.close()
+
+def sorttimesmat(filename, tname):
+    """ Function to sort the time values of a given file
+    tname, name of the variable time
+    filename= netCDF file name
+    """    
+
+    fname = 'sorttimesmat'
+  
+    filexist(filename, errormsg, 'to sort time')
+    ncft = NetCDFFile(filename,'a')
+
+    varinfile(ncft, filename, errormsg, 'time', tname)
+    timeobj = ncft.variables[tname]
+
+    timeinf = cls_time_information(ncft, tname)
+    tvals = timeobj[:]
+
+    Ltvals = list(tvals)
+
+    sortedtvals = sorted(Ltvals)
+
+    tinds = np.zeros((timeinf.dimt), dtype=int)
+
+    for it in range(timeinf.dimt):
+        tinds[it] = Ltvals.index(sortedtvals[it])
+
+    for var in ncft.variables:
+        varobj = ncft.variables[var]
+        if searchInlist(varobj.dimensions, tname):
+            print fname + ': time-sorting variable: "' + var + '" '
+            varvals = varobj[:]
+            newvarvals = varvals.copy()
+            for it in range(timeinf.dimt):
+                if var == 'time':
+                    print it, tinds[it], tvals[tinds[it]]
+                newvarvals[it,] = varvals[tinds[it],]
+
+            varobj[:] = newvarvals
+
+    ncft.sync()
+    ncft.close()
+
+def diffdate_units(diffdate, units):
+    """ Function to transform a difference of dates to a certain units
+    diffdate = difference of dates (as timedelta)
+    units = units to transform: 'weeks', 'days', 'hours', 'minutes', 'seconds', 'miliseconds', 'nanoseconds'
+    >>> diffdate_units(dt.datetime(1976, 2, 17, 8, 32, 5) - dt.datetime(1949, 12, 1, 0, 0, 0), 'seconds')
+    827224325.0
+    """
+    fname = 'diffdate_units'
+
+    if units == 'weeks':
+        diffunits = diffdate.days/7. + diffdate.seconds/(3600.*24.*7.)
+    elif units == 'days':
+        diffunits = diffdate.days + diffdate.seconds/(3600.*24.)
+    elif units == 'hours':
+        diffunits = diffdate.days*24. + diffdate.seconds/(3600.)
+    elif units == 'minutes':
+        diffunits = diffdate.days*24.*60. + diffdate.seconds/(60.)
+    elif units == 'seconds':
+        diffunits = diffdate.days*24.*3600. + diffdate.seconds
+    elif units == 'miliseconds':
+        diffunits = diffdate.days*24.*3600.*1000. + diffdate.seconds*1000.
+    elif units == 'nanoseconds':
+        diffunits = diffdate.days*24.*3600.*1000000. + diffdate.seconds*1000000.
+    else:
+        print errormsg
+        print fname + ': time units "' + units + '" not ready!!!'
+        print errormsg
+        quit(-1)
+
+    return diffunits
+
+def days_month(year,month):
+    """ Function to give the number of days of a month of a given year
+    >>> days_month(1976,2)
+    29
+    """
+    import datetime as dt
+
+    date1=dt.date(year,month,1)
+    date2=dt.date(year,month+1,1)
+
+    diffdate = date2-date1
+    return diffdate.days
+
+def mid_period(yr1,mon1,day1,hour1,min1,sec1,yr2,mon2,day2,hour2,min2,sec2):
+    """ Function to give the mid poiint of a period
+    >>> mid_period(1976,2,1,0,0,0,1976,3,1,0,0,0)
+    [1976    2   15   12    0    0]
+    """
+    import datetime as dt
+
+    date1=dt.datetime(yr1,mon1,day1,hour1,min1,sec1)
+    date2=dt.datetime(yr2,mon2,day2,hour2,min2,sec2)
+
+    diffdate = date2-date1
+    diffseconds = diffdate.days*24*3600 + diffdate.seconds
+    diff2 = dt.timedelta(seconds=diffseconds/2)
+    datenew = date1 + diff2
+    datenewvals = np.array([datenew.year, datenew.month, datenew.day, datenew.hour,  \
+      datenew.minute, datenew.second])
+
+    return datenewvals
+
+def days_year(year):
+    """ Function to give the number of days of a year
+    >>> days_year(1976)
+    366
+    """
+    import datetime as dt
+
+    date1=dt.date(year,1,1)
+    date2=dt.date(year+1,1,1)
+
+    diffdate = date2-date1
+    return diffdate.days
+
+def days_period(yeari,yearf):
+    """ Function to give the number of days for a period
+    >>> days_period(1976,1980)
+    1827
+    """
+
+    ndays=0    
+    for iyr in range(yearf-yeari+1):
+        ndays=ndays+days_year(yeari+iyr)
+
+    return ndays
+
+def check_times_file(values, filename, timen):
+    """ Function to check time-steps of a given file
+    values=[FirstDate]:[LastDate][freq]:[auxmonth]
+      [FirstDate] = first date within file (in [YYYY][MM][DD][HH][MI][SS] format)
+      [LastDate] = last date within file (in [YYYY][MM][DD][HH][MI][SS] format)
+      [freq] = frequency of the data within the file (in time units) or 'month' (monthly values)
+      [auxmonth] = in case of 'month'
+        midmon: dates are given according to the mid time value of the month
+        real: dates are given increassing a month from the previous date
+    filename: name of the file
+    timen: name of the variable time
+    """
+    import datetime as dt
+    fname = 'check_times_file'
+
+    FirstDate = values.split(':')[0]
+    LastDate = values.split(':')[1]
+    freq = values.split(':')[2]
+
+    ncft = NetCDFFile(filename, 'r')
+
+    varinfile(ncft, filename, errormsg, '', timen)
+
+    timeobj=ncft.variables[timen]
+    timeinf = cls_time_information(ncft, timen)
+
+    timevals = timeobj[:]
+    ncft.close()
+
+    yrf=int(FirstDate[0:4])
+    monf=int(FirstDate[4:6])
+    dayf=int(FirstDate[6:8])
+    horf=int(FirstDate[8:10])
+    minf=int(FirstDate[10:12])
+    secf=int(FirstDate[12:14])
+ 
+    firstdate = dt.datetime(yrf, monf, dayf, horf, minf, secf)
+
+    yrl=int(LastDate[0:4])
+    monl=int(LastDate[4:6])
+    dayl=int(LastDate[6:8])
+    horl=int(LastDate[8:10])
+    minl=int(LastDate[10:12])
+    secl=int(LastDate[12:14])
+ 
+    lastdate = dt.datetime(yrl, monl, dayl, horl, minl, secl)
+
+    firstT = firstdate - timeinf.refdate
+    t0 = diffdate_units(firstT, timeinf.units)
+
+    period = lastdate - firstdate
+    per = diffdate_units(period, timeinf.units)
+
+    if freq != 'month':
+        theordimt = np.int(per / np.float64(freq) + 1)
+    else:
+        theordimt = np.int((yrl - yrf + 1) * 12)
+
+    theordates = np.zeros((theordimt), dtype=np.float64)
+    theordates[0] = t0
+    if freq != 'month':
+        theordates = t0 + np.arange(1,theordimt) * np.float64(freq)
+    else:
+        auxmonth = values.split(':')[3]
+        if auxmonth == 'midmon':
+            t01 = np.array([yrf, monf, 1, 0, 0, 0])
+        else:
+            t01 = np.array([yrf, monf, dayf, horf, minf, secf])
+
+        for it in range(1,theordimt):
+            t02 = t01.copy()
+            t02[1] = t02[1] + 1
+            if t02[1] > 12:
+                t02[1] = 1
+                t02[0] = t02[0] + 1
+
+            date01 = dt.datetime(t01[0], t01[1], t01[2], t01[3], t01[4], t01[5])
+
+            if auxmonth == 'midmon':
+                date02 = dt.datetime(t02[0], t02[1], t02[2], t02[3], t02[4], t02[5])
+                diff012 = date02 - date01
+                t01 = diffdate_units(date01 - timeinf.refdate, timeinf.units)
+                theordates[it] = t01 + diffdate_units(diff012, timeinf.units) / 2.
+            elif auxmonth == 'real':
+                date02 = dt.datetime(t02[0], t02[1], t01[2], t01[3], t01[4], t01[5])
+                diff012 = date02 - date01
+                theordates[it] = theordates[it-1] + diffdate_units(diff012, timeinf.units)
+            else:
+                print errormsg
+                print fname + ': frequency "month" required third argument "' + auxmonth + '" not ready!!!!'
+                print errormsg
+                quit(-1)
+
+            t01 = t02.copy()        
+
+    equaldates = sorted(list(set(theordates) & set(timevals)))
+    missdates = sorted(list(set(theordates) - set(timevals)))
+
+    Nequal = len(equaldates)
+    Ndiff = len(missdates)
+
+    if theordimt != timeinf.dimt:
+        print warnmsg
+        print fname + ': there are not the correspondant times (', theordimt ,') in file "' + filename + '" with ', timeinf.dimt,' time-steps !!!!!!!'
+        print '    ' + fname + ': Number equal times-steps: ', Nequal, 'Number different time-steps: ', Ndiff
+
+        if Nequal >= Ndiff or Nequal == 0:
+            matdates = netCDFdatetime_realdatetime(timeinf.unitsval, timeinf.calendar, missdates)
+            print '  file does not have dates: '
+            for it in range(Ndiff):
+                print matdates[it,:]
+        else:
+            matdates = netCDFdatetime_realdatetime(timeinf.unitsval, timeinf.calendar, equaldates)
+            print '  file only has: '
+            for it in range(Nequal):
+                print matdates[it,:]
+
+def writing_str_nc(varo, values, Lchar):
+    """ Function to write string values in a netCDF variable as a chain of 1char values
+    varo= netCDF variable object
+    values = list of values to introduce
+    Lchar = length of the string in the netCDF file
+    """
+
+    Nvals = len(values)
+    for iv in range(Nvals):    
+        stringv=values[iv]  
+        charvals = np.chararray(Lchar)
+        Lstr = len(stringv)
+        charvals[Lstr:Lchar] = ''
+
+        for ich in range(Lstr):
+            charvals[ich] = stringv[ich:ich+1]
+
+        varo[iv,:] = charvals
+
+def writing_1str_nc(varo, values, Lchar):
+    """ Function to write 1 string value in a netCDF variable as a chain of 1char values
+    varo= netCDF variable object
+    values = list of values to introduce
+    Lchar = length of the string in the netCDF file
+    """
+
+    stringv=values
+    charvals = np.chararray(Lchar)
+    Lstr = len(stringv)
+    charvals[Lstr:Lchar] = ''
+
+    for ich in range(Lstr):
+        charvals[ich] = stringv[ich:ich+1]
+
+    varo[:] = charvals
+
+    return
+
+def get_1str_nc(varo, Lchar):
+    """ Function to get 1 string value in a netCDF variable as a chain of 1char values
+    varo= netCDF variable object
+    Lchar = length of the string in the netCDF file
+    """
+
+    string = ''
+
+    for ich in range(Lchar):
+        charval =  str(stringv[ich:ich+1]).replace('[','').replace(']','')
+        if charval == '':
+            break
+        else:
+            if ich == 0:
+                string = charval
+            else:
+                string = string + charval
+        
+    return string
+
+def get_str_nc(varo, Lchar):
+    """ Function to get string values in a netCDF variable as a chains of 1char values
+    varo= netCDF variable object
+    Lchar = length of the string in the netCDF file
+    """
+
+    Nvalues = varo.shape[0]
+
+    strings = []
+
+    for ival in range(Nvalues):
+        stringv = varo[ival]
+        string = str('')
+        for ich in range(Lchar):
+            charval = str(stringv[ich:ich+1]).replace('[','').replace(']','')
+            if charval == '--':
+                break
+            else:
+                if ich == 0:
+                    string = charval
+                else:
+                    string = string + charval
+
+        strings.append(string)
+
+    return strings
+
+class ysubsetstats(object):
+    """ Class to compute multi-year statistics of a given subset of values 
+    values= values to use
+    dates=dates of the values in matrix format ([year], [month], [day], [hour], [minute], [second])
+    sec=section to use for the period='year', 'month', 'day', 'hour', 'minute', 'second'
+    vali=initial value of the period
+    valf=final value of the period
+    Nq= number of quantiles (20 for 5% bins, it is going to produce 21 values)
+    missval= missing value
+      self.Nvalues = Number of non masked values
+      self.min = minimum non masked value
+      self.max = maximum non masked value
+      self.mean = mean non masked value
+      self.mean2 = quandratic mean non masked value
+      self.stdev = standard deviation non masked value
+      self.quantiles = quantiles non masked value
+    """  
+    def __init__(self, values, dates, sec, vali, valf, Nq, missVal):
+        import numpy.ma as ma
+
+        fname = 'ysubsetstats'
+  
+        if values is None:
+            self.Nvalues = None
+            self.min = None
+
+            self.max = None
+            self.mean = None
+            self.mean2 = None
+            self.stdev = None
+            self.quantiles = None
+
+        else:
+            Nvalues = len(values)
+            Ndates = len(dates)
+
+            if Nvalues != Ndates:
+                print errormsg
+                print fname + ': number of values ', Nvalues,' does not coincide with the number of dates ',Ndates, '!!!!!!'
+                print errormsg
+                quit(-1)
+
+            initialsub = np.zeros(Nvalues, dtype=bool)
+            endsub = initialsub.copy()
+
+            if missVal > 0.:
+                valuesmask = ma.masked_greater_equal(values, missVal*0.9)
+            else:
+                valuesmask = ma.masked_less_equal(values, missVal*0.9)
+
+            if sec == 'year':
+                isec = 0
+            elif sec == 'month':
+                isec = 1
+            elif sec == 'day':
+                isec = 2
+            elif sec == 'hour':
+                isec = 3
+            elif sec == 'minute':
+                isec = 4
+            elif sec == 'second':
+                isec = 5
+            else:
+                print errormsg
+                print fname + ': sction "' + sec + '" not ready!!!!'
+                print errormsg
+                quit(-1)
+    
+            if vali < valf:
+                timesmaskperi = ma.masked_less(dates[:,isec], vali)
+                timesmaskperf = ma.masked_greater(dates[:,isec], valf)
+            else:
+                timesmaskperi = ma.masked_less(dates[:,isec], valf)
+                timesmaskperf = ma.masked_greater(dates[:,isec], vali)
+
+            finalmask = valuesmask.mask+timesmaskperi.mask+timesmaskperf.mask
+            finalvalues = ma.array(values, mask=finalmask)
+
+            finalvalues2 = finalvalues*finalvalues
+
+            self.Nvalues = finalvalues.count()
+            self.min = finalvalues.min()
+            self.max = finalvalues.max()
+            self.mean = finalvalues.mean()
+            self.mean2 = finalvalues2.mean()
+            self.stdev = finalvalues.std()
+            self.quantiles = mask_quantiles(finalvalues, Nq) 
+
+def remapnn(values, filename, varn, ddegL, ddegl):
+    """ Function to remap to the nearest neightbor a variable using projection from another file
+    values=[newprojectionfile]:[newlonname,newlatname]:[oldlonname,oldlatname]
+      [newprojectionfile]: name of the file with the new projection
+      [newlonname,newlatname]: name of the longitude and the latitude variables in the new file
+      [oldlonname,oldlatname]: name of the longitude and the latitude variables in the old file
+    filename= netCDF file name
+    varn= variable name
+    ddegL= Longitude range around the old grid point to speed up the search
+    ddegl= latitude range around the old grid point to speed up the search
+    """ 
+    fname = 'remapnn'
+    ofile = 'remapnn_' + varn + '.nc'
+    fillValue = 1.e20
+
+    newprojectionfile = values.split(':')[0]
+    newlonlatname = values.split(':')[1]
+    oldlonlatname = values.split(':')[2]
+
+    filexist(filename, errormsg, 'old file')
+    filexist(newprojectionfile, errormsg, 'new file')
+
+    oldlon=oldlonlatname.split(',')[0]
+    oldlat=oldlonlatname.split(',')[1]
+
+    oldncfile = NetCDFFile(filename,'r')
+    varinfile(oldncfile, filename, errormsg, 'old', oldlon)
+    varinfile(oldncfile, filename, errormsg, 'old', oldlat)
+
+    newlon=newlonlatname.split(',')[0]
+    newlat=newlonlatname.split(',')[1]
+
+    newncfile = NetCDFFile(newprojectionfile,'r')
+    varinfile(newncfile, newprojectionfile, errormsg, 'old', newlon)
+    varinfile(newncfile, newprojectionfile, errormsg, 'old', newlat)
+
+    oldlon2d, oldlat2d = lonlat2D(oldncfile, oldlon, oldlat)
+    newlon2d, newlat2d = lonlat2D(newncfile, newlon, newlat)
+
+    newdimx = newlon2d.shape[1]
+    newdimy = newlon2d.shape[0]
+
+    olddimx = oldlon2d.shape[1]
+    olddimy = oldlon2d.shape[0]
+
+# pairs old-->new
+##
+    mappairs = np.ones((newdimy, newdimx, 2), dtype=int)
+    mappairs = mappairs*fillValue
+    print '     ' + fname + ' searching nearest neighbor...'
+    for jnew in range(newdimy):
+        for inew in range(newdimx):
+            if ((jnew*newdimx + inew)%100 == 0): print '      ' + fname + ' found: ', '{0:5.2f}'.format(float(jnew*newdimx + inew)*100/(newdimx*newdimy*1)), '%'
+
+            masklonoldpt1 = oldlon2d >= newlon2d[jnew, inew] - float(ddegL)
+            masklonoldpt2 = oldlon2d <= newlon2d[jnew, inew] + float(ddegL)
+            masklonoldpt = masklonoldpt1 * masklonoldpt2
+            masklatoldpt1 = oldlat2d >= newlat2d[jnew, inew] - float(ddegl)
+            masklatoldpt2 = oldlat2d <= newlat2d[jnew, inew] + float(ddegl)
+            masklatoldpt = masklatoldpt1 * masklatoldpt2
+
+            Nmasklon = np.sum(masklonoldpt)
+            Nmasklat = np.sum(masklatoldpt)
+
+            if Nmasklon > 0 and Nmasklat > 0:
+##                print newlon2d[jnew, inew], newlat2d[jnew, inew], ' ### ', np.min(oldlon2d), np.max(oldlon2d), ':', np.min(oldlat2d), np.max(oldlat2d)
+##                print masklonoldpt.shape, masklatoldpt.shape, Nmasklon, Nmasklat
+                maskindlon = indices_mask(masklonoldpt)
+                maskindlat = indices_mask(masklatoldpt)
+
+                mindist=1000000.
+#            for jold in range(olddimy):
+#                for iold in range(olddimx):
+#                   dist=np.sqrt((oldlon2d[jold, iold] - newlon2d[jnew, inew])**2. + \
+#                     (oldlat2d[jold, iold] - newlat2d[jnew, inew])**2.)
+                for jold in range(Nmasklat):
+                    for iold in range(Nmasklon):
+                       if maskindlon[iold,0] == maskindlat[jold,0] and maskindlon[iold,1] == maskindlat[jold,1]:
+                           dist=np.sqrt((newlon2d[jnew, inew] - oldlon2d[maskindlon[iold,0], maskindlon[iold,1]])**2. + \
+                             (newlat2d[jnew, inew] - oldlat2d[maskindlat[jold,0], maskindlat[jold,1]])**2.)
+##                           print jold, iold, ':' , maskindlon[iold,:], '-->', maskindlat[jold,:], '**** L:', \
+##                             oldlon2d[maskindlon[iold,0], maskindlon[iold,1]], 'l', oldlat2d[maskindlat[jold,0], maskindlat[jold,1]], \
+##                             'dist:',dist, 'mindist: ', mindist
+                           if dist < mindist:
+                               mindist = dist
+##                               print jold, iold, 'dist: ', dist, 'L', maskindlon[iold,:], 'l', maskindlat[jold,:]
+                               mappairs[jnew, inew, 0] = maskindlon[iold,1]
+                               mappairs[jnew, inew, 1] = maskindlat[jold,0]
+
+##                quit()
+
+    varobj = oldncfile.variables[varn]
+    varinf = variable_inf(varobj)
+
+# Creation of the new file
+##
+    ncfnew = NetCDFFile(ofile,'w')
+   
+    for idim in range(varinf.Ndims):
+        newdimv = oldncfile.dimensions[varinf.dimns[idim]]
+        if dimensions[varinf.dimns[idim]] == oldlon or dimensions[varinf.dimns[idim]] == oldlat:
+            if dimensions[varinf.dimns[idim]] == oldlon:
+                ncfnew.createDimension(varinf.dimns[idim], newdimx)
+            else:
+                ncfnew.createDimension(varinf.dimns[idim], newdimy)
+        else:
+            if newdimv.isunlimited():
+                ncfnew.createDimension(varinf.dimns[idim], None)
+            else:
+                ncfnew.createDimension(varinf.dimns[idim], varinf.dims[idim])
+
+    newvar = ncfnew.createVariable(varn, varinf.dtype, varinf.dimns, fill_value=fillValue)
+    for attrn in varinf.attributes:
+        if not attrn == '_FillValue':
+            attr = newvar.setncattr(attrn, varobj.getncattr(attrn))
+
+    attr = newvar.setncattr('mask', 'variable remapped at nearest neighbors using ' + values.split(':')[0] + ' using ' + \
+      ' as longitude and latitude valules ')
+
+    ncfnew.sync()
+    ncfnew.close()
+
+    for varns in ncf.variables:
+        if not varns == varn:
+            fvaradd(filename + ':' + varns, ofile)
+        elif varns == oldlon:
+            fvaradd(newprojectionfile + ':' + newlon, ofile)
+        elif varns == oldlat:
+            fvaradd(newprojectionfile + ':' + newlat, ofile)
+
+    chvarname(oldlon, ofile, newlon)
+    chvarname(oldlat, ofile, newlat)
+
+    ncfnew = NetCDFFile(ofile,'a')
+
+# looping on all the variable
+##
+    varsecdims = []
+    Nvarloop=1
+    for insdim in range(varinf.Ndims - 2):
+        Nvarloop = Nvarloop * varinf.dims[insdim]
+        varsecdims.append(0)
+
+    Nsecdims = len(varsecdims)
+
+    for iloop in range(Nvarloop):
+        varval = load_ncvariable_lastdims(oldncfile, varn, varsecdims, 2)
+        for jnew in range(newdimy):
+            for inew in range(newdimx):
+                if ((jnew*newdimx + inew)%100 == 0): print '      ' + fname + ': ', '{0:5.2f}'.format(float((jnew*newdimx + inew)*100./(newdimx*newdimy))), '% done'
+                newvarval[jnew, inew] = varval[mappairs[jnew, inew, 0], mappairs[jnew, inew, 1]]
+                
+        fill_ncvariable_lastdims(ncfnew,varn,varsecdims,2,newvarval)
+
+        varsecdims[Nsecdims -1] = varsecdims[Nsecdims - 1] + 1
+        if varsecdims[Nsecdims - 1] > varinf.dims[Nsecdims - 1] - 1:
+            varsecdims[Nsecdims - 1] = 0
+            for jdim in range(Nsecdims - 1):
+                varsecdims[Nsecdims - 2 - jdim] = varsecdims[Nsecdims - 2 - jdim] + 1
+                if varsecdims[Nsecdims - 2 - jdim] <= varinf.dims[Nsecdims - 2 - jdim] - 1:
+                    break
+                else:
+                    varsecdims[Nsecdims - 2 - jdim] = 0
+
+    ncfnew.sync()
+    ncfnew.close()
+
+    print 'remapnn: new file "' + ofile + '" with remapped variable written !!'
+#remapnn('data/R1_CCRC_NARCliM_MOM_1950-2009_pracc.nc:lon,lat:lon,lat', 'data/AWAP_pre_1950-2009_pre_mask.nc', 'pre', 1. , 1.)
+#quit()
+
+def checkallvars(values, filen):
+    """ Function to check all variables of a file
+    values=[dimn1],[[dimn2],...,[dimnN]]:[dim1],[[dim2],...,[dimN]]
+      [dimn1/N]: name of dimension
+      [dim1/N]: value for the given dimension
+        [0-N]: dimension value
+        -1: last value
+        -2: half of the dimension size
+        -3: all values
+    filen=name of the netCDF file to check
+    """
+    fname = "'checkallvars'"
+
+    dimns = values.split(':')[0].split(',')
+    dims0 = np.array(values.split(':')[1].split(','))
+    Ndims = len(dimns)
+    dims = np.zeros( (Ndims), dtype=np.int)
+    dimvals = np.zeros( (Ndims), dtype=np.int)
+
+    ncobj = NetCDFFile(filen,'r')
+
+    for idim in range(Ndims):
+        dims[idim] = np.int(dims0[idim])
+        if not ncobj.dimensions.has_key(dimns[idim]):
+            print errormsg
+            print '  ' + fname + " file '" + filen + "' does not have dimension '" + dimns[idim] + "' !!!!"
+            quit(-1)
+
+        sizedim = len(ncobj.dimensions[dimns[idim]])
+        if dims[idim] == -3:
+            dimvals[idim] = -1
+        elif dims[idim] == -2:
+            dimvals[idim] = sizedim/2
+        elif dims[idim] == -1:
+            dimvals[idim] = sizedim-1
+        else:
+            dimvals[idim] = dims[idim]
+             
+        print "  dimension '" + dimns[idim] + "' of size: ",sizedim,' shown at :',\
+          dimvals[idim]
+
+    ivar = 1
+    for varn in ncobj.variables:
+        varobj = ncobj.variables[varn]
+        varinf = variable_inf(varobj)
+        dimsvar = np.zeros( (varinf.Ndims), dtype=np.int)
+        dimsvar[:] = -9
+        for ivardim in range(varinf.Ndims):
+            vardimn = varinf.dimns[ivardim]
+            for idim in range(Ndims):
+                if vardimn == dimns[idim]: dimsvar[ivardim] = dimvals[idim]
+            if dimsvar[ivardim] == -9:
+                print errormsg
+                print '  ' + fname + " No value given to the dimension '" + vardimn +\
+                   "' !!"
+                quit(-1)
+
+        print ivar, ':', varn + ' with: ', varinf.dimns,' outputted as: ',dimsvar,' ___________________'
+        if varinf.Ndims == 1:
+            if dimsvar == -1:
+                varvals = varobj[:]
+            else:
+                varvals = varobj[dimsvar]
+        elif varinf.Ndims == 2:
+            if dimsvar[0] == -1 and dimsvar[1] == -1:
+                varvals = varobj[:]
+            elif dimsvar[0] == -1 and dimsvar[1] != -1:
+                varvals = varobj[:,dimsvar[1]]
+            elif dimsvar[0] != -1 and dimsvar[1] == -1:
+                varvals = varobj[dimsvar[0],:]
+            else:
+                varvals = varobj[dimsvar[0],dimsvar[1]]
+        elif varinf.Ndims == 3:
+            if dimsvar[0] == -1 and dimsvar[1] == -1 and dimsvar[2] == -1:
+                varvals = varobj[:]
+            elif dimsvar[0] == -1 and dimsvar[1] == -1 and dimsvar[2] != -1:
+                varvals = varobj[:,:,dimsvar[2]]
+            elif dimsvar[0] == -1 and dimsvar[1] != -1 and dimsvar[2] == -1:
+                varvals = varobj[:,dimsvar[1],:]
+            elif dimsvar[0] != -1 and dimsvar[1] == -1 and dimsvar[2] == -1:
+                varvals = varobj[dimsvar[0],:,:]
+            elif dimsvar[0] == -1 and dimsvar[1] != -1 and dimsvar[2] != -1:
+                varvals = varobj[:,dimsvar[1],dimsvar[2]]
+            elif dimsvar[0] != -1 and dimsvar[1] != -1 and dimsvar[2] == -1:
+                varvals = varobj[dimsvar[0],dimsvar[1],:]
+            elif dimsvar[0] != -1 and dimsvar[1] == -1 and dimsvar[2] != -1:
+                varvals = varobj[dimsvar[0],:,dimsvar[2]]
+            else:
+                varvals = varobj[dimsvar[0],dimsvar[1],dimsvar[2]]
+        elif varinf.Ndims == 4:
+            if dimsvar[0] == -1 and dimsvar[1] == -1 and dimsvar[2] == -1 and dimsvar[3] == -1:
+                varvals = varobj[:]
+            elif dimsvar[0] == -1 and dimsvar[1] == -1 and dimsvar[2] == -1 and dimsvar[3] != -1:
+                varvals = varobj[:,:,:,dimsvar[2]]
+            elif dimsvar[0] == -1 and dimsvar[1] == -1 and dimsvar[2] != -1 and dimsvar[3] == -1:
+                varvals = varobj[:,:,dimsvar[2],:]
+            elif dimsvar[0] == -1 and dimsvar[1] != -1 and dimsvar[2] == -1 and dimsvar[3] == -1:
+                varvals = varobj[:,dimsvar[1],:,:]
+            elif dimsvar[0] != -1 and dimsvar[1] == -1 and dimsvar[2] == -1 and dimsvar[3] == -1:
+                varvals = varobj[dimsvar[0],:,:,:]
+            elif dimsvar[0] == -1 and dimsvar[1] == -1 and dimsvar[2] != -1 and dimsvar[3] != -1:
+                varvals = varobj[:,:,dimsvar[2],dimsvar[3]]
+            elif dimsvar[0] == -1 and dimsvar[1] != -1 and dimsvar[2] == -1 and dimsvar[3] != -1:
+                varvals = varobj[:,dimsvar[1],:,dimsvar[3]]
+            elif dimsvar[0] != -1 and dimsvar[1] == -1 and dimsvar[2] == -1 and dimsvar[3] != -1:
+                varvals = varobj[dimsvar[1],:,:,dimsvar[3]]
+            elif dimsvar[0] == -1 and dimsvar[1] != -1 and dimsvar[2] != -1 and dimsvar[3] == -1:
+                varvals = varobj[:,dimsvar[1],dimsvar[2],:]
+            elif dimsvar[0] != -1 and dimsvar[1] == -1 and dimsvar[2] != -1 and dimsvar[3] == -1:
+                varvals = varobj[dimsvar[0],:,dimsvar[2],:]
+            elif dimsvar[0] != -1 and dimsvar[1] != -1 and dimsvar[2] == -1 and dimsvar[3] == -1:
+                varvals = varobj[dimsvar[0],dimsvar[1],:,:]
+            elif dimsvar[0] == -1 and dimsvar[1] != -1 and dimsvar[2] != -1 and dimsvar[3] != -1:
+                varvals = varobj[:,dimsvar[1],dimsvar[2],dimsvar[3]]
+            elif dimsvar[0] != -1 and dimsvar[1] == -1 and dimsvar[2] != -1 and dimsvar[3] != -1:
+                varvals = varobj[dimsvar[0],:,dimsvar[2],dimsvar[3]]
+            elif dimsvar[0] != -1 and dimsvar[1] != -1 and dimsvar[2] == -1 and dimsvar[3] != -1:
+                varvals = varobj[dimsvar[0],dimsvar[1],:,dimsvar[3]]
+            elif dimsvar[0] != -1 and dimsvar[1] != -1 and dimsvar[2] != -1 and dimsvar[3] == -1:
+                varvals = varobj[dimsvar[0],dimsvar[1],dimsvar[2],:]
+            else:
+                varvals = varobj[dimsvar[0],dimsvar[1],dimsvar[2],dimvals[3]]
+        else:
+            print errormsg
+            print '  ' + fname + ' number of dimensions ',varinf.Ndims,' not ready!!'
+            quit(-1)
+        print varvals    
+        ivar = ivar + 1
+
+    ncobj.close()
+
+def give_fix1dim_values(mat,iddim,dimval):
+    """ Function to return matrix values when one dimension has been removed at a 
+      given value
+    mat = matrix
+    iddim = dimesion to remove (starting from 0 tacking the right most)
+    dimval = value of the dimension
+
+    >>> matrix = np.array( (range(27)), dtype=np.float).reshape(3,3,3)
+    give_fix1dim_values(matrix,2,2)
+    [[[  0.   1.   2.]
+      [  3.   4.   5.]
+      [  6.   7.   8.]]
+
+     [[  9.  10.  11.]
+      [ 12.  13.  14.]
+      [ 15.  16.  17.]]]
+    """
+    fname='give_fix1dim_values'
+
+# Not working ma.squeeze
+##    import numpy.ma as ma
+##    print ma.squeeze(mat, axis = (idim,))
+    
+    matshape = mat.shape
+    mattype = mat.dtype
+    matmask = np.ones( tuple(matshape), dtype=bool)
+
+    zerodims=np.ones( (6), dtype=int)
+    Ndims = len(matshape)
+    if Ndims > 6: 
+        print errmsg
+        print '  ' + fname + ' number of dimensions: ',Ndims,' not ready!!!!!'
+        quit(-1)
+
+    zerodims[5-Ndims+1:6] = matshape
+
+    newdims = list(matshape)
+    newdims[Ndims-1-iddim] = matshape[iddim]-1
+
+    mask = np.ones(tuple(zerodims), dtype=bool)
+    vals = np.zeros(tuple(zerodims), dtype=mattype)
+    vals[0:zerodims[0],0:zerodims[1],0:zerodims[2],0:zerodims[3],0:zerodims[4],
+      0:zerodims[5]] = mat
+
+    for i5 in range(zerodims[5]):
+        for i4 in range(zerodims[4]):
+            for i3 in range(zerodims[3]):
+                for i2 in range(zerodims[2]):
+                    for i1 in range(zerodims[1]):
+                        for i0 in range(zerodims[0]):
+#                            print 'iddim:',iddim,'dimval:',dimval,'-->',i0,i1,i2,i3,i4,i5
+                            if iddim == 5 and dimval == i0:
+                                mask[i0,i1,i2,i3,i4,i5] = False
+                            elif iddim == 4 and dimval == i1:
+                                mask[i0,i1,i2,i3,i4,i5] = False
+                            elif iddim == 3 and dimval == i2:
+                                mask[i0,i1,i2,i3,i4,i5] = False
+                            elif iddim == 2 and dimval == i3:
+                                mask[i0,i1,i2,i3,i4,i5] = False
+                            elif iddim == 1 and dimval == i4:
+                                mask[i0,i1,i2,i3,i4,i5] = False
+                            elif iddim == 0 and dimval == i5:
+                                mask[i0,i1,i2,i3,i4,i5] = False
+
+    newmat = vals[mask].reshape(tuple(newdims))
+#    print 'newmat dim:',iddim,'val:',dimval,':',newdims,'______'
+#    print newmat
+   
+    return newmat
+
+def portion_fix1dim_values(mat,iddim,dimval):
+    """ Function to return that portion of the matrix values when one dimension has
+      been removed at a given value
+    mat = matrix
+    iddim = dimesion to remove (starting from 0 tacking the right most)
+    dimval = value of the dimension
+
+    >>> matrix = np.array( (range(27)), dtype=np.float).reshape(3,3,3)
+    portion_fix1dim_values(matrix,2,2)
+    [[ 18.  19.  20.]
+     [ 21.  22.  23.]
+     [ 24.  25.  26.]]
+    """
+    fname='portion_fix1dim_values'
+
+# Not working ma.squeeze
+##    import numpy.ma as ma
+##    print ma.squeeze(mat, axis = (idim,))
+    
+    matshape = mat.shape
+    mattype = mat.dtype
+    matmask = np.zeros( tuple(matshape), dtype=bool)
+
+    zerodims=np.ones( (6), dtype=int)
+    Ndims = len(matshape)
+
+    if Ndims > 6: 
+        print errmsg
+        print '  ' + fname + ' number of dimensions: ',Ndims,' not ready!!!!!'
+        quit(-1)
+
+    zerodims[5-Ndims+1:6] = matshape
+
+    newdims = []
+    for idim in range(Ndims):
+        if idim != iddim:
+            newdims.append(matshape[idim])
+
+    newdims.reverse()
+
+    mask = np.zeros(tuple(zerodims), dtype=bool)
+    vals = np.zeros(tuple(zerodims), dtype=mattype)
+    vals[0:zerodims[0],0:zerodims[1],0:zerodims[2],0:zerodims[3],0:zerodims[4],
+      0:zerodims[5]] = mat
+
+    for i5 in range(zerodims[5]):
+        for i4 in range(zerodims[4]):
+            for i3 in range(zerodims[3]):
+                for i2 in range(zerodims[2]):
+                    for i1 in range(zerodims[1]):
+                        for i0 in range(zerodims[0]):
+#                            print 'iddim:',iddim,'dimval:',dimval,'-->',i0,i1,i2,i3,i4,i5
+                            if iddim == 5 and dimval == i0:
+                                mask[i0,i1,i2,i3,i4,i5] = True
+                            elif iddim == 4 and dimval == i1:
+                                mask[i0,i1,i2,i3,i4,i5] = True
+                            elif iddim == 3 and dimval == i2:
+                                mask[i0,i1,i2,i3,i4,i5] = True
+                            elif iddim == 2 and dimval == i3:
+                                mask[i0,i1,i2,i3,i4,i5] = True
+                            elif iddim == 1 and dimval == i4:
+                                mask[i0,i1,i2,i3,i4,i5] = True
+                            elif iddim == 0 and dimval == i5:
+                                mask[i0,i1,i2,i3,i4,i5] = True
+
+#    print 'newmat dim:',iddim,'val:',dimval,':',newdims,'______'
+    newmat = vals[mask].reshape(tuple(newdims))
+#    print newmat
+   
+    return newmat
+
+def valmod_dim(values, ncfile, varn):
+    """ Function to modify the value of a variable at a given dimension and value
+    values = dimn,dimval,modins,modval1,[modval2,...]
+      dimn = name of the dimension
+      dimval = value of the dimension at which change the values
+      modins = instruction: 
+        'sumc', add [modval1]
+        'subc', substraction [modval1]
+        'mulc', multiply by [modval1] 
+        'divc', divide by [modval1] 
+        'lowthres': modify all values below [modval1] to [modval2]
+        'upthres': modify all values above [modval1] to [modval2]
+    ncfile = netCDF file name
+    varn = name of the variable
+    >>> valmod_dim('num_metgrid_levels,10,mulc,-1','aqua_met-em_control.nc','PRES')
+    """
+    fname = 'valmod_dim'
+
+    if values == '-h':
+        print """ Function to modify the value of a variable at a given dimension and value
+          values = dimn,dimval,modins,modval1,[modval2,...]
+          dimn = name of the dimension
+          dimval = value of the dimension at which change the values
+          modins = instruction: 
+            'sumc', add [modval1]
+            'subc', substraction [modval1]
+            'mulc', multiply by [modval1] 
+            'divc', divide by [modval1] 
+            'lowthres': modify all values below [modval1] to [modval2]
+            'upthres': modify all values above [modval1] to [modval2]
+          ncfile = netCDF file name
+          varn = name of the variable
+          >>> valmod_dim('num_metgrid_levels,10,mulc,-1','aqua_met-em_control.nc','PRES')
+          """
+        quit()
+
+##  mat = np.array( (range(27)), dtype=np.float).reshape(3,3,3)
+
+    vals = values.split(',')
+    Lvals = len(vals)
+
+    dimn = vals[0]
+    dimval = np.int(vals[1])
+    modins = vals[2]
+    modval = np.float(vals[3])
+    newvalues = ','.join(vals[2:Lvals])
+
+    if not os.path.isfile(ncfile):
+      print errormsg
+      print '   valmod: File "' + ncfile + '" does not exist !!'
+      print errormsg
+      quit(-1)    
+
+    ncf = NetCDFFile(ncfile,'a')
+
+    if ncf.dimensions.has_key('plev'):
+      # removing pressure level from variable name
+      varn = re.sub("\d+", "", varn) 
+
+    if not ncf.dimensions.has_key(dimn):
+      print errormsg
+      print '   ' + fname + ': File "' + ncfile + '" does not have dimension "' +    \
+        dimn + '" !!!!'
+      ncf.close()
+      quit(-1)
+
+    if not ncf.variables.has_key(varn):
+      print errormsg
+      print '   ' + fname + ': File "' + ncfile + '" does not have variable "' +     \
+        varn + '" !!!!'
+      ncf.close()
+      quit(-1)
+
+    varobj = ncf.variables[varn]
+    varinf = variable_inf(varobj)
+
+    varvals = varobj[:]
+
+# Dimension id
+    iddim=varinf.Ndims - 1
+    for idimn in varinf.dimns:
+#        print iddim, idimn
+        if dimn == idimn:
+            break
+
+        iddim = iddim - 1
+
+    matshape = varvals.shape
+    mattype = varvals.dtype
+    matmask = np.zeros( tuple(matshape), dtype=bool)
+
+    zerodims=np.ones( (6), dtype=int)
+    Ndims = len(matshape)
+
+    if Ndims > 6: 
+        print errmsg
+        print '  ' + fname + ' number of dimensions: ',Ndims,' not ready!!!!!'
+        quit(-1)
+
+    zerodims[5-Ndims+1:6] = matshape
+
+    newdims = []
+    for idim in range(Ndims):
+#        print idim,'matshape[idim]:',matshape[Ndims-1-idim],'iddim:',iddim
+        if idim != iddim:
+            newdims.append(matshape[Ndims-1-idim])
+
+    newdims.reverse()
+
+    mask = np.zeros(tuple(zerodims), dtype=bool)
+    vals = np.zeros(tuple(zerodims), dtype=mattype)
+    newvals = np.zeros(tuple(zerodims), dtype=mattype)
+
+    vals[0:zerodims[0],0:zerodims[1],0:zerodims[2],0:zerodims[3],0:zerodims[4],      \
+      0:zerodims[5]] = varvals
+
+#    print 'vals shape:',vals.shape,':',newdims
+
+    for i5 in range(zerodims[5]):
+        for i4 in range(zerodims[4]):
+            for i3 in range(zerodims[3]):
+                for i2 in range(zerodims[2]):
+                    for i1 in range(zerodims[1]):
+                        for i0 in range(zerodims[0]):
+#                            print 'iddim:',iddim,'dimval:',dimval,'-->',i0,i1,i2,i3,i4,i5
+                            if iddim == 5 and dimval == i0:
+                                mask[i0,i1,i2,i3,i4,i5] = True
+                            elif iddim == 4 and dimval == i1:
+                                mask[i0,i1,i2,i3,i4,i5] = True
+                            elif iddim == 3 and dimval == i2:
+                                mask[i0,i1,i2,i3,i4,i5] = True
+                            elif iddim == 2 and dimval == i3:
+                                mask[i0,i1,i2,i3,i4,i5] = True
+                            elif iddim == 1 and dimval == i4:
+                                mask[i0,i1,i2,i3,i4,i5] = True
+                            elif iddim == 0 and dimval == i5:
+                                mask[i0,i1,i2,i3,i4,i5] = True
+
+#    print 'newmat dim:',iddim,'val:',dimval,':',newdims,'______'
+    newmat = vals[mask].reshape(tuple(newdims))
+    varmod = np.zeros(tuple(newdims), dtype=mattype) 
+
+    varshape = newmat.shape
+    vartype = newmat.dtype
+    Ndims = len(varshape)
+      
+    if Ndims <= 2:
+        varmod = valmodoper(newmat, newvalues)
+    elif Ndims == 3:
+        for i in range(varshape[0]):
+            varmod[i,:,:] = valmodoper(newmat[i,:,:], newvalues)
+    elif Ndims == 4:
+        for i in range(varshape[0]):
+            for j in range(varshape[1]):
+                varmod[i,j,:,:] = valmodoper(newmat[i,j,:,:], newvalues)
+    elif Ndims == 5:
+        for i in range(varshape[0]):
+            for j in range(varshape[1]):
+                for k in range(varshape[2]):
+                    varmod[i,j,k,:,:] = valmodoper(newmat[i,j,k,:,:], newvalues)
+
+    newvals = np.where( mask, varmod, vals)
+    zerdims = np.where( zerodims == 1, 0, zerodims )
+
+    finalvals = newvals[0:zerodims[0],0:zerodims[1],0:zerodims[2],0:zerodims[3],\
+      0:zerodims[4],0:zerodims[5]]
+    finalvals = np.squeeze(finalvals)
+
+    if len(varobj.shape) != len(finalvals.shape):
+        print '  Modified values have a different shape:', finalvals.shape,          \
+          'than variable:', varobj.shape
+        print '  Assuming that extra dimensions are at the beggining'
+        newfinalvals = finalvals.reshape(varobj.shape)
+        varobj[:] = newfinalvals[:]
+    else:
+        varobj[:] = finalvals[:]
+
+    ncf.sync()
+    ncf.close()
+
+def checkNaNs(values, filen):
+    """ Function to check for NaN values over all variables in a file
+    values = absolute lower threshold for NaN value
+    filen=name of the netCDF file to check
+    """
+    fname = "'checkNaNs'"
+
+    valthres = np.float(values)
+    ncobj = NetCDFFile(filen,'r')
+    S1val = np.dtype('a1') 
+    Sval = np.dtype(str)
+    Uval = np.dtype(unicode)
+
+    ivar = 1
+    print fname + ' checking with: ',valthres,' in _______'
+    for varn in ncobj.variables:
+        varobj = ncobj.variables[varn]
+        varinf = variable_inf(varobj)
+        varvals = varobj[:]
+        var1 = varvals.flatten()[0]
+
+        if varinf.dtype != type('c') and varinf.dtype != type('Str') and             \
+          varinf.dtype != Sval.type and varinf.dtype != Uval.type and                \
+          varinf.dtype != S1val.type and type(var1) != S1val.type and                \
+          type(var1) != Sval.type and type(var1) != Uval.type:
+            print '  ' + varn + ':',varinf.dims
+            found=0
+            if varinf.Ndims == 1:
+                for i0 in range(varinf.dims[0]):
+                    if abs(varvals[i0]) > valthres or np.isnan(varvals[i0]):
+                        print '  ' + fname + ': NaN value found on variable "' +     \
+                          varn + '" at: ',i0,' value: ',varvals[i0]
+                        break
+            elif varinf.Ndims == 2:
+                for i1 in range(varinf.dims[0]):
+                    for i0 in range(varinf.dims[1]):
+                        if abs(varvals[i1,i0]) > valthres or np.isnan(varvals[i1,i0]):
+                            print '  ' + fname + ': NaN value found on variable "' + \
+                              varn + '" at: ',i1,', ',i0,' value: ',varvals[i1,i0]
+                            found=1
+                            break
+                    if found == 1: break 
+            elif varinf.Ndims == 3:
+                for i2 in range(varinf.dims[0]):
+                    for i1 in range(varinf.dims[1]):
+                        for i0 in range(varinf.dims[2]):
+                            if abs(varvals[i2,i1,i0]) > valthres or                  \
+                              np.isnan(varvals[i2,i1,i0]):
+                                print '  ' + fname +                                 \
+                                  ': NaN value found on variable "' + varn +         \
+                                  '" at: ', i2,', ',i1,', ',i0,' value: ',           \
+                                  varvals[i2,i1,i0]
+                                found=1
+                                break
+                        if found == 1: break 
+                    if found == 1: break 
+            elif varinf.Ndims == 4:
+                for i3 in range(varinf.dims[0]):
+                    for i2 in range(varinf.dims[1]):
+                        for i1 in range(varinf.dims[2]):
+                            for i0 in range(varinf.dims[3]):
+                                if abs(varvals[i3,i2,i1,i0]) > valthres or           \
+                                  np.isnan(varvals[i3,i2,i1,i0]):
+                                    print '  ' + fname +                             \
+                                      ': NaN value found on variable "' + varn +     \
+                                      '" at: ', i3,', ', i2,', ',i1,', ',i0,         \
+                                      ' value: ',varvals[i3,i2,i1,i0]
+                                    found=1
+                                    break
+                            if found == 1: break 
+                        if found == 1: break 
+                    if found == 1: break 
+            elif varinf.Ndims == 5:
+                for i4 in range(varinf.dims[0]):
+                    for i3 in range(varinf.dims[1]):
+                        for i2 in range(varinf.dims[2]):
+                            for i1 in range(varinf.dims[3]):
+                                for i0 in range(varinf.dims[4]):
+                                    if abs(varvals[i4,i3,i2,i1,i0]) > valthres or    \
+                                      np.isnan(varvals[i4,i3,i2,i1,i0]):
+                                        print '  ' + fname +                         \
+                                          ': NaN value found on variable "' + varn + \
+                                          '" at: ', i4,', ', i3,', ', i2,', ',i1,    \
+                                          ', ',i0,' value: ',varvals[i4,i3,i2,i1,i0]
+                                        found=1
+                                        break
+                                if found == 1: break 
+                            if found == 1: break 
+                        if found == 1: break 
+                    if found == 1: break 
+            else:
+                print errormsg
+                print '  ' + fname + ' number of dimensions ',varinf.Ndims,          \
+                  ' not ready!!'
+                quit(-1)
+            ivar = ivar + 1
+
+    ncobj.close()
+
+##checkNaNs(10.e10, '/d4/lflmd/etudes/WRF_LMDZ/WaquaL/WRF/control/wrfout_d01_1979-12-01_00:00:00')
+##checkNaNs(10.e10, '/d4/lflmd/etudes/FF/tests/em_quarter_ss/run/wrfout_d01_0001-01-01_00:00:00')
+
+def checkAllValues(values, filen):
+    """ Function to check for variables with along all their dimensions with the same value in a file
+    values = value to check
+    filen=name of the netCDF file to check
+    """
+    fname = "'checkAllValues'"
+
+    valcheck = np.float(values)
+    ncobj = NetCDFFile(filen,'r')
+    S1val = np.dtype('a1') 
+    Sval = np.dtype(str)
+    Uval = np.dtype(unicode)
+
+    ivar = 1
+    print fname + ' checking with: ',valcheck,' in _______'
+    for varn in ncobj.variables:
+        varobj = ncobj.variables[varn]
+        varinf = variable_inf(varobj)
+        varvals = varobj[:]
+        var1 = varvals.flatten()[0]
+
+        if varinf.dtype != type('c') and varinf.dtype != type('Str') and             \
+          varinf.dtype != Sval.type and varinf.dtype != Uval.type and                \
+          varinf.dtype != S1val.type and type(var1) != S1val.type and                \
+          type(var1) != Sval.type and type(var1) != Uval.type:
+            print '  ' + varn + ':',varinf.dims
+            if np.all(varvals == valcheck):
+                print '  ' + fname + ': variable "' + varn +                         \
+                  '" with all its values == ',valcheck
+
+            ivar = ivar + 1
+
+    ncobj.close()
+
+##checkAllValues(0., '/d4/lflmd/etudes/WRF_LMDZ/WaquaL/WRF/control/wrfout_d01_1979-12-01_00:00:00')
+##checkAllValues(0., '/d4/lflmd/etudes/FF/tests/em_quarter_ss/run/wrfout_d01_0001-01-01_00:00:00')
+##checkAllValues(0., '/home/lluis/etudes/WRF_LMDZ/tests/wrf_input/AR40.0/wrfout_d01_1979-01-01_00:00:00')
+
+def DataSetSection(values, filen):
+    """ Function to get a section (values along a dimension) of a given data-set
+      values= [dimn],[beg],[end],[int]
+        [dimn]: name of the dimension
+        [beg],[end],[int]: beginning, end and interval along the dimension-axis
+          [end] = -1, values until the end
+      filen= netCDF with the data-set
+      DataSetSection('time,3,15,1','test.nc')
+    """
+    fname = 'DataSetSection'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print DataSetSection.__doc__
+        quit()
+
+    dimn = values.split(',')[0]
+    begv = np.int(values.split(',')[1])
+    endv = np.int(values.split(',')[2])
+    intv = np.int(values.split(',')[3])
+
+    ofile=filen.split('.')[0] + '_' + dimn + '_B' + str(begv) + '-E' + str(endv) +   \
+      '-I' + str(intv) + '.nc'
+
+    nciobj = NetCDFFile(filen,'r')
+    ncoobj = NetCDFFile(ofile,'w')
+
+# Creating dimensions
+## 
+    for dims in nciobj.dimensions:
+        objdim = nciobj.dimensions[dims]
+
+        if objdim.isunlimited():
+            dimsize = None
+        else:
+            if dims == dimn:
+                if begv > len(objdim):
+                    print errormsg
+                    print '  ' + fname + ': beginning value' ,begv,                  \
+                      'is larger than dimension (', len(objdim), ')!!!!'
+                    quit(-1)
+                if endv > len(objdim):
+                    print errormsg
+                    print '  ' + fname + ': endining value' ,endv,                   \
+                      'is larger than dimension (', len(objdim), ')!!!!'
+                    quit(-1)
+
+                if endv == -1: endv = len(objdim)
+                dimsize = (endv - begv + 1)/intv - 1
+            else:
+                dimsize = len(objdim)
+
+        print '    ' + fname + ': adding dimension: ' + dims + ' size:',dimsize
+        dim = ncoobj.createDimension(dims, dimsize)
+
+    ncoobj.sync()
+# Creating variables
+## 
+    for varns in nciobj.variables:
+        print '    ' + fname + ': adding variable "' + varns + '"...'
+        varobj = nciobj.variables[varns]
+
+        vardims = varobj.dimensions
+
+        if not searchInlist(list(vardims),dimn):
+            varvals = varobj[:]
+        else:
+            varslice = []
+            for dimname in varobj.dimensions:
+                if dimname == dimn:
+                    varslice.append(slice(begv,endv,intv))
+                else:
+                    Ldim = len(nciobj.dimensions[dimname])
+                    varslice.append(slice(0,Ldim))
+
+            varvals = varobj[tuple(varslice)]
+
+# Adding fill value attribute
+##
+        varattrs = varobj.ncattrs()
+        if searchInlist(varattrs, '_FillValue'):
+            varfil = varobj._FillValue
+        else:
+            varfil = False
+        vartype = varobj.dtype
+
+        newvar = ncoobj.createVariable(varns, vartype, vardims, fill_value=varfil)
+        newvar[:] = varvals
+
+        for attrs in varattrs:
+            if not attrs == '_FillValue':
+                attrv = varobj.getncattr(attrs)
+                attr = set_attribute(newvar, attrs, attrv)
+
+# Global attributes
+## 
+    for attrs in nciobj.ncattrs():
+        attrv = nciobj.getncattr(attrs)
+        attr = set_attribute(ncoobj, attrs, attrv)
+
+    nciobj.close()
+
+    ncoobj.sync()
+    ncoobj.close()
+
+    print '  ' + fname + ' succesfull creation of file "' + ofile + '" !!!'
+
+    return
+
+def DataSetSection_multidims(values, filen):
+    """ Function to get a section (values along multiple dimensions) of a given data-set
+      values= [dimn1],[beg1],[end1],[int1]@[...[[dimnM],[begM],[endM],[intM]]]
+        [dimni]: name of the dimension
+        [begi],[endi],[inti]: beginning, end and interval along the dimension-axis
+          [endi] = -1, last value
+          NOTE: dimensions without values are taken allover their size
+      filen= netCDF with the data-set
+      DataSetSection_multidims('Time,-1,-1,1@bottom_top,6,6,1','wrfout_d01_1979-12-01_00:00:00')
+    """
+    fname = 'DataSetSection_multidims'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print DataSetSection_multidims.__doc__
+        quit()
+
+    Ndims = len(values.split('@'))
+
+    dimns = []
+    ofiletile = ''
+    begvs = np.zeros((Ndims), dtype=int)
+    endvs = np.zeros((Ndims), dtype=int)
+    intvs = np.zeros((Ndims), dtype=int)
+
+    for idim in range(Ndims):
+        val = values.split('@')[idim]
+        dimns.append(val.split(',')[0])
+        begvs[idim] = int(val.split(',')[1])
+        endvs[idim] = int(val.split(',')[2])
+        intvs[idim] = int(val.split(',')[3])
+        ofiletile = ofiletile + '_' + dimns[idim] + '_B' + str(begvs[idim]) + '-E' + \
+          str(endvs[idim]) + '-I' + str(intvs[idim])
+
+    ofile = ofile=filen.split('.')[0] + ofiletile + '.nc'
+
+    nciobj = NetCDFFile(filen,'r')
+    ncoobj = NetCDFFile(ofile,'w')
+
+# Creating dimensions
+## 
+    print '  ' + fname + ': adding dimensions...'
+    newdimsizes = {}
+    dimslices = {}
+    varslice = []
+
+    for dims in nciobj.dimensions:
+        objdim = nciobj.dimensions[dims]
+        dimsize = -1
+        if not searchInlist(dimns, dims):
+            if objdim.isunlimited():
+                dimsize = None
+            else:
+                dimsize = len(objdim)
+            varslice.append(slice(0,len(objdim)))
+        else:
+            dimid = dimns.index(dims)
+            if begvs[dimid] > len(objdim):
+                print errormsg
+                print '  ' + fname + ': beginning value' ,begvs[dimid],              \
+                  'is larger than dimension (', len(objdim), ')!!!!'
+                quit(-1)
+            if endvs[dimid] > len(objdim):
+                print errormsg
+                print '  ' + fname + ': endining value' ,endvs[dimid],               \
+                  'is larger than dimension (', len(objdim), ')!!!!'
+                quit(-1)
+
+            if begvs[dimid] != endvs[dimid]:
+                dimsize = [(endvs[dimid]-begvs[dimid]+1)/intvs[dimid]-1]
+                dimslices[dims] = [begvs[dimid],endvs[dimid]+1,intvs[dimid]]
+            else:
+                dimsize = 1
+                if begvs[dimid] == -1:
+                    dimslices[dims] = [len(objdim)-1,len(objdim),1]
+                else:
+                    dimslices[dims] = [begvs[dimid],begvs[dimid]+1,1]
+
+        newdimsizes[dims] = dimsize
+        if dimsize != -1:
+            if len(objdim) == 1 or dimsize != 1:
+                print '    ' + fname + ': adding dimension: '+ dims +' size:',dimsize
+                if objdim.isunlimited(): dimsize=None
+                dim = ncoobj.createDimension(dims, dimsize)
+
+    ncoobj.sync()
+    print '  ' + fname + ': Slice according to dimension selection: ',dimslices
+# Creating variables
+## 
+    print '  ' + fname + ': adding variables...'
+    for varns in nciobj.variables:
+#        print '    ' + fname + ': adding variable "' + varns + '"...'
+        varobj = nciobj.variables[varns]
+
+        varorigdims = varobj.dimensions
+        vardims = []
+
+# From: http://stackoverflow.com/questions/1388818/how-can-i-compare-two-lists-in-python-and-return-matches
+        coinc = list(set(varorigdims) & set(dimns))
+        if len(coinc) == 0:
+            varvals = varobj[:]
+            vardims = varorigdims
+        else:
+            varslice = []
+            for dimname in varorigdims:
+                if searchInlist(dimns, dimname):
+                    varslice.append(slice(dimslices[dimname][0],                     \
+                      dimslices[dimname][1], dimslices[dimname][2]))
+                    if newdimsizes[dimname] != 1: vardims.append(dimname)
+                else:
+                    Ldim = len(nciobj.dimensions[dimname])
+                    varslice.append(slice(0,Ldim))
+                    vardims.append(dimname)
+
+            varvals = varobj[tuple(varslice)]
+
+# Adding fill value attribute
+##
+#        print '  final variable dimensions:',vardims
+        varattrs = varobj.ncattrs()
+        if searchInlist(varattrs, '_FillValue'):
+            varfil = varobj._FillValue
+        else:
+            varfil = False
+        vartype = varobj.dtype
+
+        newvar = ncoobj.createVariable(varns, vartype, tuple(vardims),               \
+          fill_value=varfil)
+#        print 'newvar:',newvar.shape,'varvals:',varvals.shape
+        newvar[:] = varvals
+
+        for attrs in varattrs:
+            if not attrs == '_FillValue':
+                attrv = varobj.getncattr(attrs)
+                attr = set_attribute(newvar, attrs, attrv)
+
+# Global attributes
+## 
+    for attrs in nciobj.ncattrs():
+        attrv = nciobj.getncattr(attrs)
+        attr = set_attribute(ncoobj, attrs, attrv)
+
+    slicevalS = ''
+    for dimid in range(Ndims):
+        dn = dimns[dimid]
+        if dimslices[dn][2] is not None:
+            slicevalS = slicevalS + dn + ' (' + str(dimslices[dn][0]) + ',' +        \
+              str(dimslices[dn][1]) + ',' + str(dimslices[dn][2]) + '); '
+        else:
+            slicevalS = slicevalS + dn + ' (' + str(dimslices[dn][0]) + ',' +        \
+              str(dimslices[dn][1]) + ',1); '
+
+    attr = set_attribute(ncoobj, 'sliced_dimensions', slicevalS)
+
+    nciobj.close()
+
+    ncoobj.sync()
+    ncoobj.close()
+
+    print '  ' + fname + ' succesfull creation of file "' + ofile + '" !!!'
+
+    return
+
+#DataSetSection_multidims('Time,-1,-1,1@bottom_top,6,6,1','wrfout_d01_1979-12-01_00:00:00')
+#DataSetSection_multidims('bottom_top,6,6,1@south_north,3,3,1@west_east,26,26,1','wrfout_d01_1979-12-01_00:00:00')
+
+def sellonlatbox(values, ncfile, varn):
+    """ Function to select a lotlan box from a data-set
+      values= [lonName],[latName],[lonSW],[latSW],[lonNE],[latNE]
+        [lonName]: name of the variable with the longitudes
+        [latName]: name of the variable with the latitudes 
+        [lonSW],[latSW]: longitude and latitude of the SW vertex of the box
+        [lonNE],[latNE]: longitude and latitude of the NE vertex of the box
+      ncfile= netCDF file
+      varn= name of the variable
+    """
+    fname = 'sellonlatbox'
+
+    ofile = 'sellonlatbox_' + varn + '.nc'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print sellonlatbox.__doc__
+        quit()
+
+    lonn = values.split(',')[0]
+    latn = values.split(',')[1]
+
+    lonSW = np.float(values.split(',')[2])
+    latSW = np.float(values.split(',')[3])
+    lonNE = np.float(values.split(',')[4])
+    latNE = np.float(values.split(',')[5])
+
+    objfile = NetCDFFile(ncfile, 'r')
+    lonobj = objfile.variables[lonn]
+    latobj = objfile.variables[latn]
+
+    lonv = lonobj[:]
+    latv = latobj[:]
+
+    if not searchInlist(objfile.variables, varn):
+        print errormsg
+        print '  ' + fname + ': variable name "' + varn + '" is not in file "' +     \
+          ncfile + '" !!!!!'
+        quit(-1)
+
+    varobj = objfile.variables[varn]
+
+    Ndimslon = len(lonobj.shape)
+    Ndimslat = len(latobj.shape)
+    Ndimsvar = len(varobj.shape)
+
+# Looking for coincidence of dimensions
+    samedim = []
+    for idv in range(Ndimsvar):
+        for idl in range(Ndimslon):
+            if varobj.dimensions[idv] == lonobj.dimensions[idl]:
+                if not searchInlist(samedim,varobj.dimensions[idv]): 
+                    samedim.append(varobj.dimensions[idv])
+                    break
+        for idl in range(Ndimslat):
+            if varobj.dimensions[idv] == latobj.dimensions[idl]:
+                if not searchInlist(samedim,varobj.dimensions[idv]): 
+                    samedim.append(varobj.dimensions[idv])
+                    break
+
+    Ndimshare = len(samedim)
+    print 'variable and lon/lat matrices share ', Ndimshare,' dimensions: ',samedim
+
+    samedimslonlat = True
+    for idL in range(Ndimslon):
+        for idl in range(Ndimslat):
+            if lonobj.dimensions[idl] != latobj.dimensions[idl]:
+                samedimslonlat = False
+                break
+
+        if not samedimslonlat: break
+    
+# Creation of the lon/lat matrices to search
+    if Ndimshare == 1:
+        lonmat = lonobj[:]
+        latmat = latobj[:]
+    elif Ndimshare == 2:
+        if samedimslonlat:
+            lonmat = lonobj[:]
+            latmat = latobj[:]
+        else:
+            if Ndimslon != 1 and Ndimslat != 1:
+                print errormsg
+                print '  ' + fname + ': I do not know how to keep going!'
+                print '    lon ', Ndimslon,' and lat ',Ndimslat,                     \
+                  ' matrices do not share the same dimensions, and do not have shape 1'
+                quit(-1)
+            else:
+                lonmat = np.zeros((latobj.shape[0], lonobj.shape[0]), dtype=np.float)
+                latmat = np.zeros((latobj.shape[0], lonobj.shape[0]), dtype=np.float)
+
+                for i in range(lonobj.shape[0]):
+                    latmat[:,i] = latobj[:]
+                for j in range(latobj.shape[0]):
+                    lonmat[j,:] = lonobj[:]
+    elif Ndimshare == 3:
+        if samedimslonlat:
+            lonmat = lonobj[0,:,:]
+            latmat = latobj[0,:,:]
+    else:
+        print errormsg
+        print '  ' + fname + ': dimension sharing of lon/lat not ready!'
+        quit(-1)
+
+# Searching for inside points
+    iind = 0
+    if Ndimshare == 1:
+        inside = {}
+        for iL in range(lonobj.shape[0]):
+            if lonobj[iL] >= lonSW and lonobj[iL] <= lonNE and latobj[iL] >= latSW   \
+              and latobj[iL] <= latNE:
+                inside[iind] = iL
+                iind = iind + 1
+    elif Ndimshare == 2:
+        newidx = []
+        newidy = []
+        if (len(lonobj.shape) == 3):
+            inside = np.zeros((lonobj.shape[1], lonobj.shape[2]), dtype=bool)
+        else:
+            inside = np.zeros((lonobj.shape), dtype=bool)
+
+        for iL in range(lonobj.shape[1]):
+            for il in range(lonobj.shape[0]):
+                if lonobj[il,iL] >= lonSW and lonobj[il,iL] <= lonNE and             \
+                  latobj[il,iL] >= latSW and latobj[il,iL] <= latNE:
+                    if not searchInlist(newidx, iL): newidx.append(iL)
+                    if not searchInlist(newidy, il): newidy.append(il)
+                    inside[il, iL] = True
+                    iind = iind + 1
+    elif Ndimshare == 3:
+        newidx = []
+        newidy = []
+        inside = np.zeros((lonobj.shape[1], lonobj.shape[2]), dtype=bool)
+
+        for iL in range(lonobj.shape[2]):
+            for il in range(lonobj.shape[1]):
+                if lonobj[0,il,iL] >= lonSW and lonobj[0,il,iL] <= lonNE and         \
+                  latobj[0,il,iL] >= latSW and latobj[0,il,iL] <= latNE:
+                    if not searchInlist(newidx, iL): newidx.append(iL)
+                    if not searchInlist(newidy, il): newidy.append(il)
+                    inside[il, iL] = True
+                    iind = iind + 1
+
+    Ninpts = len(inside)
+    newdx = len(newidx)
+    newdy = len(newidy)
+
+    print '  ' + fname +': ',Ninpts,' pts found in the box: ',lonSW,',',latSW,' x ', \
+      lonNE,',',latNE
+
+# Creation of cropped matrices
+    inlon = np.zeros((Ninpts), dtype=np.float)
+    inlat = np.zeros((Ninpts), dtype=np.float)
+    invar = np.zeros((varobj.shape[0],Ninpts), dtype=np.float)
+
+# Creation of the netCDF file
+##
+    objofile = NetCDFFile(ofile, 'w')
+
+    if Ndimshare == 1:
+
+# Dimensions
+        newdim = objofile.createDimension('boxpt', Ninpts)
+        newdim = objofile.createDimension('time', None)
+
+# var dimensions
+        newvar = objofile.createVariable('lon', 'f8', ('boxpt'))
+        newattr = basicvardef(newvar, 'lon', 'longitude', 'degrees west_east')
+        newvar[:] = lonobj[inside[iin]]
+
+        newvar = objofile.createVariable('lat', 'f8', ('boxpt'))
+        newattr = basicvardef(newvar, 'lat', 'latitude', 'degrees north_south')
+        newvar[:] = latobj[inside[iin]]
+
+        newvar = objofile.createVariable('time', 'f8', ('time'))
+        if objfile.variables.has_key('time'):
+            otime = objfile.variables['time']
+            timevals = otime[:]
+            if searchInlist(otime.ncattrs(),'units'):
+                tunits = otime.getncattr['units']
+            else:
+                tunits = 'unkown'
+        else:
+            timevals = np.arange(varobj.shape[0])
+            tunits = 'unkown'
+
+        newattr = basicvardef(newvar, 'time', 'time', tunits)
+
+        newvar[:] = timevals
+
+# variable
+        newvar = objofile.createVariable(varn, 'f4', ('time', 'boxpt'))
+        newvar[:] = varobj[invar]
+    else:
+
+# Dimensions
+        newdim = objofile.createDimension('x', newdx)
+        newdim = objofile.createDimension('y', newdy)
+        newdim = objofile.createDimension('time', None)
+
+# var dimensions
+        newvar = objofile.createVariable('lon', 'f8', ('y', 'x'))
+        if Ndimshare == 2:
+          Vals = lonobj[:]
+        else:
+          Vals = lonobj[0,:,:]
+
+        for it in range(varobj.shape[0]):
+            newvar[:] = Vals[inside].reshape(newdy,newdx)
+
+        newattr = basicvardef(newvar, 'lon', 'longitude', 'degrees west_east')
+
+        newvar = objofile.createVariable('lat', 'f8', ('y', 'x'))
+        newattr = basicvardef(newvar, 'lat', 'latitude', 'degrees north_south')
+        if Ndimshare == 2:
+          Vals = latobj[:]
+        else:
+          Vals = latobj[0,:,:]
+
+
+        for it in range(varobj.shape[0]):
+            newvar[:] = Vals[inside].reshape(newdy,newdx)
+
+        newvar = objofile.createVariable('time', 'f8', ('time'))
+        if objfile.variables.has_key('time'):
+            otime = objfile.variables['time']
+            timevals = otime[:]
+            if searchInlist(otime.ncattrs(),'units'):
+                tunits = otime.getncattr['units']
+            else:
+                tunits = 'unkown'
+        else:
+            timevals = np.arange(varobj.shape[0])
+            tunits = 'unkown'
+
+        newattr = basicvardef(newvar, 'time', 'time', tunits)
+
+        newvar[:] = timevals
+
+# variable
+        newvar = objofile.createVariable(varn, 'f4', ('time', 'y', 'x'))
+        for it in range(varobj.shape[0]):
+            valsvar = varobj[it,:,:]
+            newvar[it,:,:] = valsvar[inside]
+
+    if searchInlist(varobj.ncattrs(),'standard_name'):
+        vsname = varobj.getncattr('standard_name')
+    else:
+        vsname = varn
+    if searchInlist(varobj.ncattrs(),'long_name'):
+        vlname = varobj.getncattr('long_name')
+    else:
+        vlname = varn
+    if searchInlist(varobj.ncattrs(),'units'):
+        vunits = varobj.getncattr('units')
+    else:
+        vunits = 'unkown'
+
+    newattr = basicvardef(newvar, vsname, vlname, vunits)
+
+# global attributes
+    objofile.setncattr('author', 'L. Fita')
+    objofile.setncattr('institution', 'Laboratire de Meteorologie Dynamique')
+    objofile.setncattr('university', 'Pierre Marie Curie - Jussieu')
+    objofile.setncattr('center', 'Centre National de Recherches Scientifiques')
+    objofile.setncattr('city', 'Paris')
+    objofile.setncattr('country', 'France')
+    objofile.setncattr('script', 'nc_var_tools.py')
+    objofile.setncattr('function', 'sellonlatbox')
+    objofile.setncattr('version', '1.0')
+
+    objfile.close()
+
+    objofile.sync()
+    objofile.close()
+
+    print '  ' + fname + ': successful creation of file "' + ofile + '" !!!'
+
+    return
+
+#sellonlatbox('h', '/san0/lflmd/DATA/SAFRAN/ForcPRCP_france_SAFRAN_8Km_1hour_1996080100_1997073123_V1_01.nc', 'RR')
+#sellonlatbox('lon,lat,2.,42.5,5.,45.', '/home/lluis/DATA/SAFRAN/safran_RR_1996.nc', 'RR')
+#sellonlatbox('lon,lat,2.,42.5,5.,45.', '/san0/lflmd/DATA/SAFRAN/ForcPRCP_france_SAFRAN_8Km_1hour_1996080100_1997073123_V1_01.nc', 'product')
+#sellonlatbox('XLONG,XLAT,2.,42.5,5.,45.', '/san0/lflmd/etudes/WRF_LMDZ/WL_HyMeX/Cevennes96/control/wrfout/wrfout_d01_1996-09-17_00:00:00', 'RAINC')
+
+def compute_deaccum(values, ncfile, varname):
+    """ Function to compute deaccum: deaccumulation of a variable (VAR[t+1]-VAR[t])
+      values= [timedimname] name of the time dimension
+      ncfile= netCDF file to use
+      varname= variable to deaccumulate
+    """
+    fname='compute_deaccum'
+
+    ofile = 'deaccumulated_' + varname + '.nc'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print compute_deacccum.__doc__
+        quit()
+
+    objnc = NetCDFFile(ncfile, 'r')
+
+    if not objnc.variables.has_key(varname):
+        print errormsg
+        print '  ' + fname + ': netCDF file "' + ncfile +                            \
+          '" does not have variable "' + varname + '" !!!!'
+        quit(-1)
+
+    var1obj = objnc.variables[varname]
+    vardims = var1obj.dimensions
+    Ndimvar = len(vardims)
+
+    vdim = []
+    deacdims = []
+
+# Searcing for time dimension
+    for idd in range(Ndimvar):
+        vdim.append(slice(0,var1obj.shape[idd]))
+        deacdims.append(var1obj.shape[idd])
+        if vardims[idd] == values:
+            dimtid = idd
+
+    dimt = var1obj.shape[dimtid]
+
+    print 'Number of time-steps: ',dimt,' id dimt: ',dimtid
+    deacdims[dimtid] = dimt
+
+    varvals = np.zeros(tuple(deacdims), dtype=np.float)
+
+# Slicing for the deaccumulation
+
+    for it in range(dimt):
+        vals1 = list(vdim)
+        vals2 = list(vdim)
+
+        vals1[dimtid] = it
+        if it > 0:
+            vals2[dimtid] = it - 1
+        else:
+            vals2[dimtid] = it
+
+        var1 = var1obj[tuple(vals1)]
+        var2 = var1obj[tuple(vals2)]
+
+        varvals[tuple(vals1)] = var1-var2
+
+# Creation of the new file
+    objofile = NetCDFFile(ofile, 'w')
+
+# Dimensions
+    fdims = objnc.dimensions
+    for dimn in fdims:
+        dimobj = objnc.dimensions[dimn]
+        if dimobj.isunlimited():
+            print '      ' + fname + ': Unlimited dimension '
+            dimsize = None
+        else:
+            dimsize = len(dimobj)
+
+        newdim = objofile.createDimension(dimn, dimsize)
+
+
+# Variables
+    fvars = objnc.variables
+    for varn in fvars:
+        varobj = objnc.variables[varn]
+        if varn == varname:
+            newvarn = 'deaccum' + varn
+        else:
+            newvarn = varn
+
+        newvar = objofile.createVariable(newvarn, varobj.dtype, varobj.dimensions)
+        for attrn in  varobj.ncattrs():
+            attrval = varobj.getncattr(attrn)
+            newattr = newvar.setncattr(attrn, attrval)
+
+        if varn == varname:
+            newvar[:] = varvals
+        else:
+            newvar[:] = varobj[:]
+
+# Global attributes
+    for attrn in objnc.ncattrs():
+        attrval = objnc.getncattr(attrn)
+        newattr = objofile.setncattr(attrn, attrval)
+    
+    objnc.close()
+
+    objofile.sync()
+    objofile.close()
+
+    print '  ' + fname + ' success written of "' + ofile + '" !!!!!'
+
+    return 
+
+#compute_deaccum('time', 'control/sellonlatbox_PRECIP_dayaccum.nc', 'PRECIP')
+
+def compute_opersvarsfiles(values, varname):
+    """ Function to compute opersvarfiles: operation of variables from different files
+      (OPER1.FILE1_VAR1 OPER2.FILE2_VAR2), operations are going to be secuentially 
+      made
+        values= [dimvons]@[operfilevars]
+          [dimnvons]: [dimo1]|[dimo2]|[...|[dimoN]] '|' seaprated list of names with the 
+            variables which contain the values of the dimensions of the compute variable
+          operfilevars: [oper1]|[file1]|[varN],[...,[operK]|[fileM]|[varN]] ',' separated list of 
+             triplets of [operation], [file], [variable name to use]
+           * [oper]: operations: add,sub,mul,div,pot
+        varname= name to the final variable
+    """
+#    import numpy.ma as ma
+    fname='compute_opersvarsfiles'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print compute_opersvarsfiles.__doc__
+        quit()
+
+    dimovars = values.split('@')[0].split('|')
+    filevars = values.split('@')[1].split(',')
+
+    ofile = 'opersvarsfiles_' + varname + '.nc'
+
+    Nfilevars = len(filevars)
+
+    operation = 'operation: '
+    newunits = '-'
+    opervars = []
+
+    for ifv in range(Nfilevars):
+        opern = filevars[ifv].split('|')[0]
+        filen = filevars[ifv].split('|')[1]
+        varn = filevars[ifv].split('|')[2]
+        opervars.append(varn)
+
+        if not os.path.isfile(filen):
+            print errormsg
+            print '  ' + fname + ' file: "' + filen + '" does not exist !!'
+            quit(-1)
+
+        objnc = NetCDFFile(filen, 'r')
+
+        if not objnc.variables.has_key(varn):
+            print errormsg
+            print '  ' + fname + ': netCDF file "' + ncfile +                        \
+              '" does not have variable "' + varn + '" !!!!'
+            quit(-1)
+
+        varobj = objnc.variables[varn]
+        varvals = varobj[:]
+
+# Creation of the operated variable
+        if ifv == 0:
+            vardims = varobj.dimensions
+            vartype = varobj.dtype
+
+            if opern == 'add' or opern == 'sub':
+                newvarv = np.zeros(tuple(varobj.shape), dtype=np.float)
+            elif opern == 'mul' or opern == 'div' or opern == 'pot':
+                newvarv = np.ones(tuple(varobj.shape), dtype=np.float)
+            else:
+                print errormsg
+                print '  ' + fname + ': operation "' + opern + '" is not ready !!!!'
+                quit(-1)
+
+        if searchInlist(varobj.ncattrs(), '_FillValue'):
+            NOvalue = varobj.getncattr('_FillValue')
+            print warnmsg
+            print '    ' + fname + ': variable with a missing value:',NOvalue
+
+        if opern == 'add':
+            if searchInlist(varobj.ncattrs(), '_FillValue'):
+                prevals = varvals.filled(0.)
+                newvarv = newvarv + prevals
+            else:
+                newvarv = newvarv + varvals
+            operation = operation + ' +' + varn
+            newunits = variables_values(varname)[5]
+        elif opern == 'sub':
+            if searchInlist(varobj.ncattrs(), '_FillValue'):
+                prevals = varvals.filled(0.)
+                newvarv = newvarv - prevals
+            else:
+                newvarv = newvarv - varvals
+            operation = operation + ' -' + varn
+            newunits = variables_values(varname)[5]
+        elif opern == 'mul':
+            if searchInlist(varobj.ncattrs(), '_FillValue'):
+                prevals = varvals.filled(1.)
+                newvarv = newvarv * prevals
+            else:
+                newvarv = newvarv * varvals
+            operation = operation + ' *' + varn
+            newunits = variables_values(varname)[5]
+        elif opern == 'div':
+            if searchInlist(varobj.ncattrs(), '_FillValue'):
+                prevals = varvals.filled(1.)
+                newvarv = newvarv / prevals
+            else:
+                newvarv = newvarv / varvals
+            operation = operation + ' /' + varn
+            newunits = variables_values(varname)[5]
+        elif opern == 'pot':
+            if searchInlist(varobj.ncattrs(), '_FillValue'):
+                prevals = varvals.filled(1.)
+                newvarv = newvarv ** prevals
+            else:
+                newvarv = newvarv ** varvals
+            operation = operation + ' **' + varn
+            newunits = variables_values(varname)[5]
+
+# Creation of the new file
+    objofile = NetCDFFile(ofile, 'w')
+
+# Dimensions
+    for dimn in vardims:
+        dimobj = objnc.dimensions[dimn]
+        if dimobj.isunlimited():
+            print '      ' + fname + ': Unlimited dimension '
+            dimsize = None
+        else:
+            dimsize = len(dimobj)
+
+        newdim = objofile.createDimension(dimn, dimsize)
+
+# Variables for dimensions
+    for varn in dimovars:
+        varobj = objnc.variables[varn]
+        newvar = objofile.createVariable(varn, varobj.dtype, varobj.dimensions)
+        for attrn in  varobj.ncattrs():
+            attrval = varobj.getncattr(attrn)
+            newattr = newvar.setncattr(attrn, attrval)
+        newvar[:] = varobj[:]
+
+    newvar = objofile.createVariable(varname, vartype, vardims)
+    newvar[:] = newvarv
+    newattr = basicvardef(newvar, varname, operation, newunits)
+
+# Global attributes
+    for attrn in objnc.ncattrs():
+        attrval = objnc.getncattr(attrn)
+        newattr = objofile.setncattr(attrn, attrval)
+    
+    objnc.close()
+
+    objofile.sync()
+    objofile.close()
+
+    print '  ' + fname + ' success written of "' + ofile + '" !!!!!'
+
+    return 
+
+#compute_opersvarsfiles('add|control/sellonlatbox_RAINC.nc|RAINC,add|control/sellonlatbox_RAINNC.nc|RAINNC', 'PRECIP')
+
+def compute_opervartimes(values, ncfile, varname):
+    """ Function to compute opervartimes: operation of variable for a given sub-set of time-steps
+      (OPER1.VAR[IT,ET]), operations are going to be secuentially made
+        values= [oper]|[timen]|[intT]
+          dimension
+          [oper]: operations: add,sub,mul,div,pot
+          [timen]: name of the dimension time
+          [intT]: number time-steps to accumulate
+        ncfile= netCDF file to use
+        varname= variable to use
+    """
+    fname='compute_opervartimes'
+
+    ofile = 'opervartimes_' + varname + '.nc'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print opervartimes.__doc__
+        quit()
+
+    if not os.path.isfile(ncfile):
+        print errormsg
+        print '  ' + fname + ' file: "' + ncfile + '" does not exist !!'
+        quit(-1)
+
+    objnc = NetCDFFile(ncfile, 'r')
+
+    if not objnc.variables.has_key(varname):
+        print errormsg
+        print '  ' + fname + ': netCDF file "' + ncfile +                            \
+          '" does not have variable "' + varname + '" !!!!'
+        quit(-1)
+
+    opern = values.split('|')[0]
+    timen = values.split('|')[1]
+    intT = int(values.split('|')[2])
+
+    varobj = objnc.variables[varname]
+    vardims = varobj.dimensions
+    vartype = varobj.dtype
+    Ndims = len(vardims)
+    
+    newdimns = vardims
+    newdims = np.zeros((Ndims), dtype=int)
+    newslice = []
+    newunits = '-'
+    
+    idim = 0
+    for dimn in vardims:
+        if dimn == timen:
+            dimtid = idim
+            newslice.append(0)
+            origdimt = varobj.shape[dimtid]
+            newdims[idim] = len(np.arange(origdimt)[intT/2::intT])
+        else:
+            newdims[idim] = varobj.shape[idim]
+            newslice.append(slice(0,varobj.shape[idim]))
+
+        idim = idim + 1
+    
+    print 'dimtid: ',dimtid
+
+    if opern == 'add' or opern == 'sub':
+        newvarv = np.zeros(tuple(newdims), dtype=np.float)
+    elif opern == 'mul' or opern == 'div' or opern == 'pot':
+        newvarv = np.ones(tuple(newdims), dtype=np.float)
+    else:
+        print errormsg
+        print '  ' + fname + ': operation "' + opern + '" is not ready !!!!'
+        quit(-1)
+
+# Creation of the accumulated operated variable
+    idint = 0
+    itt = 0
+    nint = 0
+
+    for it in range(1,origdimt):
+
+        tslice = list(newslice)
+        tslice[dimtid] = it
+        tnewvar = list(newslice)
+        tnewvar[dimtid] = nint
+
+        if opern == 'add':
+            newvarv[tuple(tnewvar)] = newvarv[tuple(tnewvar)] + varobj[tuple(tslice)]
+            if searchInlist(varobj.ncattrs(), 'units') and newunits != '-':
+                newunits = varobj.getncattr('units')
+        elif opern == 'sub':
+            newvarv[tuple(tnewvar)] = newvarv[tuple(tnewvar)] - varobj[tuple(tslice)]
+            if searchInlist(varobj.ncattrs(), 'units') and newunits != '-':
+                newunits = varobj.getncattr('units')
+        elif opern == 'mul':
+            newvarv[tuple(tnewvar)] = newvarv[tuple(tnewvar)] * varobj[tuple(tslice)]
+        elif opern == 'div':
+            newvarv[tuple(tnewvar)] = newvarv[tuple(tnewvar)] / varobj[tuple(tslice)]
+        elif opern == 'pot':
+            newvarv[tuple(tnewvar)] = newvarv[tuple(tnewvar)] **varobj[tuple(tslice)]
+            
+        it = it + 1
+        itt = itt + 1
+        if itt == intT:
+            nint = nint + 1
+            itt = 0
+
+# Creation of the new file
+    objofile = NetCDFFile(ofile, 'w')
+
+# Dimensions
+    for dimn in newdimns:
+
+        dimobj = objnc.dimensions[dimn]
+        if dimobj.isunlimited():
+            print '      ' + fname + ': Unlimited dimension '
+            dimsize = None
+        else:
+            dimsize = len(dimobj)
+            if dimn == timen:
+                if np.mod(varobj.shape[dimtid],intT) != 0:
+                    dimsize = varobj.shape[dimtid]/intT + 1
+
+        newdim = objofile.createDimension(dimn, dimsize)
+
+    newdim = objofile.createDimension('bnds', 2)
+
+# Variables
+    fvars = objnc.variables
+    for varn in fvars:
+        if varn != varname:
+            varobj = objnc.variables[varn]
+            if varn != timen:    
+                if not searchInlist(varobj.dimensions,timen):
+                    newvar = objofile.createVariable(varn, varobj.dtype,             \
+                      varobj.dimensions)
+                    for attrn in  varobj.ncattrs():
+                        attrval = varobj.getncattr(attrn)
+                        newattr = newvar.setncattr(attrn, attrval)
+                    newvar[:] = varobj[:]
+            else:
+                    newvar = objofile.createVariable(varn, varobj.dtype, ('time'))
+                    basicvardef(newvar, 'time', 'time steps','-')
+                    times = np.arange(origdimt)[intT/2::intT]
+                    newvar[:] = times
+                    newdimt = newvar.shape[0]
+                    newattr = newvar.setncattr('bounds','time_bnds')
+
+    newvar = objofile.createVariable('time_bnds', 'i4', ('time', 'bnds'))
+    basicvardef(newvar, 'time_bnds', 'time steps bnds of accumulation','-')
+    for it in range(newdimt):
+        newvar[it,0] = (it - 1)*intT
+        newvar[it,1] = (it)*intT-1
+
+    newvar = objofile.createVariable('ac' + varname, vartype, vardims)
+    newvar[:] = newvarv
+    newattr = basicvardef(newvar, 'ac' + varname, 'accumulated ' + opern +           \
+      ' values' , newunits)
+
+# Global attributes
+    for attrn in objnc.ncattrs():
+        attrval = objnc.getncattr(attrn)
+        newattr = objofile.setncattr(attrn, attrval)
+    
+    objnc.close()
+
+    objofile.sync()
+    objofile.close()
+
+    print '  ' + fname + ' success written of "' + ofile + '" !!!!!'
+
+    return 
+
+#compute_opervartimes('add|time|24', 'obs/PRCP.nc', 'product')
+#
+
+def compute_opervaralltime(values, ncfile, varname):
+    """ Function to compute opervaralltime: operation of variable successible allover the time-steps
+      (OPER1.VAR), operations are going to be secuentially made
+        values= [oper]|[timen]
+          dimension
+          [oper]: operations: add,sub,mul,div,pot
+          [timen]: name of the dimension time
+        ncfile= netCDF file to use
+        varname= variable to use
+    """
+    fname='compute_opervarlltime'
+
+    ofile = 'opervaralltime_' + varname + '.nc'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print compute_opervaralltime.__doc__
+        quit()
+
+    if not os.path.isfile(ncfile):
+        print errormsg
+        print '  ' + fname + ' file: "' + ncfile + '" does not exist !!'
+        quit(-1)
+
+    objnc = NetCDFFile(ncfile, 'r')
+
+    if not objnc.variables.has_key(varname):
+        print errormsg
+        print '  ' + fname + ': netCDF file "' + ncfile +                            \
+          '" does not have variable "' + varname + '" !!!!'
+        quit(-1)
+
+    opern = values.split('|')[0]
+    timen = values.split('|')[1]
+
+    varobj = objnc.variables[varname]
+    vardims = varobj.dimensions
+    vartype = varobj.dtype
+    Ndims = len(vardims)
+    
+    newdimns = vardims
+    newdims = np.zeros((Ndims), dtype=int)
+    newslice = []
+    prevslice = []
+    newunits = '-'
+    
+    idim = 0
+    for dimn in vardims:
+        if dimn == timen:
+            dimtid = idim
+            newslice.append(0)
+            origdimt = varobj.shape[dimtid]
+            newdims[idim] = origdimt
+        else:
+            newdims[idim] = varobj.shape[idim]
+            newslice.append(slice(0,varobj.shape[idim]))
+
+        idim = idim + 1
+    
+    print 'dimtid: ',dimtid
+
+    if opern == 'add' or opern == 'sub':
+        newvarv = np.zeros(tuple(newdims), dtype=np.float)
+    elif opern == 'mul' or opern == 'div' or opern == 'pot':
+        newvarv = np.ones(tuple(newdims), dtype=np.float)
+    else:
+        print errormsg
+        print '  ' + fname + ': operation "' + opern + '" is not ready !!!!'
+        quit(-1)
+
+# Creation of the accumulated operated variable
+    idint = 0
+
+    for it in range(1,origdimt):
+
+        tslice = list(newslice)
+        tslice[dimtid] = it
+        prevslice = list(newslice)
+        prevslice[dimtid] = it - 1
+
+        if opern == 'add':
+            newvarv[tuple(tslice)] = newvarv[tuple(prevslice)] + varobj[tuple(tslice)]
+            if searchInlist(varobj.ncattrs(), 'units') and newunits != '-':
+                newunits = varobj.getncattr('units')
+        elif opern == 'sub':
+            newvarv[tuple(tslice)] = newvarv[tuple(prevslice)] - varobj[tuple(tslice)]
+            if searchInlist(varobj.ncattrs(), 'units') and newunits != '-':
+                newunits = varobj.getncattr('units')
+        elif opern == 'mul':
+            newvarv[tuple(tslice)] = newvarv[tuple(prevslice)] * varobj[tuple(tslice)]
+        elif opern == 'div':
+            newvarv[tuple(tslice)] = newvarv[tuple(prevslice)] / varobj[tuple(tslice)]
+        elif opern == 'pot':
+            newvarv[tuple(tslice)] = newvarv[tuple(prevslice)] **varobj[tuple(tslice)]
+        
+        it = it + 1
+
+# Creation of the new file
+    objofile = NetCDFFile(ofile, 'w')
+
+# Dimensions
+    for dimn in newdimns:
+
+        dimobj = objnc.dimensions[dimn]
+        if dimobj.isunlimited():
+            print '      ' + fname + ': Unlimited dimension '
+            dimsize = None
+        else:
+            dimsize = len(dimobj)
+
+        newdim = objofile.createDimension(dimn, dimsize)
+
+    newdim = objofile.createDimension('bnds', 2)
+
+# Variables
+    fvars = objnc.variables
+    for varn in fvars:
+        if varn != varname:
+            varobj = objnc.variables[varn]
+            if varn != timen:    
+                if not searchInlist(varobj.dimensions,timen):
+                    newvar = objofile.createVariable(varn, varobj.dtype,             \
+                      varobj.dimensions)
+                    for attrn in  varobj.ncattrs():
+                        attrval = varobj.getncattr(attrn)
+                        newattr = newvar.setncattr(attrn, attrval)
+                    newvar[:] = varobj[:]
+            else:
+                    newvar = objofile.createVariable(varn, varobj.dtype, ('time'))
+                    basicvardef(newvar, 'time', 'time steps','-')
+                    timevals = varobj[:]
+                    newvar[:] = timevals
+                    newdimt = newvar.shape[0]
+                    newattr = newvar.setncattr('bounds','time_bnds')
+
+    newvar = objofile.createVariable('time_bnds', 'i4', ('bnds'))
+    basicvardef(newvar, 'time_bnds', 'time steps bnds of accumulation','-')
+    newvar[0] = timevals[0]
+    newvar[1] = timevals[origdimt-1]
+
+    newvar = objofile.createVariable('ac' + varname, vartype, vardims)
+    newvar[:] = newvarv
+    newattr = basicvardef(newvar, 'ac' + varname, 'accumulated ' + opern +           \
+      ' values' , newunits)
+
+# Global attributes
+    for attrn in objnc.ncattrs():
+        attrval = objnc.getncattr(attrn)
+        newattr = objofile.setncattr(attrn, attrval)
+    
+    objnc.close()
+
+    objofile.sync()
+    objofile.close()
+
+    print '  ' + fname + ' success written of "' + ofile + '" !!!!!'
+
+    return 
+
+#compute_opervaralltime('add|time', 'obs/PRCP.nc', 'product')
+
+def retype(val, vtype):
+    """ Function to transform a value to a given type
+    retype(val, vtype)
+      [val]= value
+      [vtype]= type to transform
+    >>> retype(0, type(True))
+    False
+    """
+
+    fname = 'retype'
+
+    if val == 'h':
+        print fname + '_____________________________________________________________'
+        print retype.__doc__
+        quit()
+
+    if vtype == type(int(1)):
+        newval = int(val)
+    elif vtype == type(float(1)):
+        newval = float(val)
+#    elif vtype == type(float32(1)):
+#        newval = float32(val)
+    elif vtype == type(np.int(1)):
+        newval = np.int(val)
+    elif vtype == type(np.int16(1)):
+        newval = np.int16(val)
+    elif vtype == type(np.int32(1)):
+        newval = np.int32(val)
+    elif vtype == type(np.int64(1)):
+        newval = np.int64(val)
+    elif vtype == type(np.float(1)):
+        newval = np.float(val)
+    elif vtype == type(np.float16(1)):
+        newval = np.float16(val)
+    elif vtype == type(np.float32(1)):
+        newval = np.float32(val)
+    elif vtype == type(np.float64(1)):
+        newval = np.float64(val)
+    elif vtype == type(True):
+        if val == 0:
+            newval = False
+        else:
+            newval = True
+    else:
+        print errormsg
+        print '  ' + fname + ': variable type "', vtype, '" not ready!!!'
+        quit(-1)
+
+    return newval
+
+def setvar_asciivalues(values, ncfile, varname):
+    """ Function to set de values of a variable with an ASCII file (common 
+          Fortran-like format)
+        values= asciifile: ASCII file with a Fortran-like structure
+          [dim1]_1 [[dim2]_1 ... [dim2]_M]
+          ...
+          [dim1]_N
+        ncfile= netCDF file to use
+        varname= variable to use
+    """
+    fname='setvar_asciivalues'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print setvar_asciivalues.__doc__
+        quit()
+
+    if not os.path.isfile(ncfile):
+        print errormsg
+        print '  ' + fname + ' file: "' + ncfile + '" does not exist !!'
+        quit(-1)
+
+    if not os.path.isfile(values):
+        print errormsg
+        print '  ' + fname + ' ASCII file: "' + values + '" does not exist !!'
+        quit(-1)
+
+    objnc = NetCDFFile(ncfile, 'a')
+
+    if not objnc.variables.has_key(varname):
+        print errormsg
+        print '  ' + fname + ': netCDF file "' + ncfile +                            \
+          '" does not have variable "' + varname + '" !!!!'
+        quit(-1)
+
+    objvar = objnc.variables[varname]
+
+    vardims = objvar.shape
+    vartype = objvar.dtype
+    Ndims = len(vardims)
+
+    objasciif = open(values, 'r')
+    values = np.zeros((objvar.shape), dtype=vartype)
+
+    valfinal = np.zeros((1), dtype=vartype)
+
+    it = 0
+    if Ndims == 1:
+        for line in objasciif:
+            val = (line.replace('\n','').replace(' ','').replace('\t',''))
+            valfinal[0] = retype(val, vartype)
+            if it <= values.shape[0]-1:
+                values[it] = retype(valfinal[0], vartype)
+                it = it +1
+
+    else:
+        print errormsg
+        print '  ' + fname + ': number of dimensions',Ndims,'not ready !!!!'
+        quit(-1)
+
+    objasciif.close()
+    objvar[:] = values
+
+    objnc.sync()
+    objnc.close()
+
+#setvar_asciivalues('obstimes.inf', 'obs/re_project_accumulated-1h_PRCP.nc', 'time')
+
+class stats_space2D(object):
+    """spatial statistics for a 2D file:
+      vals= variable ro check (assuming var[t,dy,dx])
+        self.minv[t]: spatial minimum at each time-step
+        self.maxv[t]: spatial maximum at each time-step
+        self.meanv[t]: spatial mean at each time-step
+        self.mean2v[t]: spatial quadratic mean at each time-step
+        self.stdv[t]: spatial standard deviation at each time-step
+        self.anomv[t]: spatial anomaly from the whole mean at each time-step
+    """
+  
+    def __init__(self, vals):
+        from scipy import stats as sts
+        fname = 'stats_space2D'
+
+        if vals1 == 'h':
+            print fname + '_____________________________________________________________'
+            print stats_space2Dvars.__doc__
+            quit()
+
+        if vals1 is None:
+            self.minv = None
+            self.maxv = None
+            self.meanv = None
+            self.mean2v = None
+            self.stdv = None
+        else:
+            dimt = vals.shape[0]
+            stats=np.zeros((dimt,5), dtype=np.float)
+            absmean = np.mean(vals)
+
+            for it in range(dimt):
+                stats[it,0]=np.min(vals[it,:,:])
+                stats[it,1]=np.max(vals[it,:,:])
+                stats[it,2]=np.mean(vals[it,:,:])
+                stats[it,3]=np.mean(vals[it,:,:]*vals[it,:,:])
+                stats[it,4]=absmean - stats[it,2]
+
+            stats = np.where(stats > 0.1*fillValue, fillValue, stats)
+            stats = np.where(stats is nan, fillValue, stats)
+            stats = np.where(stats is np.inf, fillValue, stats)
+            stats = np.where(stats is None, fillValue, stats)
+
+            self.minv=stats[:,0]
+            self.maxv=stats[:,1]
+            self.meanv=stats[:,2]
+            self.mean2v=stats[:,3]
+            self.stdv=np.sqrt(stats[:,3]-stats[:,2]*stats[:,2])
+            self.anomv=stats[:,4]
+
+class stats_space2Dvars(object):
+    """spatial statistics beween 2 2D files:
+    valsA = variable 1 (assuming var[t,dy,dx])
+    valsB = variable 2 (assuming var[t,dy,dx])
+    self.min[t,var], self.max[t,var], self.mean[t,var], self.mean2[t,var], 
+      self.std[t,var]
+      [var] = var1+var2[v1Av2], var1-var2[v1Sv2], var1/var2[v1Dv2], var1*var2[v1Pv2]
+
+    self.mae=mean[t,abs(var1-var2)]
+    self.correlation=correlation[var1,var2] (and p-value) 
+    self.bias=[t,mean(var1)-mean(var2)]
+    self.meancorrelation=correlation[mean(var1),mean(var2)] (and p-value) 
+    """
+
+    def __init__(self, vals1, vals2):
+        from scipy import stats as sts
+        fname = 'stats_space2Dvars'
+
+        if vals1 == 'h':
+            print fname + '_____________________________________________________________'
+            print stats_space2Dvars.__doc__
+            quit()
+
+        if vals1 is None:
+            self.minv1Av2 = None
+            self.maxv1Av2 = None
+            self.meanv1Av2 = None
+            self.mean2v1Av2 = None
+            self.stdv1Av2 = None
+            self.minv1Sv2 = None
+            self.maxv1Sv2 = None
+            self.meanv1Sv2 = None
+            self.mean2v1Sv2 = None
+            self.stdv1Sv2 = None
+            self.minv1Dv2 = None
+            self.maxv1Dv2 = None
+            self.meanv1Dv2 = None
+            self.mean2v1Dv2 = None
+            self.stdv1Dv2 = None
+            self.minv1Pv2 = None
+            self.maxv1Pv2 = None
+            self.meanv1Pv2 = None
+            self.mean2v1Pv2 = None
+            self.stdv1Pv2 = None
+            self.mae = None
+            self.corr = None
+        else:
+            dimt = vals1.shape[0]
+            stats=np.zeros((dimt,26), dtype=np.float)
+            meanvals1 = np.zeros((dimt), dtype=np.float)
+            meanvals2 = np.zeros((dimt), dtype=np.float)
+    
+            for it in range(dimt):
+                v1 = vals1[it,:,:].flatten() 
+                v2 = vals2[it,:,:].flatten() 
+
+# add
+                vs = v1 + v2
+                stats[it,0] = np.min(vs)
+                stats[it,1] = np.max(vs)
+                stats[it,2] = np.mean(vs)
+                stats[it,3] = np.mean(vs*vs)
+                stats[it,4] = np.sqrt(stats[it,3] - stats[it,2]*stats[it,2])
+# sub
+                stats[it,20] = np.mean(np.abs(v1-v2))
+                vs = v1 - v2
+                stats[it,5] = np.min(vs)
+                stats[it,6] = np.max(vs)
+                stats[it,7] = np.mean(vs)
+                stats[it,8] = np.mean(vs*vs)
+                stats[it,9] = np.sqrt(stats[it,8] - stats[it,7]*stats[it,7])
+
+# mul
+                vs = v1 * v2
+                stats[it,10] = np.min(vs)
+                stats[it,11] = np.max(vs)
+                stats[it,12] = np.mean(vs)
+                stats[it,13] = np.mean(vs*vs)
+                stats[it,14] = np.sqrt(stats[it,13] - stats[it,12]*stats[it,12])
+# div
+                vs = v1 / v2
+                stats[it,15] = np.min(vs)
+                stats[it,16] = np.max(vs)
+                stats[it,17] = np.mean(vs)
+                stats[it,18] = np.mean(vs*vs)
+                stats[it,19] = np.sqrt(stats[it,18] - stats[it,17]*stats[it,17])
+# corr
+                stats[it,21], stats[it,22] = mask_pearsonr(v1, v2)
+
+# Mean values
+                meanvals1[it] = np.mean(v1)
+                meanvals2[it] = np.mean(v2)
+                stats[it,23] =  meanvals1[it] - meanvals2[it]
+            
+            stats = np.where(stats > 0.1*fillValue, fillValue, stats)
+            stats = np.where(stats is np.nan, fillValue, stats)
+            stats = np.where(stats is np.inf, fillValue, stats)
+            stats = np.where(stats is None, fillValue, stats)
+
+            self.minv1Av2 = stats[:,0]
+            self.maxv1Av2 = stats[:,1]
+            self.meanv1Av2 = stats[:,2]
+            self.meanv21Av2 = stats[:,3]
+            self.stdv1Av2 = stats[:,4]
+
+            self.minv1Sv2 = stats[:,5]
+            self.maxv1Sv2 = stats[:,6]
+            self.meanv1Sv2 = stats[:,7]
+            self.meanv21Sv2 = stats[:,8]
+            self.stdv1Sv2 = stats[:,9]
+
+            self.minv1Pv2 = stats[:,10]
+            self.maxv1Pv2 = stats[:,11]
+            self.meanv1Pv2 = stats[:,12]
+            self.meanv21Pv2 = stats[:,13]
+            self.stdv1Pv2 = stats[:,14]
+
+            self.minv1Dv2 = stats[:,15]
+            self.maxv1Dv2 = stats[:,16]
+            self.meanv1Dv2 = stats[:,17]
+            self.meanv21Dv2 = stats[:,18]
+            self.stdv1Dv2 = stats[:,19]
+
+            self.mae = stats[:,20]
+            self.corr = stats[:,21]
+            self.p_value = stats[:,22]
+
+            self.bias = stats[:,23]
+            self.meancorr, self.meanp_value = sts.pearsonr(meanvals1, meanvals2)
+
+class stats_time2D(object):
+    """temporal statistics for a 2D file:
+      vals= variable ro check (assuming var[t,dy,dx])
+        self.minv[t]: temporal minimum at each grid point
+        self.maxv[t]: temporal maximum at each grid point
+        self.meanv[t]: temporal mean at each grid point
+        self.mean2v[t]: temporal quadratic mean at each grid point
+        self.stdv[t]: temporal standard deviation at each grid point
+        self.anomv[t]: temporal anomaly from the whole mean at each grid point
+    """
+  
+    def __init__(self, vals):
+        from scipy import stats as sts
+        fname = 'stats_time2D'
+
+        if vals1 == 'h':
+            print fname + '_____________________________________________________________'
+            print stats_time2Dvars.__doc__
+            quit()
+
+        if vals1 is None:
+            self.minv = None
+            self.maxv = None
+            self.meanv = None
+            self.mean2v = None
+            self.stdv = None
+        else:
+            dimx = vals.shape[2]
+            dimy = vals.shape[1]
+            stats=np.zeros((dimy,dimx,5), dtype=np.float)
+            absmean = np.mean(vals,axis=0)
+
+            stats[:,:,0]=np.min(vals, axis=0)
+            stats[:,:,1]=np.max(vals, axis=0)
+            stats[:,:,2]=np.mean(vals, axis=0)
+            stats[:,:,3]=np.mean(vals*vals, axis=0)
+            stats[:,:,4]=absmean - stats[:,:,2]
+
+            stats = np.where(stats > 0.1*fillValue, fillValue, stats)
+            stats = np.where(stats is np.nan, fillValue, stats)
+            stats = np.where(stats is np.inf, fillValue, stats)
+            stats = np.where(stats is None, fillValue, stats)
+
+            self.minv=stats[:,:,0]
+            self.maxv=stats[:,:,1]
+            self.meanv=stats[:,:,2]
+            self.mean2v=stats[:,:,3]
+            self.stdv=np.sqrt(stats[:,:,3]-stats[:,:,2]*stats[:,:,2])
+            self.anomv=stats[:,:,4]
+
+class stats_time2Dvars(object):
+    """temporal statistics beween 2 2D files:
+    valsA = variable 1 (assuming var[t,dy,dx])
+    valsB = variable 2 (assuming var[t,dy,dx])
+    self.min[dy,dx,var], self.max[dy,dx,var], self.mean[dy,dx,var], 
+      self.mean2[dy,dx,var], self.std[dy,dx,var]
+      [var] = var1+var2[v1Av2], var1-var2[v1Sv2], var1/var2[v1Dv2], var1*var2[v1Pv2]
+
+    self.mae=mean[dy,dx,abs(var1-var2)]
+    self.correlation=correlation[var1,var2] (and p-value) 
+    self.bias=[dy,dx,mean(var1)-mean(var2)]
+    self.meancorrelation=correlation[mean(var1),mean(var2)] (and p-value) 
+    """
+
+    def __init__(self, vals1, vals2):
+        from scipy import stats as sts
+        fname = 'stats_time2Dvars'
+
+        if vals1 == 'h':
+            print fname + '_____________________________________________________________'
+            print stats_time2Dvars.__doc__
+            quit()
+
+        if vals1 is None:
+            self.minv1Av2 = None
+            self.maxv1Av2 = None
+            self.meanv1Av2 = None
+            self.mean2v1Av2 = None
+            self.stdv1Av2 = None
+            self.minv1Sv2 = None
+            self.maxv1Sv2 = None
+            self.meanv1Sv2 = None
+            self.mean2v1Sv2 = None
+            self.stdv1Sv2 = None
+            self.minv1Dv2 = None
+            self.maxv1Dv2 = None
+            self.meanv1Dv2 = None
+            self.mean2v1Dv2 = None
+            self.stdv1Dv2 = None
+            self.minv1Pv2 = None
+            self.maxv1Pv2 = None
+            self.meanv1Pv2 = None
+            self.mean2v1Pv2 = None
+            self.stdv1Pv2 = None
+            self.mae = None
+            self.corr = None
+        else:
+            dimx = vals1.shape[1]
+            dimy = vals1.shape[1]
+            stats=np.zeros((dimy,dimx,24), dtype=np.float)
+            meanvals1 = np.zeros((dimy,dimx), dtype=np.float)
+            meanvals2 = np.zeros((dimy,dimx), dtype=np.float)
+# add
+            vs = vals1 + vals2
+            stats[:,:,0] = np.min(vs,axis=0)
+            stats[:,:,1] = np.max(vs,axis=0)
+            stats[:,:,2] = np.mean(vs,axis=0)
+            stats[:,:,3] = np.mean(vs*vs,axis=0)
+            stats[:,:,4] = np.sqrt(stats[:,:,3] - stats[:,:,2]*stats[:,:,2])
+# sub
+            stats[:,:,20] = np.mean(np.abs(vals1-vals2), axis=0)
+            vs = vals1 - vals2
+            stats[:,:,5] = np.min(vs,axis=0)
+            stats[:,:,6] = np.max(vs,axis=0)
+            stats[:,:,7] = np.mean(vs,axis=0)
+            stats[:,:,8] = np.mean(vs*vs,axis=0)
+            stats[:,:,9] = np.sqrt(stats[:,:,8] - stats[:,:,7]*stats[:,:,7])
+# mul
+            vs = vals1 * vals2
+            stats[:,:,10] = np.min(vs,axis=0)
+            stats[:,:,11] = np.max(vs,axis=0)
+            stats[:,:,12] = np.mean(vs,axis=0)
+            stats[:,:,13] = np.mean(vs*vs,axis=0)
+            stats[:,:,14] = np.sqrt(stats[:,:,13] - stats[:,:,12]*stats[:,:,12])
+# div
+            vs = vals1 / vals2
+            stats[:,:,15] = np.min(vs,axis=0)
+            stats[:,:,16] = np.max(vs,axis=0)
+            stats[:,:,17] = np.mean(vs,axis=0)
+            stats[:,:,18] = np.mean(vs*vs,axis=0)
+            stats[:,:,19] = np.sqrt(stats[:,:,18] - stats[:,:,17]*stats[:,:,17])
+
+
+# Mean values
+            meanvals1[:,:] = np.mean(vals1,axis=0)
+            meanvals2[:,:] = np.mean(vals2,axis=0)
+            stats[:,:,23] =  meanvals1[:,:] - meanvals2[:,:]
+            
+# corr
+            self.meancorr, self.meanp_value = sts.pearsonr(meanvals1.flatten(), meanvals2.flatten())
+
+            for j in range(dimy):
+                for i in range(dimx):
+                    stats[j,i,21], stats[j,i,22] = sts.pearsonr(vals1[:,j,i], vals2[:,j,i])
+
+            stats = np.where(stats > 0.1*fillValue, fillValue, stats)
+            stats = np.where(stats is np.nan, fillValue, stats)
+            stats = np.where(stats is np.inf, fillValue, stats)
+            stats = np.where(stats is None, fillValue, stats)
+
+            self.minv1Av2 = stats[:,:,0]
+            self.maxv1Av2 = stats[:,:,1]
+            self.meanv1Av2 = stats[:,:,2]
+            self.meanv21Av2 = stats[:,:,3]
+            self.stdv1Av2 = stats[:,:,4]
+
+            self.minv1Sv2 = stats[:,:,5]
+            self.maxv1Sv2 = stats[:,:,6]
+            self.meanv1Sv2 = stats[:,:,7]
+            self.meanv21Sv2 = stats[:,:,8]
+            self.stdv1Sv2 = stats[:,:,9]
+
+            self.minv1Pv2 = stats[:,:,10]
+            self.maxv1Pv2 = stats[:,:,11]
+            self.meanv1Pv2 = stats[:,:,12]
+            self.meanv21Pv2 = stats[:,:,13]
+            self.stdv1Pv2 = stats[:,:,14]
+
+            self.minv1Dv2 = stats[:,:,15]
+            self.maxv1Dv2 = stats[:,:,16]
+            self.meanv1Dv2 = stats[:,:,17]
+            self.meanv21Dv2 = stats[:,:,18]
+            self.stdv1Dv2 = stats[:,:,19]
+
+            self.mae = stats[:,:,20]
+            self.corr = stats[:,:,21]
+            self.p_value = stats[:,:,22]
+
+            self.bias = stats[:,:,23]
+
+#vals1 = np.arange(27).reshape(3,3,3)*1.
+#vals2 = np.arange(1,28).reshape(3,3,3)*1.
+
+#printing_class(stats_time2Dvars(vals1,vals2))
+
+def statcompare_files(values):
+    """ Python script to statistically compare two different files
+      values= [file1]:[var1],[file2][var2] 
+        [file1/2]: files to compare any diferent would be [file1]-[file2]
+        [var1/2]: variable in file1/2 to compare
+    """
+
+    fname = 'statcompare_files'
+    ofile='statcompare_files.nc'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print statcompare_files.__doc__
+        quit()
+
+    file1=values.split(',')[0].split(':')[0]
+    var1=values.split(',')[0].split(':')[1]
+    file2=values.split(',')[1].split(':')[0]
+    var2=values.split(',')[1].split(':')[1]
+
+    if not os.path.isfile(file1):
+        print errormsg
+        print '  ' + fname + ' file: "' + file1 + '" does not exist !!'
+        quit(-1)
+
+    objnc1 = NetCDFFile(file1, 'r')
+
+    if not objnc1.variables.has_key(var1):
+        print errormsg
+        print '  ' + fname + ': netCDF file "' + file1 +                            \
+          '" does not have variable "' + var1 + '" !!!!'
+        quit(-1)
+
+    if not os.path.isfile(file2):
+        print errormsg
+        print '  ' + fname + ' file: "' + file2 + '" does not exist !!'
+        quit(-1)
+
+    objnc2 = NetCDFFile(file2, 'r')
+
+    if not objnc2.variables.has_key(var2):
+        print errormsg
+        print '  ' + fname + ': netCDF file "' + file2 +                            \
+          '" does not have variable "' + var2 + '" !!!!'
+        quit(-1)
+
+    objvar1 = objnc1.variables[var1]
+    objvar2 = objnc2.variables[var2]
+
+    Ndim1 = len(objvar1.shape)
+    Ndim2 = len(objvar2.shape)
+
+    if Ndim1 != Ndim2:
+        print errormsg
+        print '  ' + fname + ' variable: "' + var1 + '" from file "' + file1 +       \
+          '" does not have the same size:' , Ndim1, 'as variable: "' + var2 +        \
+          '" from file "' + file2 + '": ',Ndim2
+        quit(-1)
+    
+    dims1 = objvar1.shape
+    dims2 = objvar2.shape
+
+    for iid in range(Ndim1):
+        if dims1[iid] != dims2[iid]:
+            print errormsg
+            print '  ' + fname + ' shape:',iid,'is different between variables!!!'
+            print '    dim_var1:', dims1[iid], 'dim_var2:', dims2[iid]
+            print '    var1 shape:', dims1
+            print '    var2 shape:', dims2
+            quit(-1)
+
+    varvals1 = objvar1[:]
+    varvals2 = objvar2[:]
+
+    if Ndim1 == 3:
+        timecompare = stats_time2Dvars(varvals1,varvals2)
+        spacecompare = stats_space2Dvars(varvals1,varvals2)
+
+        dimt = varvals1.shape[0]
+        dimy = varvals1.shape[1]
+        dimx = varvals1.shape[2]
+
+#        print 'bias std.dev. ___________________________________'
+#        for it in range(dimt):
+#            print it,':',spacecompare.bias[it],spacecompare.stdv1Sv2[it]
+#        print 'global spatial correlation (% significance)______'
+#        for it in range(dimt):
+#            print it, ':', spacecompare.corr[it], '(',                               \
+#              (1.-spacecompare.p_value[it])*100.,')'
+#        print 'spatial means temporal correlation:',spacecompare.meancorr,'(',       \
+#          (1.-spacecompare.meanp_value)*100.,' % significance)'
+#        print 'temporal means temporal correlation:',timecompare.meancorr,'(',       \
+#          (1.-timecompare.meanp_value)*100.,' % significance)'
+
+#        print 'temporal bias map________________________________'
+#        print timecompare.meanv1Sv2
+
+#        print 'temporal correlation map_________________________'
+#        print timeecompare.corr
+
+    else:
+        print errormsg
+        print '  ' + fname + ' numbe of dimensions:' + Ndim1 + ' not ready!!!'
+        quit(-1)
+
+# Creation of results file
+##
+    objofile = NetCDFFile(ofile, 'w')
+
+# Dimensions
+    for dimn in objnc1.dimensions:
+        dimobj = objnc1.dimensions[dimn]
+        if dimobj.isunlimited():
+            print '      ' + fname + ': Unlimited dimension '
+            dimsize = None
+        else:
+            dimsize = len(dimobj)
+
+        newdim = objofile.createDimension(dimn, dimsize)
+
+# Variables
+    fvars = objnc1.variables
+    for varn in fvars:
+        if varn != var1:
+            varobj = objnc1.variables[varn]
+            if varn != var1:    
+                newvar = objofile.createVariable(varn, varobj.dtype,                 \
+                  varobj.dimensions)
+                for attrn in  varobj.ncattrs():
+                    attrval = varobj.getncattr(attrn)
+                    newattr = newvar.setncattr(attrn, attrval)
+                newvar[:] = varobj[:]
+
+# Statistical variables
+    vartype = objvar1.dtype
+    varunits = objvar2.getncattr('units')
+
+    print 'vartype=',vartype
+
+# temporal bias
+    newvar = objofile.createVariable('t_bias_'+var1+'_'+var2, vartype, ('y', 'x'),   \
+      fill_value = fillValue)
+    newvar[:] = timecompare.bias
+    newattr = basicvardef(newvar, 't_bias_'+var1+'_'+var2, 'temporal bias between ' +\
+      var1 + '&' + var2, varunits)
+
+# temporal Standard deviation
+    newvar = objofile.createVariable('t_stddev_'+var1+'_'+var2, vartype, ('y', 'x'), \
+      fill_value = fillValue)
+    newvar[:] = timecompare.stdv1Sv2
+    newattr = basicvardef(newvar, 't_stddev_'+var1+'_'+var2,                         \
+      'temporal standard deviation between '+ var1 + '&' + var2, varunits)
+
+# space bias
+    newvar = objofile.createVariable('s_bias_'+var1+'_'+var2, vartype, ('time'),     \
+      fill_value = fillValue)
+    newvar[:] = spacecompare.bias
+    newattr = basicvardef(newvar, 's_bias_'+var1+'_'+var2, 'spatial bias between ' + \
+      var1 + '&' + var2, varunits)
+
+# space Standard deviation
+    newvar = objofile.createVariable('s_stddev_'+var1+'_'+var2, vartype, ('time'),   \
+      fill_value = fillValue)
+    newvar[:] = spacecompare.stdv1Sv2
+    newattr = basicvardef(newvar, 's_stddev_'+var1+'_'+var2,                         \
+      'spatial standard deviation between '+ var1 + '&' + var2, varunits)
+
+# t Correlation map
+    newvar = objofile.createVariable('t_corr_'+var1+'_'+var2, vartype, ('y','x'),    \
+      fill_value = fillValue)
+    newvar[:] = timecompare.corr
+    newattr = basicvardef(newvar, 't_corr_'+var1+'_'+var2,                           \
+      'temporal correlation between ' +  var1 + '&' + var2, '-')
+    newattr = newvar.setncattr('projection', 'lon lat')
+
+# t p-value map
+    newvar = objofile.createVariable('t_p_value_'+var1+'_'+var2, vartype, ('y','x'), \
+      fill_value = fillValue)
+    newvar[:] = timecompare.p_value
+    newattr = basicvardef(newvar, 't_p_value_'+var1+'_'+var2,                        \
+      'temporal p_value between ' + var1 + '&' + var2, '-')
+    newattr = newvar.setncattr('projection', 'lon lat')
+
+# s Correlation map
+    newvar = objofile.createVariable('s_corr_'+var1+'_'+var2, vartype, ('time'),     \
+      fill_value = fillValue)
+    newvar[:] = spacecompare.corr
+    newattr = basicvardef(newvar, 's_corr_'+var1+'_'+var2,                           \
+      'spatial correlation between ' +  var1 + '&' + var2, '-')
+
+# s p-value map
+    newvar = objofile.createVariable('s_p_value_'+var1+'_'+var2, vartype, ('time'),  \
+      fill_value = fillValue)
+    newvar[:] = spacecompare.p_value
+    newattr = basicvardef(newvar, 's_p_value_'+var1+'_'+var2,                        \
+      'spatial p_value between ' + var1 + '&' + var2, '-')
+
+#        print 'spatial means temporal correlation:',spacecompare.meancorr,'(',       \
+#          (1.-spacecompare.meanp_value)*100.,' % significance)'
+
+# t mean Correlation
+    newvar = objofile.createVariable('t_mean_corr_'+var1+'_'+var2, 'f4')
+    newvar[:] = timecompare.meancorr
+    newattr = basicvardef(newvar, 't_mean_corr_'+var1+'_'+var2,                      \
+      'time mean values correlation between ' +  var1 + '&' + var2, '-')
+
+# t mean p-value
+    newvar = objofile.createVariable('t_mean_p_value_'+var1+'_'+var2, 'f4')
+    newvar[:] = timecompare.meanp_value
+    newattr = basicvardef(newvar, 't_mean_p_value_'+var1+'_'+var2,                   \
+      'time mean p_value between ' + var1 + '&' + var2, '-')
+
+# s mean Correlation
+    newvar = objofile.createVariable('s_mean_corr_'+var1+'_'+var2, 'f4')
+    newvar[:] = spacecompare.meancorr
+    newattr = basicvardef(newvar, 's_mean_corr_'+var1+'_'+var2,                      \
+      'space mean values correlation between ' +  var1 + '&' + var2, '-')
+
+# s mean p-value
+    newvar = objofile.createVariable('s_mean_p_value_'+var1+'_'+var2, 'f4')
+    newvar[:] = spacecompare.meanp_value
+    newattr = basicvardef(newvar, 's_mean_p_value_'+var1+'_'+var2,                   \
+      'space mean p_value between ' + var1 + '&' + var2, '-')
+
+# Global attributes
+    for attrn in objnc1.ncattrs():
+        attrval = objnc1.getncattr(attrn)
+        newattr = objofile.setncattr(attrn, attrval)
+
+    newattr = objofile.setncattr('statisitcs', 'variables retrieved from files ' +   \
+      file1 + ' & ' + file2)
+    
+    objnc1.close()
+    objnc2.close()
+
+    objofile.sync()
+    objofile.close()
+
+    varsfillvalue = ['t_bias_', 't_stddev_', 's_bias_', 's_stddev_', 't_corr_',      \
+      't_p_value', 's_corr_', 's_p_value']
+
+#    for varn in varsfillvalue:
+#        print varn
+#        fill = varaddattrk('_FillValue|'+ str(fillValue) + '|R32', ofile,          \
+#          varn+var1+'_'+var2)
+
+    print '  ' + fname + ': successfull generation of file "' + ofile + '" !!!!!'
+
+    return 
+
+#statcompare_files('control/sellonlatbox_wss_17-20.nc:wss,obs/re_project_Vu_17-20.nc:wss')
+
+
+def sellonlatlevbox(values, ncfile, varn):
+    """ Function to select a lotlan box and a given level from a data-set
+      values= [lonName],[latName],[lonSW],[latSW],[lonNE],[latNE],[levi],[levf]
+        [lonName]: name of the variable with the longitudes
+        [latName]: name of the variable with the latitudes 
+        [levName]: name of the variable with the value of the levels
+        [lonSW],[latSW]: longitude and latitude of the SW vertex of the box
+        [lonNE],[latNE]: longitude and latitude of the NE vertex of the box
+        [levI],[levF]: range of levels to retrieve
+      ncfile= netCDF file
+      varn= name of the variable
+    """
+    fname = 'sellonlatlevbox'
+
+    ofile = 'sellonlatlevbox_' + varn + '.nc'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print sellonlatlevbox.__doc__
+        quit()
+
+    lonn = values.split(',')[0]
+    latn = values.split(',')[1]
+    levn = values.split(',')[2]
+
+    lonSW = np.float(values.split(',')[3])
+    latSW = np.float(values.split(',')[4])
+    lonNE = np.float(values.split(',')[5])
+    latNE = np.float(values.split(',')[6])
+    levI = int(values.split(',')[7])
+    levF = int(values.split(',')[8])
+
+    objfile = NetCDFFile(ncfile, 'r')
+    lonobj = objfile.variables[lonn]
+    latobj = objfile.variables[latn]
+    levobj = objfile.variables[levn]
+
+    lonv = lonobj[:]
+    latv = latobj[:]
+    levv = levobj[:]
+
+    if not searchInlist(objfile.variables, varn):
+        print errormsg
+        print '  ' + fname + ': variable name "' + varn + '" is not in file "' +     \
+          ncfile + '" !!!!!'
+        quit(-1)
+
+    varobj = objfile.variables[varn]
+
+    Ndimslon = len(lonobj.shape)
+    Ndimslat = len(latobj.shape)
+    Ndimslev = len(levobj.shape)
+    Ndimsvar = len(varobj.shape)
+
+# Looking for coincidence of dimensions
+    samedim = []
+    for idv in range(Ndimsvar):
+        for idl in range(Ndimslon):
+            if varobj.dimensions[idv] == lonobj.dimensions[idl]:
+                if not searchInlist(samedim,varobj.dimensions[idv]): 
+                    samedim.append(varobj.dimensions[idv])
+                    break
+        for idl in range(Ndimslat):
+            if varobj.dimensions[idv] == latobj.dimensions[idl]:
+                if not searchInlist(samedim,varobj.dimensions[idv]): 
+                    samedim.append(varobj.dimensions[idv])
+                    break
+
+    Ndimshare = len(samedim)
+    print 'variable and lon/lat matrices share ', Ndimshare,' dimensions: ',samedim
+
+    samedimslonlat = True
+    for idL in range(Ndimslon):
+        for idl in range(Ndimslat):
+            if lonobj.dimensions[idl] != latobj.dimensions[idl]:
+                samedimslonlat = False
+                break
+
+        if not samedimslonlat: break
+    
+# Creation of the lon/lat matrices to search
+    if Ndimshare == 1:
+        lonmat = lonobj[:]
+        latmat = latobj[:]
+    elif Ndimshare == 2:
+        if samedimslonlat:
+            lonmat = lonobj[:]
+            latmat = latobj[:]
+        else:
+            if Ndimslon != 1 and Ndimslat != 1:
+                print errormsg
+                print '  ' + fname + ': I do not know how to keep going!'
+                print '    lon ', Ndimslon,' and lat ',Ndimslat,                     \
+                  ' matrices do not share the same dimensions, and do not have shape 1'
+                quit(-1)
+            else:
+                lonmat = np.zeros((latobj.shape[0], lonobj.shape[0]), dtype=np.float)
+                latmat = np.zeros((latobj.shape[0], lonobj.shape[0]), dtype=np.float)
+
+                for i in range(lonobj.shape[0]):
+                    latmat[:,i] = latobj[:]
+                for j in range(latobj.shape[0]):
+                    lonmat[j,:] = lonobj[:]
+    elif Ndimshare == 3:
+        if samedimslonlat:
+            lonmat = lonobj[0,:,:]
+            latmat = latobj[0,:,:]
+    else:
+        print errormsg
+        print '  ' + fname + ': dimension sharing of lon/lat not ready!'
+        quit(-1)
+
+# Searching for inside points
+    iind = 0
+    if Ndimshare == 1:
+        inside = {}
+        for iL in range(lonobj.shape[0]):
+            if lonobj[iL] >= lonSW and lonobj[iL] <= lonNE and latobj[iL] >= latSW   \
+              and latobj[iL] <= latNE:
+                inside[iind] = iL
+                iind = iind + 1
+    elif Ndimshare == 2:
+        newidx = []
+        newidy = []
+        newidz = []
+        if (len(lonobj.shape) == 3):
+            inside3D = np.zeros((varobj.shape[1], lonobj.shape[1], lonobj.shape[2]), dtype=bool)
+            inside2D = np.zeros((lonobj.shape[1], lonobj.shape[2]), dtype=bool)
+            insideZ = np.zeros((varobj.shape[1]), dtype=bool)
+        else:
+            inside3D = np.zeros((varobj.shape[1], lonobj.shape), dtype=bool)
+            inside2D = np.zeros((lonobj.shape), dtype=bool)
+            insideZ = np.zeros((varobj.shape[1]), dtype=bool)
+
+        for iL in range(lonobj.shape[1]):
+            for il in range(lonobj.shape[0]):
+                if lonobj[il,iL] >= lonSW and lonobj[il,iL] <= lonNE and             \
+                  latobj[il,iL] >= latSW and latobj[il,iL] <= latNE:
+                    inside2D[il, iL] = True
+                    if not searchInlist(newidx, iL): newidx.append(iL)
+                    if not searchInlist(newidy, il): newidy.append(il)
+                    for iz in range(Ndimslev): 
+                        if iz >= levI and iz <= levF:
+                            if not searchInlist(newidz, iz): newidz.append(iz)
+                            inside3D[iz,il, iL] = True
+                            insideZ[iz] = True
+
+                            iind = iind + 1
+    elif Ndimshare == 3:
+        newidx = []
+        newidy = []
+        newidz = []
+        inside3D = np.zeros((varobj.shape[1], lonobj.shape[1], lonobj.shape[2]), dtype=bool)
+        inside2D = np.zeros((lonobj.shape[1], lonobj.shape[2]), dtype=bool)
+        insideZ = np.zeros((varobj.shape[1]), dtype=bool)
+
+        for iL in range(lonobj.shape[2]):
+            for il in range(lonobj.shape[1]):
+                if lonobj[0,il,iL] >= lonSW and lonobj[0,il,iL] <= lonNE and         \
+                  latobj[0,il,iL] >= latSW and latobj[0,il,iL] <= latNE:
+                    inside2D[il, iL] = True
+                    if not searchInlist(newidx, iL): newidx.append(iL)
+                    if not searchInlist(newidy, il): newidy.append(il)
+                    for iz in range(Ndimslev):
+                        if iz >= levI and iz <= levF:
+                            if not searchInlist(newidz, iz): newidz.append(iz)
+                            inside3D[iz, il, iL] = True
+                            insideZ[iz] = True
+
+                            iind = iind + 1
+
+    Ninpts3D = len(inside3D)
+    Ninpts2D = len(inside2D)
+    NinptsZ = len(insideZ)
+    newdx = len(newidx)
+    newdy = len(newidy)
+    newdz = len(newidz)
+
+    print '  ' + fname + ': ',Ninpts3D,' pts found in the box: ',lonSW,',',latSW,',', \
+      levI,' x ', lonNE,',',latNE,',',levF
+    print '  ' + fname + ': dimensions output matrix:', newdz, ',', newdy, ',', newdx
+
+# Creation of cropped matrices
+    Ninlev = levF - levI + 1
+    inlon = np.zeros((Ninpts2D), dtype=np.float)
+    inlat = np.zeros((Ninpts2D), dtype=np.float)
+    inlev = np.zeros((NinptsZ), dtype=np.float)
+    invar = np.zeros((varobj.shape[0],Ninpts3D), dtype=np.float)
+
+# Creation of the netCDF file
+##
+    objofile = NetCDFFile(ofile, 'w')
+
+    if Ndimshare == 1:
+
+# Dimensions
+        newdim = objofile.createDimension('boxpt', Ninpts3D)
+        newdim = objofile.createDimension('time', None)
+
+# var dimensions
+        newvar = objofile.createVariable('lon', 'f8', ('boxpt'))
+        newattr = basicvardef(newvar, 'lon', 'longitude', 'degrees west_east')
+        newvar[:] = lonobj[inside2D[iin]]
+
+        newvar = objofile.createVariable('lat', 'f8', ('boxpt'))
+        newattr = basicvardef(newvar, 'lat', 'latitude', 'degrees north_south')
+        newvar[:] = latobj[inside2D[iin]]
+
+        newvar = objofile.createVariable('lev', 'f8', ('NinptsZ'))
+        newattr = basicvardef(newvar, 'lev', 'level', '-')
+        newvar[:] = levobj[insideZ[iin]]
+
+        newvar = objofile.createVariable('time', 'f8', ('time'))
+        if objfile.variables.has_key('time'):
+            otime = objfile.variables['time']
+            timevals = otime[:]
+            if searchInlist(otime.ncattrs(),'units'):
+                tunits = otime.getncattr['units']
+            else:
+                tunits = 'unkown'
+        else:
+            timevals = np.arange(varobj.shape[0])
+            tunits = 'unkown'
+
+        newattr = basicvardef(newvar, 'time', 'time', tunits)
+
+        newvar[:] = timevals
+
+# variable
+        newvar = objofile.createVariable(varn, 'f4', ('time', 'boxpt'))
+        newvar[:] = varobj[invar]
+    else:
+
+# Dimensions
+        newdim = objofile.createDimension('x', newdx)
+        newdim = objofile.createDimension('y', newdy)
+        newdim = objofile.createDimension('z', newdz)
+        newdim = objofile.createDimension('time', None)
+
+# var dimensions
+        newvar = objofile.createVariable('lon', 'f8', ('y', 'x'))
+        if Ndimshare == 2:
+          Vals = lonobj[:]
+        else:
+          Vals = lonobj[0,:,:]
+
+        for it in range(varobj.shape[0]):
+            newvar[:] = Vals[inside2D].reshape(newdy,newdx)
+
+        newattr = basicvardef(newvar, 'lon', 'longitude', 'degrees west_east')
+
+        newvar = objofile.createVariable('lat', 'f8', ('y', 'x'))
+        newattr = basicvardef(newvar, 'lat', 'latitude', 'degrees north_south')
+        if Ndimshare == 2:
+          Vals = latobj[:]
+        else:
+          Vals = latobj[0,:,:]
+
+        for it in range(varobj.shape[0]):
+            newvar[:] = Vals[inside2D].reshape(newdy,newdx)
+
+        newvar = objofile.createVariable('lev', 'f8', ('z'))
+        newattr = basicvardef(newvar, 'lev', 'level', '-')
+        if len(levobj.shape) == 2:
+            newvar[:] = levobj[0,insideZ]
+        else:
+            newvar[:] = levobj[insideZ]
+
+        newvar = objofile.createVariable('time', 'f8', ('time'))
+        if objfile.variables.has_key('time'):
+            otime = objfile.variables['time']
+            timevals = otime[:]
+            if searchInlist(otime.ncattrs(),'units'):
+                tunits = otime.getncattr['units']
+            else:
+                tunits = 'unkown'
+        else:
+            timevals = np.arange(varobj.shape[0])
+            tunits = 'unkown'
+
+        newattr = basicvardef(newvar, 'time', 'time', tunits)
+
+        newvar[:] = timevals
+
+# variable
+        newvar = objofile.createVariable(varn, 'f4', ('time', 'z', 'y', 'x'))
+        for it in range(varobj.shape[0]):
+            valsvar = varobj[it,:,:,:]
+            newvar[it,:,:,:] = valsvar[inside3D]
+
+    if searchInlist(varobj.ncattrs(),'standard_name'):
+        vsname = varobj.getncattr('standard_name')
+    else:
+        vsname = varn
+    if searchInlist(varobj.ncattrs(),'long_name'):
+        vlname = varobj.getncattr('long_name')
+    else:
+        vlname = varn
+    if searchInlist(varobj.ncattrs(),'units'):
+        vunits = varobj.getncattr('units')
+    else:
+        vunits = 'unkown'
+
+    newattr = basicvardef(newvar, vsname, vlname, vunits)
+
+# global attributes
+    objofile.setncattr('author', 'L. Fita')
+    objofile.setncattr('institution', 'Laboratire de Meteorologie Dynamique')
+    objofile.setncattr('university', 'Pierre Marie Curie - Jussieu')
+    objofile.setncattr('center', 'Centre National de Recherches Scientifiques')
+    objofile.setncattr('city', 'Paris')
+    objofile.setncattr('country', 'France')
+    objofile.setncattr('script', 'nc_var_tools.py')
+    objofile.setncattr('function', 'sellonlatlevbox')
+    objofile.setncattr('version', '1.0')
+
+    objfile.close()
+
+    objofile.sync()
+    objofile.close()
+
+    print '  ' + fname + ': successful creation of file "' + ofile + '" !!!'
+
+    return
+
+#sellonlatlevbox('XLONG,XLAT,ZNU,-12.4,25.35,32.4,52.65,0,0', 'control/wrfout_d01_2001-11-09_00:00:00', 'P')
+
+def file_nlines(filen,char):
+    """ Function to provide the number of lines of a file
+    filen= name of the file
+    char= character as no line
+    >>> file_nlines('trajectory.dat','#')
+    49
+    """
+    fname = 'file_nlines'
+
+    if not os.path.isfile(filen):
+        print errormsg
+        print '  ' + fname + ' file: "' + filen + '" does not exist !!'
+        quit(-1)
+
+    fo = open(filen,'r')
+
+    nlines=0
+    for line in fo: 
+        if line[0:1] != char: nlines = nlines + 1
+
+    fo.close()
+
+    return nlines
+
+def datetimeStr_conversion(StringDT,typeSi,typeSo):
+    """ Function to transform a string date to an another date object
+    StringDT= string with the date and time
+    typeSi= type of datetime string input
+    typeSo= type of datetime string output
+      [typeSi/o]
+        'cfTime': [time],[units]; ]time in CF-convention format [units] = [tunits] since [refdate]
+        'matYmdHMS': numerical vector with [[YYYY], [MM], [DD], [HH], [MI], [SS]]
+        'YmdHMS': [YYYY][MM][DD][HH][MI][SS] format
+        'Y-m-d_H:M:S': [YYYY]-[MM]-[DD]_[HH]:[MI]:[SS] format
+        'Y-m-d H:M:S': [YYYY]-[MM]-[DD] [HH]:[MI]:[SS] format
+        'Y/m/d H-M-S': [YYYY]/[MM]/[DD] [HH]-[MI]-[SS] format
+        'WRFdatetime': [Y], [Y], [Y], [Y], '-', [M], [M], '-', [D], [D], '_', [H], 
+          [H], ':', [M], [M], ':', [S], [S]
+    >>> datetimeStr_conversion('1976-02-17_08:32:05','Y-m-d_H:M:S','matYmdHMS')
+    [1976    2   17    8   32    5]
+    >>> datetimeStr_conversion(str(137880)+',minutes since 1979-12-01_00:00:00','cfTime','Y/m/d H-M-S')
+    1980/03/05 18-00-00
+    """
+    import datetime as dt
+
+    fname = 'datetimeStr_conversion'
+
+    if StringDT[0:1] == 'h':
+        print fname + '_____________________________________________________________'
+        print datetimeStr_conversion.__doc__
+        quit()
+
+    if typeSi == 'cfTime':
+        timeval = np.float(StringDT.split(',')[0])
+        tunits = StringDT.split(',')[1].split(' ')[0]
+        Srefdate = StringDT.split(',')[1].split(' ')[2]
+
+# Does reference date contain a time value [YYYY]-[MM]-[DD] [HH]:[MI]:[SS]
+##
+        yrref=Srefdate[0:4]
+        monref=Srefdate[5:7]
+        dayref=Srefdate[8:10]
+
+        trefT = Srefdate.find(':')
+        if not trefT == -1:
+#            print '  ' + fname + ': refdate with time!'
+            horref=Srefdate[11:13]
+            minref=Srefdate[14:16]
+            secref=Srefdate[17:19]
+            refdate = datetimeStr_datetime( yrref + '-' + monref + '-' + dayref +    \
+              '_' + horref + ':' + minref + ':' + secref)
+        else:
+            refdate = datetimeStr_datetime( yrref + '-' + monref + '-' + dayref +    \
+              + '_00:00:00')
+
+        if tunits == 'weeks':
+            newdate = refdate + dt.timedelta(weeks=float(timeval))
+        elif tunits == 'days':
+            newdate = refdate + dt.timedelta(days=float(timeval))
+        elif tunits == 'hours':
+            newdate = refdate + dt.timedelta(hours=float(timeval))
+        elif tunits == 'minutes':
+            newdate = refdate + dt.timedelta(minutes=float(timeval))
+        elif tunits == 'seconds':
+            newdate = refdate + dt.timedelta(seconds=float(timeval))
+        elif tunits == 'milliseconds':
+            newdate = refdate + dt.timedelta(milliseconds=float(timeval))
+        else:
+              print errormsg
+              print '    timeref_datetime: time units "' + tunits + '" not ready!!!!'
+              quit(-1)
+
+        yr = newdate.year
+        mo = newdate.month
+        da = newdate.day
+        ho = newdate.hour
+        mi = newdate.minute
+        se = newdate.second
+    elif typeSi == 'matYmdHMS':
+        yr = StringDT[0]
+        mo = StringDT[1]
+        da = StringDT[2]
+        ho = StringDT[3]
+        mi = StringDT[4]
+        se = StringDT[5]
+    elif typeSi == 'YmdHMS':
+        yr = int(StringDT[0:4])
+        mo = int(StringDT[4:6])
+        da = int(StringDT[6:8])
+        ho = int(StringDT[8:10])
+        mi = int(StringDT[10:12])
+        se = int(StringDT[12:14])
+    elif typeSi == 'Y-m-d_H:M:S':
+        dateDT = StringDT.split('_')
+        dateD = dateDT[0].split('-')
+        timeT = dateDT[1].split(':')
+        yr = int(dateD[0])
+        mo = int(dateD[1])
+        da = int(dateD[2])
+        ho = int(timeT[0])
+        mi = int(timeT[1])
+        se = int(timeT[2])
+    elif typeSi == 'Y-m-d H:M:S':
+        dateDT = StringDT.split(' ')
+        dateD = dateDT[0].split('-')
+        timeT = dateDT[1].split(':')
+        yr = int(dateD[0])
+        mo = int(dateD[1])
+        da = int(dateD[2])
+        ho = int(timeT[0])
+        mi = int(timeT[1])
+        se = int(timeT[2])
+    elif typeSi == 'Y/m/d H-M-S':
+        dateDT = StringDT.split(' ')
+        dateD = dateDT[0].split('/')
+        timeT = dateDT[1].split('-')
+        yr = int(dateD[0])
+        mo = int(dateD[1])
+        da = int(dateD[2])
+        ho = int(timeT[0])
+        mi = int(timeT[1])
+        se = int(timeT[2])
+    elif typeSi == 'WRFdatetime':
+        yr = int(StringDT[0])*1000 + int(StringDT[1])*100 + int(StringDT[2])*10 +    \
+          int(StringDT[3])
+        mo = int(StringDT[5])*10 + int(StringDT[6])
+        da = int(StringDT[8])*10 + int(StringDT[9])
+        ho = int(StringDT[11])*10 + int(StringDT[12])
+        mi = int(StringDT[14])*10 + int(StringDT[15])
+        se = int(StringDT[17])*10 + int(StringDT[18])
+    else:
+        print errormsg
+        print '  ' + fname + ': type of String input date "' + typeSi +              \
+          '" not ready !!!!'
+        quit(-1)
+
+    if typeSo == 'matYmdHMS':
+        dateYmdHMS = np.zeros((6), dtype=int)
+        dateYmdHMS[0] =  yr
+        dateYmdHMS[1] =  mo
+        dateYmdHMS[2] =  da
+        dateYmdHMS[3] =  ho
+        dateYmdHMS[4] =  mi
+        dateYmdHMS[5] =  se
+    elif typeSo == 'YmdHMS':
+        dateYmdHMS = str(yr).zfill(4) + str(mo).zfill(2) + str(da).zfill(2) +        \
+          str(ho).zfill(2) + str(mi).zfill(2) + str(se).zfill(2)
+    elif typeSo == 'Y-m-d_H:M:S':
+        dateYmdHMS = str(yr).zfill(4) + '-' + str(mo).zfill(2) + '-' +               \
+          str(da).zfill(2) + '_' + str(ho).zfill(2) + ':' + str(mi).zfill(2) + ':' + \
+          str(se).zfill(2)
+    elif typeSo == 'Y-m-d H:M:S':
+        dateYmdHMS = str(yr).zfill(4) + '-' + str(mo).zfill(2) + '-' +               \
+          str(da).zfill(2) + ' ' + str(ho).zfill(2) + ':' + str(mi).zfill(2) + ':' + \
+          str(se).zfill(2)
+    elif typeSo == 'Y/m/d H-M-S':
+        dateYmdHMS = str(yr).zfill(4) + '/' + str(mo).zfill(2) + '/' +               \
+          str(da).zfill(2) + ' ' + str(ho).zfill(2) + '-' + str(mi).zfill(2) + '-' + \
+          str(se).zfill(2) 
+    elif typeSo == 'WRFdatetime':
+        dateYmdHMS = []
+        yM = yr/1000
+        yC = (yr-yM*1000)/100
+        yD = (yr-yM*1000-yC*100)/10
+        yU = yr-yM*1000-yC*100-yD*10
+
+        mD = mo/10
+        mU = mo-mD*10
+        
+        dD = da/10
+        dU = da-dD*10
+
+        hD = ho/10
+        hU = ho-hD*10
+
+        miD = mi/10
+        miU = mi-miD*10
+
+        sD = se/10
+        sU = se-sD*10
+
+        dateYmdHMS.append(str(yM))
+        dateYmdHMS.append(str(yC))
+        dateYmdHMS.append(str(yD))
+        dateYmdHMS.append(str(yU))
+        dateYmdHMS.append('-')
+        dateYmdHMS.append(str(mD))
+        dateYmdHMS.append(str(mU))
+        dateYmdHMS.append('-')
+        dateYmdHMS.append(str(dD))
+        dateYmdHMS.append(str(dU))
+        dateYmdHMS.append('_')
+        dateYmdHMS.append(str(hD))
+        dateYmdHMS.append(str(hU))
+        dateYmdHMS.append(':')
+        dateYmdHMS.append(str(miD))
+        dateYmdHMS.append(str(miU))
+        dateYmdHMS.append(':')
+        dateYmdHMS.append(str(sD))
+        dateYmdHMS.append(str(sU))
+    else:
+        print errormsg
+        print '  ' + fname + ': type of output date "' + typeSo + '" not ready !!!!'
+        quit(-1)
+
+    return dateYmdHMS
+
+def radius_dist(dx,dy,ptx,pty):
+    """ Function to generate a matrix with the distance at a given point
+    radius_dist(dx,dy,ptx,pty)
+      [dx/y]: dimension of the matrix
+      [ptx/y]: grid point coordinates of the point
+    >>> radius_dist(3,5,2,2)
+    [[ 1.41421356  1.          1.41421356  2.23606798  3.16227766]
+     [ 1.          0.          1.          2.          3.        ]
+     [ 1.41421356  1.          1.41421356  2.23606798  3.16227766]]
+    """
+
+    fname = 'radius_dist'
+
+    if ptx < 0 or ptx > dx-1 or pty < 0 or pty > dy-1:
+        print errormsg
+        print '  ' + fname + ': wrong point coordinates:',dx,',',dy,'for matrix;',dx \
+         ,'x',dy
+        quit(-1)
+
+    xdist =  np.zeros((dx,dy), dtype=np.float)
+    ydist =  np.zeros((dx,dy), dtype=np.float)
+    dist =  np.zeros((dx,dy), dtype=np.float)
+
+    for ix in range(dx):
+        xdist[ix,:] = np.float(ix-ptx)
+    for iy in range(dy):
+        ydist[:,iy] = np.float(iy-pty)
+
+    dist = np.sqrt(xdist*xdist + ydist*ydist)
+
+    return dist
+
+def compute_tevolboxtraj(values, ncfile, varn):
+    """ Function to compute tevolboxtraj: temporal evolution at a given point along 
+          a box following a trajectory
+      values= [trajfile]@[Tbeg],[lonname],[latname],[timename],[timekind],[boxsize],[circler]
+        [trajfile]: ASCII file with the trajectory ('#' not readed)
+          [time] [xpoint] [ypoint]
+        [Tbeg]: equivalent first time-step of the trajectory within the netCDF file
+        [lonname],[latname],[timename]: longitude, latitude and time variables names
+        [timekind]: kind of time
+          'cf': cf-compilant
+          'wrf': WRF kind
+        [boxsize]: size in grid points of the box (square centered, better even number!)
+        [circler]: radius in grid points of a centerd circle
+      ncfile= netCDF file to use
+      varn= variable name
+        EMERGENCY version, assuming 3D [time,lat,lon] variable !
+    """
+    import numpy.ma as ma
+
+    fname='compute_tevolboxtraj'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print compute_tevolboxtraj.__doc__
+        quit()
+
+    ofile = 'tevolboxtraj_' + varn + '.nc'
+
+    trajfile = values.split(',')[0].split('@')[0]
+    Tbeg = int(values.split(',')[0].split('@')[1])
+    lonn = values.split(',')[1]
+    latn = values.split(',')[2]
+    timn = values.split(',')[3]
+    timekind = values.split(',')[4]
+    boxs = int(values.split(',')[5])
+    circler = int(values.split(',')[6])
+
+    if np.mod(boxs,2) != 1:
+        print errormsg
+        print '  ' + fname + ': box size:', boxs, 'is not even !!!'
+        quit(-1)
+    
+    box2 = int(boxs/2)
+
+    if not os.path.isfile(ncfile):
+        print errormsg
+        print '  ' + fname + " netCDF file: '" + ncfile + "' does not exist !!"
+        quit(-1)
+
+    if not os.path.isfile(trajfile):
+        print errormsg
+        print '  ' + fname + " trajectory file: '" + trajfile + "' does not exist !!"
+        quit(-1)
+
+# circle values
+#    radius = np.float(rboxs.split('#')[0])
+#    ddist = np.float(rboxs.split('#')[1])
+#    if radius < ddist:
+#        print errormsg
+#        print '  ' + fname + ': radius of the circle:',radius,' is smaller than ' +  \
+#          'the distance between grid points !!'
+#        quit(-1)
+#    else:
+#        Nrad = int(radius/ddist)
+    Nrad = int(circler)
+
+    objfile = NetCDFFile(ncfile, 'r')
+    lonobj = objfile.variables[lonn]
+    latobj = objfile.variables[latn]
+    timobj = objfile.variables[timn]
+
+    if len(lonobj.shape) == 3:
+        lonv = lonobj[0,:,:]
+        latv = latobj[0,:,:]
+    elif len(lonobj.shape) == 2:
+        lonv = lonobj[:]
+        latv = latobj[:]
+
+    dimx = lonv.shape[1]
+    dimy = lonv.shape[0]
+
+    timv = timobj[:]
+
+    if not searchInlist(objfile.variables, varn):
+        print errormsg
+        print '  ' + fname + ": variable name '" + varn + "' is not in file " +     \
+          ncfile + '" !!!!!'
+        quit(-1)
+
+    varobj = objfile.variables[varn]
+
+# Selecting accordingly a trajectory
+##
+    Ttraj = file_nlines(trajfile,'#')
+    if Ttraj > varobj.shape[0]:
+        print errormsg
+        print '  ' + fname + ': trajectory has ', Ttraj, ' time steps and data',     \
+          varobj.shape[0], '" !!!!!'
+        quit(-1)
+
+    print '    ' + fname + ': Number of time-steps in trajectory file: ',Ttraj
+
+    trajobj = open(trajfile,'r')
+
+    gtrajvals = np.zeros((Ttraj,3), dtype=int)
+    trajvals = np.zeros((Ttraj,3), dtype=np.float)
+    varvals = np.ones(tuple([Ttraj,boxs,boxs]), dtype=np.float)
+    lonvals = np.ones(tuple([Ttraj,boxs,boxs]), dtype=np.float)
+    latvals = np.ones(tuple([Ttraj,boxs,boxs]), dtype=np.float)
+    rvarvals = np.ones(tuple([Ttraj,Nrad*2+1,Nrad*2+1]), dtype=np.float)
+    rlonvals = np.ones(tuple([Ttraj,Nrad*2+1,Nrad*2+1]), dtype=np.float)
+    rlatvals = np.ones(tuple([Ttraj,Nrad*2+1,Nrad*2+1]), dtype=np.float)
+
+    statvarvals = np.ones(tuple([Ttraj,6]), dtype=np.float)
+    rstatvarvals = np.ones(tuple([Ttraj,6]), dtype=np.float)
+
+    iline = 0
+    it = 0
+    for line in trajobj:
+        slicev = []
+        slice2D = []
+        slicevnoT = []
+
+## Skipping first line
+##        if not iline == 0:
+##        it = iline - 1
+##        it = iline
+
+# Slicing brings to reduce 1 time-step.... ???
+        if line[0:1] != '#':
+            gtrajvals[it,0] = Tbeg + iline
+            gtrajvals[it,1] = int(line.split(' ')[1])
+            gtrajvals[it,2] = int(line.split(' ')[2])
+#            print it,'t:',gtrajvals[it,0],'x y:', gtrajvals[it,1], gtrajvals[it,2]
+        
+            if timekind == 'wrf':
+                gdate = datetimeStr_conversion(timv[gtrajvals[it,0]],'WRFdatetime',  \
+                  'matYmdHMS')
+                trajvals[it,0] = realdatetime1_CFcompilant(gdate, '19491201000000',  \
+                  'hours')
+                tunits = 'hours since 1949-12-01 00:00:00'
+            elif timekind == 'cf':
+                trajvals[it,0] = timv[gtrajvals[it,0]]
+                tunits = timobj.getncattr('units')
+            else:
+                print errormsg
+                print '  ' + fname + ' time kind: "' + timekind + '" not ready !!'
+                quit(-1)
+
+            trajvals[it,1] = lonv[gtrajvals[it,2],gtrajvals[it,1]]
+            trajvals[it,2] = latv[gtrajvals[it,2],gtrajvals[it,1]]
+
+#            print iline, it,'time:',trajvals[it,0],'lon lat:', trajvals[it,1], trajvals[it,2]
+
+# Assuming time as the first dimension in a fortran like way (t=0 as 1)
+#            trajcut[0] = tstept - 1
+# Assuming time as the first dimension in a C/python like way (t=0)
+
+            slicev.append(gtrajvals[it,0])
+
+# box values
+            if gtrajvals[it,2]-box2 < 0 or gtrajvals[it,2]+box2 + 1 > dimy + 1 \
+              or gtrajvals[it,1]-box2 < 0 or gtrajvals[it,1]+box2 + 1 > dimx + 1:
+
+                varvalst = np.ones((boxs, boxs), dtype=np.float)*fillValue
+
+                if gtrajvals[it,2]-box2 < 0: 
+                    yinit = 0
+                    yinit2D = box2 - gtrajvals[it,2]
+                else:
+                    yinit = gtrajvals[it,2]-box2
+                    yinit2D = 0
+
+                if gtrajvals[it,2]+box2 + 1 > dimy + 1: 
+                    yend = dimy + 1
+                    yend2D = dimy + 1 - gtrajvals[it,2] + box2
+                else:
+                    yend = gtrajvals[it,2]+box2 + 1
+                    yend2D = boxs
+
+                if gtrajvals[it,1]-box2 < 0: 
+                    xinit = 0
+                    xinit2D = box2 - gtrajvals[it,1]
+                else:
+                    xinit = gtrajvals[it,1]-box2
+                    xinit2D = 0
+
+                if gtrajvals[it,1]+box2 + 1 > dimx + 1: 
+                    xend = dimx + 1
+                    xend2D = dimx + 1 - gtrajvals[it,1] - box2
+                else:
+                    xend = gtrajvals[it,1]+box2 + 1
+                    xend2D = boxs
+
+                slicev.append(slice(yinit, yend))
+                slicev.append(slice(xinit, xend))
+
+                slicevnoT.append(slice(yinit, yend))
+                slicevnoT.append(slice(xinit, xend))
+
+                slice2D.append(slice(yinit2D, yend2D))
+                slice2D.append(slice(xinit2D, xend2D))
+
+                varvalst[tuple(slice2D)] = varobj[tuple(slicev)]
+                varvals[it,:,:] = varvalst
+
+# box stats values
+                maskedvals = ma.masked_values (varvalst, fillValue)
+                statvarvals[it,0] = varvalst[box2,box2]
+                statvarvals[it,1] = maskedvals.min()
+                statvarvals[it,2] = maskedvals.max()
+                statvarvals[it,3] = maskedvals.mean()
+                maskedvals2 = maskedvals*maskedvals
+                statvarvals[it,4] = maskedvals2.mean()
+                statvarvals[it,5] = np.sqrt(statvarvals[it,4] -                      \
+                  statvarvals[it,3]*statvarvals[it,3])
+
+                varvalst[tuple(slice2D)] = lonv[tuple(slicevnoT)]
+                lonvals[it,:,:] = varvalst
+                varvalst[tuple(slice2D)] = latv[tuple(slicevnoT)]           
+                latvals[it,:,:] = varvalst
+
+            else:
+                slicev.append(slice(gtrajvals[it,2]-box2, gtrajvals[it,2]+box2 + 1))
+                slicev.append(slice(gtrajvals[it,1]-box2, gtrajvals[it,1]+box2 + 1))
+                slicevnoT.append(slice(gtrajvals[it,2]-box2, gtrajvals[it,2]+box2+1))
+                slicevnoT.append(slice(gtrajvals[it,1]-box2, gtrajvals[it,1]+box2+1))
+
+                slice2D.append(slice(gtrajvals[it,2]-box2, gtrajvals[it,2]+box2 + 1))
+                slice2D.append(slice(gtrajvals[it,1]-box2, gtrajvals[it,1]+box2 + 1))
+
+                varvalst = varobj[tuple(slicev)]
+# box values
+
+                varvals[it,:,:] = varvalst
+#            print 'values at time t______'
+#            print varvalst
+
+# box stats values
+                statvarvals[it,0] = varvalst[box2,box2]
+                statvarvals[it,1] = np.min(varvalst)
+                statvarvals[it,2] = np.max(varvalst)
+                statvarvals[it,3] = np.mean(varvalst)
+                statvarvals[it,4] = np.mean(varvalst*varvalst)
+                statvarvals[it,5] = np.sqrt(statvarvals[it,4] -                      \
+                  statvarvals[it,3]*statvarvals[it,3])
+
+                varvalst = lonv[tuple(slicevnoT)]
+                lonvals[it,:,:] = varvalst
+                varvalst = latv[tuple(slicevnoT)]           
+                latvals[it,:,:] = varvalst
+
+# circle values
+            slicev = []
+            slice2D = []
+            slicevnoT = []
+
+            slicev.append(gtrajvals[it,0])
+            circdist = radius_dist(dimy, dimx, gtrajvals[it,2], gtrajvals[it,1])
+
+            if gtrajvals[it,2]-Nrad < 0 or gtrajvals[it,2]+Nrad + 1 > dimy + 1 \
+              or gtrajvals[it,1]-Nrad < 0 or gtrajvals[it,1]+Nrad + 1 > dimx + 1:
+
+                rvarvalst = np.ones((Nrad*2+1, Nrad*2+1), dtype=np.float)*fillValue
+
+                if gtrajvals[it,2]-Nrad < 0: 
+                    yinit = 0
+                    yinit2D = Nrad - gtrajvals[it,2]
+                else:
+                    yinit = gtrajvals[it,2]-Nrad
+                    yinit2D = 0
+
+                if gtrajvals[it,2]+Nrad + 1 > dimy + 1: 
+                    yend = dimy + 1
+                    yend2D = dimy + 1 - gtrajvals[it,2] + Nrad
+                else:
+                    yend = gtrajvals[it,2]+Nrad + 1
+                    yend2D = 2*Nrad+1
+
+                if gtrajvals[it,1]-Nrad < 0: 
+                    xinit = 0
+                    xinit2D = Nrad - gtrajvals[it,1]
+                else:
+                    xinit = gtrajvals[it,1]-Nrad
+                    xinit2D = 0
+
+                if gtrajvals[it,1]+Nrad + 1 > dimx + 1: 
+                    xend = dimx + 1
+                    xend2D = dimx + 1 - gtrajvals[it,1] - Nrad
+                else:
+                    xend = gtrajvals[it,1]+Nrad + 1
+                    xend2D = 2*Nrad+1
+
+                slicev.append(slice(yinit, yend))
+                slicev.append(slice(xinit, xend))
+
+                slicevnoT.append(slice(yinit, yend))
+                slicevnoT.append(slice(xinit, xend))
+
+                slice2D.append(slice(yinit2D, yend2D))
+                slice2D.append(slice(xinit2D, xend2D))
+
+                rvarvalst[tuple(slice2D)] = varobj[tuple(slicev)]
+                rvarvalst[tuple(slice2D)] = np.where(circdist[tuple(slice2D)] >      \
+                  np.float(Nrad), fillValue, rvarvalst[tuple(slice2D)])
+
+                rvarvals[it,:,:] = rvarvalst
+
+# circle stats values
+                maskedvals = ma.masked_values (rvarvalst, fillValue)
+                rstatvarvals[it,0] = rvarvalst[Nrad,Nrad]
+                rstatvarvals[it,1] = maskedvals.min()
+                rstatvarvals[it,2] = maskedvals.max()
+                rstatvarvals[it,3] = maskedvals.mean()
+                maskedvals2 = maskedvals*maskedvals
+                rstatvarvals[it,4] = maskedvals2.mean()
+                rstatvarvals[it,5] = np.sqrt(rstatvarvals[it,4] -                    \
+                  rstatvarvals[it,3]*rstatvarvals[it,3])
+
+                rvarvalst[tuple(slice2D)] = lonv[tuple(slicevnoT)]
+                rlonvals[it,:,:] = rvarvalst
+                rvarvalst[tuple(slice2D)] = latv[tuple(slicevnoT)]           
+                rlatvals[it,:,:] = rvarvalst
+
+            else:
+                slicev.append(slice(gtrajvals[it,2]-Nrad, gtrajvals[it,2]+Nrad + 1))
+                slicev.append(slice(gtrajvals[it,1]-Nrad, gtrajvals[it,1]+Nrad + 1))
+                slicevnoT.append(slice(gtrajvals[it,2]-Nrad, gtrajvals[it,2]+Nrad+1))
+                slicevnoT.append(slice(gtrajvals[it,1]-Nrad, gtrajvals[it,1]+Nrad+1))
+
+                slice2D.append(slice(gtrajvals[it,2]-Nrad, gtrajvals[it,2]+Nrad + 1))
+                slice2D.append(slice(gtrajvals[it,1]-Nrad, gtrajvals[it,1]+Nrad + 1))
+
+                rvarvalst = varobj[tuple(slicev)]
+                cdist = circdist[tuple(slicevnoT)]
+# circle values
+                rvarvalst = np.where(cdist > np.float(Nrad), fillValue, rvarvalst)
+
+                rvarvals[it,:,:] = rvarvalst
+
+# circle stats values
+                maskedvals = ma.masked_values (rvarvalst, fillValue)
+                rstatvarvals[it,0] = rvarvalst[Nrad,Nrad]
+                rstatvarvals[it,1] = maskedvals.min()
+                rstatvarvals[it,2] = maskedvals.max()
+                rstatvarvals[it,3] = maskedvals.mean()
+                maskedvals2 = maskedvals*maskedvals
+                rstatvarvals[it,4] = maskedvals2.mean()
+                rstatvarvals[it,5] = np.sqrt(rstatvarvals[it,4] -                    \
+                  rstatvarvals[it,3]*rstatvarvals[it,3])
+
+                rvarvalst = lonv[tuple(slicevnoT)]
+                rlonvals[it,:,:] = rvarvalst
+                rvarvalst = latv[tuple(slicevnoT)]           
+                rlatvals[it,:,:] = rvarvalst
+
+            it = it + 1
+#            print 'statistics:',rstatvarvals[it,:] 
+
+        iline = iline + 1
+
+    trajobj.close()
+
+# Creation of the netCDF file
+##
+    objofile = NetCDFFile(ofile, 'w')
+
+# Dimensions
+    newdim = objofile.createDimension('x', boxs)
+    newdim = objofile.createDimension('y', boxs)
+    newdim = objofile.createDimension('xr', Nrad*2+1)
+    newdim = objofile.createDimension('yr', Nrad*2+1)
+    newdim = objofile.createDimension('time', None)
+
+# var dimensions
+    newvar = objofile.createVariable('trlon', 'f8', ('time'))
+    newattr = basicvardef(newvar,'trlon','trajectory longitude','degrees west_east')
+    newvar[:] = trajvals[:,1]
+
+    newvar = objofile.createVariable('trlat', 'f8', ('time'))
+    newattr = basicvardef(newvar,'trlat','trajectory latitude','degrees north_south')
+    newvar[:] = trajvals[:,2]
+
+    newvar = objofile.createVariable('time', 'f8', ('time'))
+    newattr = basicvardef(newvar, 'time', 'time', tunits)
+    newvar[:] = trajvals[:,0]
+
+    newvar = objofile.createVariable('lon', 'f8', ('time', 'y', 'x'),                \
+      fill_value=fillValue)
+    newattr = basicvardef(newvar, 'longitude', 'longitude', 'degrees west_east')
+    newvar[:] = lonvals
+
+    newvar = objofile.createVariable('lat', 'f8', ('time', 'y', 'x'),                \
+      fill_value=fillValue)
+    newattr = basicvardef(newvar, 'latitude', 'latitude', 'degrees north_south')
+    newvar[:] = latvals
+
+# variable box values
+    newvar = objofile.createVariable(varn + 'box', 'f4', ('time', 'y', 'x'),         \
+      fill_value=fillValue)
+    if searchInlist(varobj.ncattrs(),'standard_name'):
+        vsname = varobj.getncattr('standard_name')
+    else:
+        vsname = variables_values(varn)[1]
+    if searchInlist(varobj.ncattrs(),'long_name'):
+        vlname = varobj.getncattr('long_name')
+    else:
+        vlname = variables_values(varn)[4].replace('|',' ')
+    if searchInlist(varobj.ncattrs(),'units'):
+        vunits = varobj.getncattr('units')
+    else:
+        vunits = variables_values(varn)[5].replace('|',' ')
+
+    newattr = basicvardef(newvar, vsname, vlname, vunits)
+    newattr = newvar.setncattr('projection','lon lat')
+    newvar[:] = varvals
+
+# center of the trajectory
+    newvar = objofile.createVariable('trj_' + varn, 'f', ('time'),                  \
+      fill_value=fillValue)
+    newattr = basicvardef(newvar, 'trj_' + vsname, 'value along the trajectory of '+\
+      varn, vunits)
+    newvar[:] = statvarvals[:,0]
+
+# variable box statistics
+    ist = 0
+
+    statnames = ['minbox', 'maxbox', 'meanbox', 'mean2box', 'stdevbox']
+    vstlname = ['minimum value within', 'maximum value within',                      \
+     'mean value within', 'squared mean value within',                               \
+     'standard deviation value within']
+
+    for statn in statnames:
+        newvar = objofile.createVariable(statn + '_' + varn, 'f', ('time'),          \
+          fill_value=fillValue)
+        newattr = basicvardef(newvar, statn + '_' + vsname, vstlname[ist] +          \
+          ' the box ('+str(boxs)+'x'+str(boxs)+') of ' + varn, vunits)
+        newvar[:] = statvarvals[:,ist+1]
+#        newattr = set_attributek(newvar,'_FillValue',fillValue,'npfloat')
+        ist = ist + 1
+        
+
+# variable circle values
+    newvar = objofile.createVariable(varn + 'circle', 'f4', ('time', 'yr', 'xr'),      \
+      fill_value=fillValue)
+    if searchInlist(varobj.ncattrs(),'standard_name'):
+        vsname = varobj.getncattr('standard_name')
+    else:
+        vsname = variables_values(varn)[1]
+    if searchInlist(varobj.ncattrs(),'long_name'):
+        vlname = varobj.getncattr('long_name')
+    else:
+        vlname = variables_values(varn)[4].replace('|',' ')
+    if searchInlist(varobj.ncattrs(),'units'):
+        vunits = varobj.getncattr('units')
+    else:
+        vunits = variables_values(varn)[5].replace('|',' ')
+
+    newattr = basicvardef(newvar, vsname, vlname, vunits)
+    newattr = newvar.setncattr('projection','lon lat')
+    newvar[:] = rvarvals
+
+# variable circle statistics
+    ist = 0
+    statnames = ['mincircle', 'maxcircle', 'meancircle', 'mean2circle', 'stdevcircle']
+
+    for statn in statnames:
+        newvar = objofile.createVariable(statn + '_' + varn, 'f', ('time'),          \
+          fill_value=fillValue)
+        newattr = basicvardef(newvar, statn + '_' + vsname, vstlname[ist] +          \
+          ' the circle of radius ('+ str(circler)+') of ' + varn, vunits)
+        newvar[:] = rstatvarvals[:,ist+1]
+#        newattr = set_attributek(newvar,'_FillValue',fillValue,'npfloat')
+        ist = ist + 1
+
+# global attributes
+    objofile.setncattr('author', 'L. Fita')
+    objofile.setncattr('institution', 'Laboratire de Meteorologie Dynamique')
+    objofile.setncattr('university', 'Pierre Marie Curie - Jussieu')
+    objofile.setncattr('center', 'Centre National de Recherches Scientifiques')
+    objofile.setncattr('city', 'Paris')
+    objofile.setncattr('country', 'France')
+    objofile.setncattr('script', 'nc_var_tools.py')
+    objofile.setncattr('function', 'compute_tevolboxtraj')
+    objofile.setncattr('version', '1.0')
+    objofile.setncattr('data_file',ncfile)
+
+    objfile.close()
+
+    objofile.sync()
+    objofile.close()
+
+    print '  ' + fname + ': successful creation of file "' + ofile + '" !!!'
+
+    return 
+
+#compute_tevolboxtraj('h', 'wrfout*', 'PSFC')
+#compute_tevolboxtraj('control/trajectory.dat@0,XLONG,XLAT,Times,wrf,3,3',            \
+#  '../../superstorm/control/wrfout/wrfout_d01_2001-11-09_00:00:00', 'PSFC')
+#compute_tevolboxtraj('control/trajectory.dat@0,lon,lat,time,cf,5,5',                 \
+#  'control/wss.nc', 'wss')
+
+def numVector_String(vec,char):
+    """ Function to transform a vector of numbers to a single string [char] separated
+    numVector_String(vec,char)
+      vec= vector with the numerical values
+      char= single character to split the values
+    >>> print numVector_String(np.arange(10),' ')
+    0 1 2 3 4 5 6 7 8 9
+    """
+    fname = 'numVector_String'
+
+    if vec == 'h':
+        print fname + '_____________________________________________________________'
+        print numVector_String.__doc__
+        quit()
+
+    Nvals = len(vec)
+
+    string=''
+    for i in range(Nvals):
+        if i == 0:
+            string = str(vec[i])
+        else:
+            string = string + char + str(vec[i])
+
+    return string
+
+def interpolate_locs(locs,coords,kinterp):
+    """ Function to provide interpolate locations on a given axis
+    interpolate_locs(locs,axis,kinterp)
+      locs= locations to interpolate
+      coords= axis values with the reference of coordinates
+      kinterp: kind of interpolation
+        'lin': linear
+    >>> coordinates = np.arange((10), dtype=np.float)
+    >>> values = np.array([-1.2, 2.4, 5.6, 7.8, 12.0])
+    >>> interpolate_locs(values,coordinates,'lin')
+    [ -1.2   2.4   5.6   7.8  13. ]
+    >>> coordinates[0] = 0.5
+    >>> coordinates[2] = 2.5
+    >>> interpolate_locs(values,coordinates,'lin')
+    [ -3.4          1.93333333   5.6          7.8         13.        ]
+    """
+
+    fname = 'interpolate_locs'
+
+    if locs == 'h':
+        print fname + '_____________________________________________________________'
+        print interpolate_locs.__doc__
+        quit()
+
+    Nlocs = locs.shape[0]
+    Ncoords = coords.shape[0]
+
+    dcoords = coords[Ncoords-1] - coords[0]
+
+    intlocs = np.zeros((Nlocs), dtype=np.float)
+    minc = np.min(coords)
+    maxc = np.max(coords)
+
+    for iloc in range(Nlocs):
+        for icor in range(Ncoords-1):
+            if locs[iloc] < minc and dcoords > 0.:
+                a = 0.
+                b = 1. / (coords[1] - coords[0])
+                c = coords[0]
+            elif locs[iloc] > maxc and dcoords > 0.:
+                a = (Ncoords-1)*1.
+                b = 1. / (coords[Ncoords-1] - coords[Ncoords-2])
+                c = coords[Ncoords-2]
+            elif locs[iloc] < minc and dcoords < 0.:
+                a = (Ncoords-1)*1.
+                b = 1. / (coords[Ncoords-1] - coords[Ncoords-2])
+                c = coords[Ncoords-2]
+            elif locs[iloc] > maxc and dcoords < 0.:
+                a = 0.
+                b = 1. / (coords[1] - coords[0])
+                c = coords[0]
+            elif locs[iloc] >= coords[icor] and locs[iloc] < coords[icor+1] and dcoords > 0.:
+                a = icor*1.
+                b = 1. / (coords[icor+1] - coords[icor])
+                c = coords[icor]
+                print coords[icor], locs[iloc], coords[icor+1], ':', icor, '->', a, b
+            elif locs[iloc] <= coords[icor] and locs[iloc] > coords[icor+1] and dcoords < 0.:
+                a = icor*1.
+                b = 1. / (coords[icor+1] - coords[icor])
+                c = coords[icor]
+
+        if kinterp == 'lin':
+            intlocs[iloc] = a + (locs[iloc] - c)*b
+        else:
+            print errormsg
+            print '  ' + fname + ": interpolation kind '" + kinterp + "' not ready !!!!!"
+            quit(-1)
+
+    return intlocs
+
+def vertical_interpolation2D(varb,vart,zorigvals,znewval,kinterp):
+    """ Function to vertically integrate a 3D variable
+    vertical_interpolation2D(varb,vart,zorigvals,znewval)
+      varb= values at the base of the interval of interpolation (2D field)
+      vart= values at the top of the interval of interpolation (2D field)
+      zorigvals= pair of original values (2, 2D field)
+      znewval= new value to interpolate
+      Possible cases:
+        zorigvals[0,:,:] <= znewval < zorigvals[1,:,:]
+        znewval <= zorigvals[0,:,:] < zorigvals[1,:,:]
+        zorigvals[0,:,:] < zorigvals[1,:,:] <= znewval
+      kinterp: kind of interpolation
+        'lin': linear
+    >>> dx=5
+    >>> dy=7
+    >>> vals1 = np.ones((dy,dx), dtype=np.float)
+    >>> vals2 = np.ones((dy,dx), dtype=np.float)*2.
+
+    >>> zbase = np.zeros((2,dy,dx), dtype=np.float)
+    >>> zbase[0,:,:] = 0.5
+    >>> zbase[1,:,:] = 1.
+
+    >>> vertical_interpolation2D(vals1,vals2, zbase, newz,'lin')
+    [[ 1.5  1.5  1.5  1.5  1.5]
+     [ 1.5  1.5  1.5  1.5  1.5]
+     [ 1.5  1.5  1.5  1.5  1.5]
+     [ 1.5  1.5  1.5  1.5  1.5]
+     [ 1.5  1.5  1.5  1.5  1.5]
+     [ 1.5  1.5  1.5  1.5  1.5]
+     [ 1.5  1.5  1.5  1.5  1.5]]
+    """
+
+    fname = 'vertical_interpolation2D'
+
+    if varb == 'h':
+        print fname + '_____________________________________________________________'
+        print vertical_interpolation2D.__doc__
+        quit()
+
+    newvar = np.zeros((varb.shape), dtype=np.float)
+    if kinterp == 'lin':
+##        print '  ' + fname + ' Vertical linear interpolation at',znewval
+# Standard linear interpolation (y = a + b*incz)
+#   a = zorig[0], b = (vart-varb)/(zorig[1]-zorig[0])), incz = znewval - zorig[0]
+        a = varb
+        b = np.where(zorigvals[1,:,:] == zorigvals[0,:,:], 0.,                       \
+          (vart - varb)/(zorigvals[1,:,:] - zorigvals[0,:,:]))
+        incz = np.ones((varb.shape), dtype=np.float)*znewval - zorigvals[0,:,:]
+
+        newvar = a + b*incz
+# Too code for not be used... but maybe?
+#        dx=varb.shape[1]
+#        dy=varb.shape[0]
+#        for j in range(dy):
+#            for i in range(dx):
+#                  if zorigvals[1,j,i] == zorigvals[0,j,i]: print 'equals!',          \
+#                    zorigvals[1,j,i], zorigvals[0,j,i],':',newvar[j,i],'@',vart[j,i]
+#                  if zorigvals[0,j,i] != zorigvals[0,j,i]: print '0 Nan',            \
+#                    zorigvals[0,j,i],':',newvar[j,i],'@',vart[j,i]
+#                  if zorigvals[1,j,i] != zorigvals[1,j,i]: print '1 Nan',            \
+#                    zorigvals[1,j,i],':',newvar[j,i],'@',vart[j,i]
+#                  if zorigvals[0,j,i] is None: print '0 None', zorigvals[0,j,i],':', \
+#                    newvar[j,i],'@',vart[j,i]
+#                  if zorigvals[1,j,i] is None: print '1 None', zorigvals[1,j,i],':', \
+#                    newvar[j,i],'@',vart[j,i]
+    else:
+        print errormsg
+        print '  ' + fname + ": interpolation kind '" + kinterp + "' not ready !!!!!"
+        quit(-1)
+
+    return newvar
+
+#dx=5
+#dy=7
+#vals1 = np.ones((dy,dx), dtype=np.float)
+#vals2 = np.ones((dy,dx), dtype=np.float)*2.
+
+#zbase = np.zeros((2,dy,dx), dtype=np.float)
+#zbase[0,:,:] = 0.5
+#for i in range(dx):
+#    for j in range(dy):
+#        zbase[1,j,i] = np.sqrt((j-dy/2.)**2. + (i-dx/2.)**2.) /                      \
+#          np.sqrt((dy/2.)**2.+(dy/2.)**2.) + 1.
+
+#zbase[1,:,:] = 1.
+
+#newz = 0.75
+
+#print vertical_interpolation2D(vals1,vals2, zbase, newz,'lin')
+
+def vertical_interpolation(varb,vart,zorigvals,znewval,kinterp):
+    """ Function to vertically integrate a 1D variable
+    vertical_interpolation(varb,vart,zorigvals,znewval)
+      varb= values at the base of the interval of interpolation
+      vart= values at the top of the interval of interpolation
+      zorigvals= pair of original values (2)
+      znewval= new value to interpolate
+      Possible cases:
+        zorigvals[0,:] <= znewval < zorigvals[1,:]
+        znewval <= zorigvals[0,:] < zorigvals[1,:]
+        zorigvals[0,:] < zorigvals[1,:] <= znewval
+      kinterp: kind of interpolation
+        'lin': linear
+    >>> dx=5
+    >>> vals1 = np.ones((dx), dtype=np.float)
+    >>> vals2 = np.ones((dx), dtype=np.float)*2.
+
+    >>> zbase = np.zeros((2,dx), dtype=np.float)
+    >>> zbase[0,:] = 0.5
+    >>> for i in range(dx):
+    >>>     zbase[1,i] = i + 1.
+
+    >>> newz = 0.75
+    >>> vertical_interpolation2D(vals1,vals2, zbase, newz,'lin')
+    [ 1.5         1.16666667  1.1         1.07142857  1.05555556]
+    """
+
+    fname = 'vertical_interpolation'
+
+    if varb == 'h':
+        print fname + '_____________________________________________________________'
+        print vertical_interpolation.__doc__
+        quit()
+
+    newvar = np.zeros((varb.shape), dtype=np.float)
+    if kinterp == 'lin':
+##        print '  ' + fname + ' Vertical linear interpolation at',znewval
+# Standard linear interpolation (y = a + b*incz)
+#   a = zorig[0], b = (vart-varb)/(zorig[1]-zorig[0])), incz = znewval - zorig[0]
+        a = varb
+        b = np.where(zorigvals[1,:] == zorigvals[0,:], 0.,                           \
+          (vart - varb)/(zorigvals[1,:] - zorigvals[0,:]))
+        incz = np.ones((varb.shape), dtype=np.float)*znewval - zorigvals[0,:]
+
+        newvar = a + b*incz
+    else:
+        print errormsg
+        print '  ' + fname + ": interpolation kind '" + kinterp + "' not ready !!!!!"
+        quit(-1)
+
+    return newvar
+
+def interpolate_3D(zorigvs, varv, zintvs, kint):
+    """ Function to interpolate a 3D variable
+    interpolate_3D(zintvs, varv, zorigvals)
+      zorigvs= original 3D z values
+      varv= 3D variable to interpolate
+      zintvs= new series of z values to interpolate
+      kint= kind of interpolation
+        'lin': linear
+    """
+    fname = 'interpolate_3D'
+
+    if zorigvs == 'h':
+        print fname + '_____________________________________________________________'
+        print interpolate_3D.__doc__
+        quit()
+
+    Ninv = len(zintvs)
+    dimv = varv.shape
+
+# Sense of the original z-variable
+    Lzorig = zorigvs.shape[0]
+    incz = zorigvs[Lzorig-1,0,0] - zorigvs[0,0,0]
+
+    varin = np.zeros((Ninv,dimv[1],dimv[2]), dtype=np.float)
+
+    for ilev in range(Ninv):
+#        print ' vertical interpolate level: ',zintvs[ilev]
+        valinf = np.zeros((dimv[1], dimv[2]), dtype=np.float)
+        valsup = np.zeros((dimv[1], dimv[2]), dtype=np.float)
+        zorigv = np.zeros((2,dimv[1], dimv[2]), dtype=np.float)
+        for j in range(valinf.shape[0]):
+            for i in range(valinf.shape[1]):
+                
+                if np.min(zorigvs[:,j,i]) > zintvs[ilev] and incz > 0.:
+                    valinf[j,i] = varv[0,j,i]
+                    valsup[j,i] = varv[1,j,i]
+                    zorigv[0,j,i] = zorigvs[0,j,i]
+                    zorigv[1,j,i] = zorigvs[1,j,i]
+                elif np.max(zorigvs[:,j,i]) < zintvs[ilev] and incz < 0.:
+                    valinf[j,i] = varv[0,j,i]
+                    valsup[j,i] = varv[1,j,i]
+                    zorigv[0,j,i] = zorigvs[0,j,i]
+                    zorigv[1,j,i] = zorigvs[1,j,i]
+                elif np.max(zorigvs[:,j,i]) < zintvs[ilev] and incz > 0.:
+                    valinf[j,i] = varv[Lzorig-2,j,i]
+                    valsup[j,i] = varv[Lzorig-1,j,i]
+                    zorigv[0,j,i] = zorigvs[Lzorig-2,j,i]
+                    zorigv[1,j,i] = zorigvs[Lzorig-1,j,i]
+                elif np.min(zorigvs[:,j,i]) > zintvs[ilev] and incz < 0.:
+                    valinf[j,i] = varv[Lzorig-2,j,i]
+                    valsup[j,i] = varv[Lzorig-1,j,i]
+                    zorigv[0,j,i] = zorigvs[Lzorig-2,j,i]
+                    zorigv[1,j,i] = zorigvs[Lzorig-1,j,i]
+#                    print 'top: ',i,j,':',zorigv[0,j,i], zintvs[ilev], zorigv[1,j,i]
+                else:
+                    for z in range(Lzorig-1):
+                        if (zorigvs[z,j,i]-zintvs[ilev])*(zorigvs[z+1,j,i]-          \
+                          zintvs[ilev]) <= 0.:
+                            valinf[j,i] = varv[z,j,i]
+                            valsup[j,i] = varv[z+1,j,i]
+                            zorigv[0,j,i] = zorigvs[z,j,i]
+                            zorigv[1,j,i] = zorigvs[z+1,j,i]
+                            break
+
+#        print 'zorigvs: ',zorigvs[:,0,0]
+#        print '  valinf:', valinf[0,0]
+#        print '  valsup:', valsup[0,0]
+#        print '  zorigv 0:',zorigv[0,0,0]
+#        print '  zorigv 1:',zorigv[1,0,0]
+
+        varin[ilev,:,:] = vertical_interpolation2D(valinf,valsup,zorigv,             \
+          zintvs[ilev], kint)
+#        print '  varin:',varin[ilev,0,0]
+#        quit()
+
+#    quit()
+    return varin
+
+def interpolate_2D(zorigvs0, varv0, zdim, zintvs, kint):
+    """ Function to interpolate a 2D variable
+    interpolate_2D(zintvs, varv, zorigvals)
+      zorigvs= original 2D z values
+      varv= 2D variable to interpolate
+      zdim= number of the dimension with the z-values
+      zintvs= new series of z values to interpolate
+      kint= kind of interpolation
+        'lin': linear
+    """
+    fname = 'interpolate_2D'
+
+    if zorigvs0 == 'h':
+        print fname + '_____________________________________________________________'
+        print interpolate_2D.__doc__
+        quit()
+
+    Ninv = len(zintvs)
+    if zdim == 0:
+        varv = varv0
+        zorigvs = zorigvs0
+    else:
+        varv = np.transpose(varv0)
+        zorigvs = np.transpose(zorigvs0)
+
+    dimv = varv.shape
+
+# Sense of the original z-variable
+    Lzorig = zorigvs.shape[0]
+    incz = zorigvs[Lzorig-1,0] - zorigvs[0,0]
+
+    varin = np.zeros((Ninv,dimv[1]), dtype=np.float)
+
+    for ilev in range(Ninv):
+        valinf = np.zeros((dimv[1]), dtype=np.float)
+        valsup = np.zeros((dimv[1]), dtype=np.float)
+        zorigv = np.zeros((2,dimv[1]), dtype=np.float)
+        for i in range(valinf.shape[0]):   
+            if np.min(zorigvs[:,i]) > zintvs[ilev] and incz > 0.:
+                valinf[i] = varv[0,i]
+                valsup[i] = varv[1,i]
+                zorigv[0,i] = zorigvs[0,i]
+                zorigv[1,i] = zorigvs[1,i]
+            elif np.max(zorigvs[:,i]) < zintvs[ilev] and incz < 0.:
+                valinf[i] = varv[0,i]
+                valsup[i] = varv[1,i]
+                zorigv[0,i] = zorigvs[0,i]
+                zorigv[1,i] = zorigvs[1,i]
+            elif np.max(zorigvs[:,i]) < zintvs[ilev] and incz > 0.:
+                valinf[i] = varv[Lzorig-2,i]
+                valsup[i] = varv[Lzorig-1,i]
+                zorigv[0,i] = zorigvs[Lzorig-2,i]
+                zorigv[1,i] = zorigvs[Lzorig-1,i]
+            elif np.min(zorigvs[:,i]) > zintvs[ilev] and incz < 0.:
+                valinf[i] = varv[Lzorig-2,i]
+                valsup[i] = varv[Lzorig-1,i]
+                zorigv[0,i] = zorigvs[Lzorig-2,i]
+                zorigv[1,i] = zorigvs[Lzorig-1,i]
+            else:
+                for z in range(Lzorig-1):
+                    if (zorigvs[z,i]-zintvs[ilev])*(zorigvs[z+1,i]-                  \
+                      zintvs[ilev]) <= 0.:
+                        valinf[i] = varv[z,i]
+                        valsup[i] = varv[z+1,i]
+                        zorigv[0,i] = zorigvs[z,i]
+                        zorigv[1,i] = zorigvs[z+1,i]
+                        break
+
+        varin[ilev,:] = vertical_interpolation(valinf,valsup,zorigv,                 \
+          zintvs[ilev], kint)
+
+    if zdim == 0:
+        varin0 = varin
+    else:
+        varin0 = np.transpose(varin)
+
+    return varin0
+
+
+def list_toVec(listv, kind):
+    """ Function to transform from a list of values to a vector
+    list_toVec(listv, kind)
+      listv= list with the values 
+      kind= kind of values
+      >>> list_toVec(['1', 2, '3', 4, 5, '6.9', 7, 9], 'npfloat')
+      [ 1.   2.   3.   4.   5.   6.9  7.   9. ]
+    """
+
+    fname = 'list_toVec'
+
+    if listv == 'h':
+        print fname + '_____________________________________________________________'
+        print list_toVec.__doc__
+        quit()
+
+    Nvals = len(listv)
+
+    if kind == 'npfloat':
+        vecv = np.zeros((Nvals), dtype=np.float)
+        for iv in range(Nvals):
+            vecv[iv] = np.float(listv[iv])
+    else:
+        print errormsg
+        print '  ' + fname + ': type of value "' + kind + '" not ready!!'
+        quit(-1)
+
+    return vecv
+
+def running_mean(values, run):
+    """ Function to compute a running mean of a series of values
+      running_mean(vals, int)
+      [vals]: series of values
+      [run]: interval to use to compute the running mean 
+        NOTE: resultant size would be the same but with None except at [run/2,size(vals)-run/2]
+      >>> running_mean(np.arange(100),10)
+      [None None None None None 4.5 5.5 6.5 7.5 8.5 9.5 10.5 11.5 12.5 13.5 14.5
+       15.5 16.5 17.5 18.5 19.5 20.5 21.5 22.5 23.5 24.5 25.5 26.5 27.5 28.5 29.5
+       30.5 31.5 32.5 33.5 34.5 35.5 36.5 37.5 38.5 39.5 40.5 41.5 42.5 43.5 44.5
+       45.5 46.5 47.5 48.5 49.5 50.5 51.5 52.5 53.5 54.5 55.5 56.5 57.5 58.5 59.5
+       60.5 61.5 62.5 63.5 64.5 65.5 66.5 67.5 68.5 69.5 70.5 71.5 72.5 73.5 74.5
+       75.5 76.5 77.5 78.5 79.5 80.5 81.5 82.5 83.5 84.5 85.5 86.5 87.5 88.5 89.5
+       90.5 91.5 92.5 93.5 None None None None None]
+    """
+    fname = 'running_mean'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print running_mean.__doc__
+        quit()
+
+    runmean = np.ones((len(values)), dtype=np.float)*fillValue
+
+    for ip in range(run/2,len(values)-run/2):
+        runmean[ip] = np.mean(values[ip-run/2:ip+run/2])
+
+    runmean = np.where(runmean == fillValue, None, runmean)
+
+    return runmean
+
+def slice_variable(varobj, dimslice):
+    """ Function to return a slice of a given variable according to values to its 
+      dimensions
+    slice_variable(varobj, dims)
+      varobj= object wit the variable
+      dimslice= [[dimname1]:[value1]|[[dimname2]:[value2], ...] pairs of dimension 
+        [value]: 
+          * [integer]: which value of the dimension
+          * -1: all along the dimension
+          * [beg]:[end] slice from [beg] to [end]
+    """
+    fname = 'slice_variable'
+
+    if varobj == 'h':
+        print fname + '_____________________________________________________________'
+        print slice_variable.__doc__
+        quit()
+
+    vardims = varobj.dimensions
+    Ndimvar = len(vardims)
+
+    Ndimcut = len(dimslice.split('|'))
+    dimsl = dimslice.split('|')
+
+    varvalsdim = []
+    dimnslice = []
+
+    for idd in range(Ndimvar):
+        for idc in range(Ndimcut):
+            dimcutn = dimsl[idc].split(':')[0]
+            dimcutv = dimsl[idc].split(':')[1]
+            if vardims[idd] == dimcutn: 
+                posfrac = dimcutv.find(':')
+                if posfrac != -1:
+                    inifrac = int(dimcutv.split(':')[0])
+                    endfrac = int(dimcutv.split(':')[1])
+                    varvalsdim.append(slice(inifrac,endfrac))
+                    dimnslice.append(vardims[idd])
+                else:
+                    if int(dimcutv) == -1:
+                        varvalsdim.append(slice(0,varobj.shape[idd]))
+                        dimnslice.append(vardims[idd])
+                    else:
+                        varvalsdim.append(int(dimcutv))
+                break
+
+    varvalues = varobj[tuple(varvalsdim)]
+
+    return varvalues, dimnslice
+
+def operation_alongdims(ovar,dimvals,dimsoper,opkind):
+    """ Function to operate along different dimensions of a variable
+    operation_alongdims(ovar,dimvals,opkind)
+      ovar= netCDF variable object
+      dimvals= [dimname1]:[val1]|[dimdname2]:[val2]|[...[dimnameN]:[valN]]
+        [value]: 
+          * [integer]: which value of the dimension
+          * -1: all along the dimension
+          * [beg]:[end] slice from [beg] to [end]
+      dimsoper= [dimname1]:[dimname2]:[...[dimnameN]] names of the dimensions along 
+        which operation has to be done
+      opkind= operation to perform along the dimensions with a range: max, mean, 
+        mean2, min, sum
+    """
+
+    fname = 'operation_alongdims'
+
+    if ovar == 'h':
+        print fname + '_____________________________________________________________'
+        print operation_alongdims.__doc__
+        quit()
+
+    vardims = ovar.dimensions
+    Nvardims = len(vardims)
+
+    cutdims = dimvals.split('|')
+    Ncutdims = len(cutdims)
+
+    if Nvardims != Ncutdims:
+        print errormsg
+        print '  ' + fname + ': cutting for',Ncutdims,'but variable has:',Nvardims,  \
+          '!!'
+        quit(-1)
+
+    for idc in range(Ncutdims):
+        found = False
+        for idv in range(Nvardims):
+            if vardims[idv] == cutdims[idc].split(':')[0]:
+                found = True
+                break
+        if not found:
+            print errormsg
+            print '  ' + fname + ": cutting by '",cutdims[idc].split(':')[0],        \
+              "' but variable has not it !!!"
+            print '  variable dims:',vardims
+            quit(-1)
+
+    slicedvar, dimslice = slice_variable(ovar, dimvals)
+
+# operation
+    dimnsoper = dimsoper.split(':')
+
+    if opkind == 'mean2':
+        origvar = slicedvar*slicedvar
+    else:
+        origvar = slicedvar.copy()
+
+    dimsnewvar = []
+    Ndimslice = len(dimslice)
+    Ndimsoper = len(dimnsoper)
+    noper=0
+    for ids in range(Ndimslice):
+        found = False
+        for ido in range(Ndimsoper):
+            if dimslice[ids] == dimnsoper[ido]:
+                if opkind == 'max':
+                    varoper = np.max(origvar, axis=ids-noper)
+                elif opkind == 'mean':
+                    varoper = np.mean(origvar, axis=ids-noper)
+                elif opkind == 'mean2':
+                    varoper = np.mean(origvar, axis=ids-noper)
+                elif opkind == 'min':
+                    varoper = np.min(origvar, axis=ids-noper)
+                elif opkind == 'sum':
+                    varoper = np.sum(origvar, axis=ids-noper)
+                else:
+                    print errormsg
+                    print '  ' + fname + ': operation "' + opkind + '" not ready!!'
+                    quit(-1)
+
+                del(origvar)
+                origvar = varoper.copy()
+                noper = noper + 1
+                found = True
+                break
+        if not found: dimsnewvar.append(dimslice[ids])
+
+    return origvar, dimsnewvar
+
+def file_oper_alongdims(values, ncfile, varn):
+    """ Function to operate a file along different dimensions of a variable
+    file_oper_alongdims(values, ncfile, varn)
+      values= [dimvals],[dimsoper],[opkind],[dimvn]
+        [dimvals]; [dimname1]:[val1]|[dimdname2]:[val2]|[...[dimnameN]:[valN]]
+          [value]; 
+            * [integer]: which value of the dimension
+            * -1: all along the dimension
+            * [beg]:[end] slice from [beg] to [end]
+        [dimsoper]; [dimname1]:[dimname2]:[...[dimnameN]] names of the dimensions along 
+          which operation has to be done
+        [opkind]; operation to perform along the dimensions with a range: max, mean, 
+          mean2, min, sum
+        [dimvn]; [varname1]:[varname2]:[...[varnameM]] variables with the values of the 
+          dimensions of the resultant operation
+      ncfile= netCDF file
+      varn= variable name
+    """
+
+    fname = 'file_oper_alongdims'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print file_oper_alongdims.__doc__
+        quit()
+
+    dimvals = values.split(',')[0]
+    dimsoper = values.split(',')[1]
+    operkind = values.split(',')[2]
+    dimvn = values.split(',')[3]
+
+    ofile = 'file_oper_alongdims_' + operkind + '.nc'
+
+    objnc = NetCDFFile(ncfile, 'r')
+
+    if not objnc.variables.has_key(varn):
+        print errormsg
+        print '  ' + fname + ': netCDF file "' + ncfile +                            \
+          '" does not have variable "' + varn + '" !!!!'
+        quit(-1)
+
+    objvar = objnc.variables[varn]
+
+    newvarv, newvardimns = operation_alongdims(objvar,dimvals,dimsoper,operkind)
+
+    print 'dimsoper:',dimsoper
+    print 'newvar shape',newvarv.shape,'newvardims:',newvardimns
+
+# Creation of output file
+##
+
+    objnewnc = NetCDFFile(ofile, 'w')
+
+# Dimensions
+    for idim in range(len(newvardimns)):
+        objdim = objnc.dimensions[newvardimns[idim]]
+        if objdim.isunlimited():
+            objnewnc.createDimension(newvardimns[idim], None)
+        else:
+            objnewnc.createDimension(newvardimns[idim], len(objdim))
+
+# Variables with dimension values
+    vardims = dimvn.split(':')
+    for ivdim in range(len(vardims)):
+        objvdim = objnc.variables[vardims[ivdim]]
+        dimsvdim = objvdim.dimensions
+        dimvslice = []
+        dimvdims = []
+        for idmvd in range(len(dimsvdim)):
+            found = False
+            for idimv in range(len(newvardimns)):
+                if dimsvdim[idmvd] == newvardimns[idimv]:
+                    dimvslice.append(slice(0,objvdim.shape[idmvd]))
+                    dimvdims.append(dimsvdim[idmvd])
+                    found = True
+                    break
+            if not found: dimvslice.append(len(objnc.dimensions[dimsvdim[idmvd]])/2)
+
+        newvar = objnewnc.createVariable(vardims[ivdim], 'f8', tuple(dimvdims))
+        newvar[:] = objvdim[tuple(dimvslice)]
+        dimvattrs = objvdim.ncattrs()
+        for attrn in dimvattrs:
+            attrv = objvdim.getncattr(attrn)
+            newattr = set_attribute(newvar,attrn,attrv)
+
+# new variable
+    oldvarattr = objvar.ncattrs()
+
+    varname = variables_values(varn)[0]
+    if searchInlist(oldvarattr, 'standard_name'):
+        stdname = objvar.getncattr('standard_name')
+    else:
+        stdname = variables_values(varn)[1]
+
+    if searchInlist(oldvarattr, 'long_name'):
+        lname = objvar.getncattr('long_name')
+    else:
+        lname = variables_values(varn)[4].replace('|',' ')
+
+    if searchInlist(oldvarattr, 'units'):
+        uname = objvar.getncattr('units')
+    else:
+        uname = variables_values(varn)[5]
+
+    dimsoperS = numVector_String(dimsoper.split(':'),', ')
+
+    newvar = objnewnc.createVariable(varname + operkind, 'f4', tuple(newvardimns))
+    newattr = basicvardef(newvar, stdname + operkind, lname + ' '+  operkind +       \
+      ' along ' + dimsoperS, uname)
+
+    newvar[:] = newvarv
+    for idim in range(len(objvar.shape)):
+        dimn = dimvals.split('|')[idim].split(':')[0]
+        dimv = '{:d}'.format(len(objnc.dimensions[dimn]))
+        if idim == 0:
+            origdimsS = dimn + '(' + dimv + ')'
+        else:
+            origdimsS = origdimsS + ' ' + dimn + '(' + dimv + ')'
+
+
+    newattr = set_attribute(newvar, 'orig_dimensions', origdimsS)
+
+# global attributes
+    objnewnc.setncattr('author', 'L. Fita')
+    objnewnc.setncattr('institution', 'Laboratire de Meteorologie Dynamique')
+    objnewnc.setncattr('university', 'Pierre Marie Curie - Jussieu')
+    objnewnc.setncattr('center', 'Centre National de Recherches Scientifiques')
+    objnewnc.setncattr('city', 'Paris')
+    objnewnc.setncattr('country', 'France')
+    objnewnc.setncattr('script', 'nc_var_tools.py')
+    objnewnc.setncattr('function', 'file_oper_alongdims')
+    objnewnc.setncattr('version', '1.0')
+    objnewnc.setncattr('data_file', ncfile)
+
+    gorigattrs = objnc.ncattrs()
+    for attr in gorigattrs:
+        attrv = objnc.getncattr(attr)
+        atvar = set_attribute(objnewnc, attr, attrv)
+
+    objnc.close()
+
+    objnewnc.sync()
+    objnewnc.close()
+
+    print '  ' + fname + ': successful creation of file "' + ofile + '" !!!'
+
+    return 
+
+#file_oper_alongdims('time:-1|z:-1|x:-1|y:-1,time:y,mean,pressure:lat', '/home/lluis/etudes/WRF_LMDZ/WaquaL/WRF_LMDZ/AR40/vertical_interpolation_WRFp.nc', 'WRFt')
+
+
+def variables_values(varName):
+    """ Function to provide values to plot the different variables
+    variables_values(varName)
+      [varName]= name of the variable
+        return: [var name], [std name], [minimum], [maximum], 
+          [long name]('|' for spaces), [units], [color palette] (following: 
+          http://matplotlib.org/1.3.1/examples/color/colormaps_reference.html)
+     [varn]: original name of the variable
+       NOTE: It might be better doing it with an external ASII file. But then we 
+         got an extra dependency...
+    >>> variables_values('WRFght')
+    ['z', 'geopotential_height', 0.0, 80000.0, 'geopotential|height', 'm2s-2', 'rainbow']
+    """
+    fname='variables_values'
+
+    if varName == 'h':
+        print fname + '_____________________________________________________________'
+        print variables_values.__doc__
+        quit()
+
+# Variable name might come with a statistical surname...
+    stats = ['min','max','mean','stdv','turb']
+    statsLong = {'min':'minimum', 'max':'maximum', 'mean':'mean',                    \
+      'stdv':'standard deviation', 'turb':'turbulence'}
+
+    ifst = False
+    for st in stats:
+        if varName.find(st) > -1:
+            print '    '+ fname + ": varibale '" + varName + "' with a statistical "+\
+              " surname: '",st,"' !!"
+            Lst = len(st)
+            LvarName = len(varName)
+            varn = varName[0:LvarName - Lst]
+            ifst = True
+            stname = st
+            break
+    if not ifst:
+        varn = varName
+
+    if varn[0:6] == 'varDIM': 
+# Variable from a dimension (all with 'varDIM' prefix)
+        Lvarn = len(varn)
+        varvals = [varn[6:Lvarn+1], varn[6:Lvarn+1], 0., 1.,                         \
+          "variable|from|size|of|dimension|'" + varn[6:Lvarn+1] + "'", '1', 'rainbox']
+    elif varn == 'a_tht' or varn == 'LA_THT':
+        varvals = ['a_th', 'total_thermal_plume_cover', 0., 1.,                      \
+        'total|column|thermal|plume|cover', '1', 'YlGnBu']
+    elif varn == 'bils' or varn == 'LBILS':
+        varvals = ['bils', 'surface_total_heat_flux', -100., 100.,                   \
+          'surface|total|heat|flux', 'Wm-2', 'seismic']
+    elif varn == 'landcat' or varn == 'category':
+        varvals = ['landcat', 'land_categories', 0., 22., 'land|categories', '1',    \
+          'rainbow']
+    elif varn == 'c' or varn == 'QCLOUD' or varn == 'oliq' or varn == 'OLIQ':
+        varvals = ['c', 'condensed_water_mixing_ratio', 0., 3.e-4,                   \
+          'condensed|water|mixing|ratio', 'kgkg-1', 'BuPu']
+    elif varn == 'clt' or varn == 'CLT' or varn == 'cldt' or                         \
+      varn == 'Total cloudiness':
+        varvals = ['clt', 'cloud_area_fraction', 0., 1., 'total|cloud|cover', '1',   \
+          'gist_gray']
+    elif varn == 'cll' or varn == 'cldl' or varn == 'LCLDL' or                       \
+      varn == 'Low-level cloudiness':
+        varvals = ['cll', 'low_level_cloud_area_fraction', 0., 1.,                   \
+          'low|level|(p|>|680|hPa)|cloud|fraction', '1', 'gist_gray']
+    elif varn == 'clm' or varn == 'cldm' or varn == 'LCLDM' or                       \
+      varn == 'Mid-level cloudiness':
+        varvals = ['clm', 'mid_level_cloud_area_fraction', 0., 1.,                   \
+          'medium|level|(440|<|p|<|680|hPa)|cloud|fraction', '1', 'gist_gray']
+    elif varn == 'clh' or varn == 'cldh' or varn == 'LCLDH' or                       \
+      varn == 'High-level cloudiness':
+        varvals = ['clh', 'high_level_cloud_area_fraction', 0., 1.,                  \
+          'high|level|(p|<|440|hPa)|cloud|fraction', '1', 'gist_gray']
+    elif varn == 'dqajs' or varn == 'LDQAJS':
+        varvals = ['dqajs', 'dry_adjustment_water_vapor_tendency', -0.0003, 0.0003,  \
+        'dry|adjustment|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqcon' or varn == 'LDQCON':
+        varvals = ['dqcon', 'convective_water_vapor_tendency', -3e-8, 3.e-8,         \
+        'convective|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqdyn' or varn == 'LDQDYN':
+        varvals = ['dqdyn', 'dynamics_water_vapor_tendency', -3.e-7, 3.e-7,          \
+        'dynamics|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqeva' or varn == 'LDQEVA':
+        varvals = ['dqeva', 'evaporation_water_vapor_tendency', -3.e-6, 3.e-6,       \
+        'evaporation|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqlscst' or varn == 'LDQLSCST':
+        varvals = ['dqlscst', 'stratocumulus_water_vapor_tendency', -3.e-7, 3.e-7,   \
+        'stratocumulus|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqlscth' or varn == 'LDQLSCTH': 
+        varvals = ['dqlscth', 'thermals_water_vapor_tendency', -3.e-7, 3.e-7,        \
+        'thermal|plumes|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqlsc' or varn == 'LDQLSC':
+        varvals = ['dqlsc', 'condensation_water_vapor_tendency', -3.e-6, 3.e-6,      \
+        'condensation|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqphy' or varn == 'LDQPHY':
+        varvals = ['dqphy', 'physics_water_vapor_tendency', -3.e-7, 3.e-7,           \
+        'physics|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqthe' or varn == 'LDQTHE':
+        varvals = ['dqthe', 'thermals_water_vapor_tendency', -3.e-7, 3.e-7,          \
+        'thermal|plumes|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqvdf' or varn == 'LDQVDF':
+        varvals = ['dqvdf', 'vertical_difussion_water_vapor_tendency', -3.e-8, 3.e-8,\
+        'vertical|difussion|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dqwak' or varn == 'LDQWAK':
+        varvals = ['dqwak', 'wake_water_vapor_tendency', -3.e-7, 3.e-7,              \
+        'wake|water|vapor|tendency', 'kg/kg/s', 'seismic']
+    elif varn == 'dtajs' or varn == 'LDTAJS':
+        varvals = ['dtajs', 'dry_adjustment_thermal_tendency', -3.e-5, 3.e-5,        \
+        'dry|adjustment|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtcon' or varn == 'LDTCON':
+        varvals = ['dtcon', 'convective_thermal_tendency', -3.e-5, 3.e-5,            \
+        'convective|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtdyn' or varn == 'LDTDYN':
+        varvals = ['dtdyn', 'dynamics_thermal_tendency', -3.e-4, 3.e-4,              \
+        'dynamics|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dteva' or varn == 'LDTEVA':
+        varvals = ['dteva', 'evaporation_thermal_tendency', -3.e-3, 3.e-3,           \
+        'evaporation|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtlscst' or varn == 'LDTLSCST':
+        varvals = ['dtlscst', 'stratocumulus_thermal_tendency', -3.e-4, 3.e-4,       \
+        'stratocumulus|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtlscth' or varn == 'LDTLSCTH':
+        varvals = ['dtlscth', 'thermals_thermal_tendency', -3.e-4, 3.e-4,            \
+        'thermal|plumes|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtlsc' or varn == 'LDTLSC':
+        varvals = ['dtlsc', 'condensation_thermal_tendency', -3.e-3, 3.e-3,          \
+        'condensation|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtphy' or varn == 'LDTPHY':
+        varvals = ['dtphy', 'physics_thermal_tendency', -3.e-4, 3.e-4,               \
+        'physics|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtthe' or varn == 'LDTTHE':
+        varvals = ['dtthe', 'thermals_thermal_tendency', -3.e-4, 3.e-4,              \
+        'thermal|plumes|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtvdf' or varn == 'LDTVDF':
+        varvals = ['dtvdf', 'vertical_difussion_thermal_tendency', -3.e-5, 3.e-5,    \
+        'vertical|difussion|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'dtwak' or varn == 'LDTWAK':
+        varvals = ['dtwak', 'wake_thermal_tendency', -3.e-4, 3.e-4,                  \
+        'wake|thermal|tendency', 'K/s', 'seismic']
+    elif varn == 'evspsbl' or varn == 'LEVAP' or varn == 'evap':
+        varvals = ['evspsbl', 'water_evaporation_flux', 0., 1.5e-4,                  \
+          'water|evaporation|flux', 'kgm-2s-1', 'Blues']
+    elif varn == 'h2o' or varn == 'LH2O':
+        varvals = ['h2o', 'water_mass_fraction', 0., 3.e-2,                          \
+          'mass|fraction|of|water', '1', 'Blues']
+    elif varn == 'hfls' or varn == 'LH' or varn == 'LFLAT' or varn == 'flat':
+        varvals = ['hfls', 'surface_upward_latent_heat_flux', -400., 400.,           \
+          'upward|latnt|heat|flux|at|the|surface', 'Wm-2', 'seismic']
+    elif varn == 'hfss' or varn == 'LSENS' or varn == 'sens':
+        varvals = ['hfss', 'surface_upward_sensible_heat_flux', -150., 150.,         \
+          'upward|sensible|heat|flux|at|the|surface', 'Wm-2', 'seismic']
+    elif varn == 'hus' or varn == 'WRFrh' or varn == 'LMDZrh' or varn == 'rhum' or   \
+      varn == 'LRHUM':
+        varvals = ['hus', 'specific_humidity', 0., 1., 'specific|humidty', '1',      \
+          'BuPu']
+    elif varn == 'huss' or varn == 'WRFrhs' or varn == 'LMDZrhs' or varn == 'rh2m' or\
+      varn == 'LRH2M':
+        varvals = ['huss', 'specific_humidity', 0., 1., 'specific|humidty|at|2m',    \
+          '1', 'BuPu']
+    elif varn == 'lat' or varn == 'XLAT' or varn == 'XLAT_M' or varn == 'latitude':
+        varvals = ['lat', 'latitude', -90., 90., 'latitude', 'degrees North',        \
+          'seismic']
+    elif varn == 'lon' or varn == 'XLONG' or varn == 'XLONG_M':
+        varvals = ['lon', 'longitude', -180., 180., 'longitude', 'degrees East',     \
+          'seismic']
+    elif varn == 'longitude':
+        varvals = ['lon', 'longitude', 0., 360., 'longitude', 'degrees East',        \
+          'seismic']
+    elif varn == 'orog' or varn == 'HGT' or varn == 'HGT_M':
+        varvals = ['orog', 'orography',  0., 3000., 'surface|altitude', 'm','terrain']
+    elif varn == 'pr' or varn == 'RAINTOT' or varn == 'precip' or                    \
+      varn == 'LPRECIP' or varn == 'Precip Totale liq+sol':
+        varvals = ['pr', 'precipitation_flux', 0., 1.e-4, 'precipitation|flux',      \
+          'kgm-2s-1', 'BuPu']
+    elif varn == 'pracc' or varn == 'ACRAINTOT':
+        varvals = ['pracc', 'precipitation_amount', 0., 100.,                        \
+          'accumulated|precipitation', 'kgm-2', 'BuPu']
+    elif varn == 'prc' or varn == 'LPLUC' or varn == 'pluc' or varn == 'WRFprc':
+        varvals = ['prc', 'convective_precipitation_flux', 0., 2.e-4,                \
+          'convective|precipitation|flux', 'kgm-2s-1', 'Blues']
+    elif varn == 'pres' or varn == 'presnivs' or varn == 'pressure':
+        varvals = ['pres', 'air_pressure', 0., 103000., 'air|pressure', 'Pa',        \
+          'Blues']
+    elif varn == 'prls' or varn == 'WRFprls' or varn == 'LPLUL' or varn == 'plul':
+        varvals = ['prls', 'large_scale_precipitation_flux', 0., 2.e-4,              \
+          'large|scale|precipitation|flux', 'kgm-2s-1', 'Blues']
+    elif varn == 'prsn' or varn == 'SNOW' or varn == 'snow' or varn == 'LSNOW':
+        varvals = ['prsn', 'snowfall', 0., 1.e-4, 'snowfall|flux', 'kgm-2s-1', 'BuPu']
+    elif varn == 'prw' or varn == 'WRFprh':
+        varvals = ['prw', 'atmosphere_water_vapor_content', 0., 10.,                 \
+          'water|vapor"path', 'kgm-2', 'Blues']
+    elif varn == 'ps' or varn == 'psfc' or varn =='PSFC' or varn == 'psol' or        \
+      varn == 'Surface Pressure':
+        varvals=['ps', 'surface_air_pressure', 85000., 105400., 'surface|pressure',  \
+          'hPa', 'cool']
+    elif varn == 'psl' or varn == 'mslp' or varn =='WRFmslp':
+        varvals=['psl', 'air_pressure_at_sea_level', 85000., 104000.,                \
+          'mean|sea|level|pressure', 'Pa', 'Greens']
+    elif varn == 'q_th':
+        varvals = ['q_th', 'thermal_plume_total_water_content', 0., 25.,             \
+          'total|water|cotent|in|thermal|plume', 'mm', 'YlOrRd']
+    elif varn == 'r' or varn == 'QVAPOR' or varn == 'ovap' or varn == 'LOVAP':
+        varvals = ['r', 'water_mixing_ratio', 0., 0.03, 'water|mixing|ratio',        \
+          'kgkg-1', 'BuPu']
+    elif varn == 'rsds' or varn == 'SWdnSFC' or varn == 'SWdn at surface' or         \
+      varn == 'SWDOWN':
+        varvals=['rsds', 'surface_downwelling_shortwave_flux_in_air',  0., 1200.,    \
+          'downward|SW|surface|radiation', 'Wm-2' ,'Reds']
+    elif varn == 'rsdsacc':
+        varvals=['rsdsacc', 'accumulated_surface_downwelling_shortwave_flux_in_air', \
+          0., 1200., 'accumulated|downward|SW|surface|radiation', 'Wm-2' ,'Reds']
+    elif varn == 'rvor' or varn == 'WRFrvor':
+        varvals = ['rvor', 'air_relative_vorticity', -2.5E-3, 2.5E-3,                \
+          'air|relative|vorticity', 's-1', 'seismic']
+    elif varn == 'rvors' or varn == 'WRFrvors':
+        varvals = ['rvors', 'surface_air_relative_vorticity', -2.5E-3, 2.5E-3,       \
+          'surface|air|relative|vorticity', 's-1', 'seismic']
+    elif varn == 's_therm' or varn == 'LS_THERM':
+        varvals = ['s_therm', 'thermals_excess', 0., 0.8, 'thermals|excess', 'K',    \
+          'Reds']
+    elif varn == 's_therm' or varn == 'LS_THERM':
+        varvals = ['s_therm', 'thermals_excess', 0., 0.8, 'thermals|excess', 'K',    \
+          'Reds']
+    elif varn == 'ta' or varn == 'WRFt' or varn == 'temp' or varn == 'LTEMP' or      \
+      varn == 'Air temperature':
+        varvals = ['ta', 'air_temperature', 195., 320., 'air|temperature', 'K',      \
+          'YlOrRd']
+    elif varn == 'tas' or varn == 'T2' or varn == 't2m' or varn == 'T2M' or          \
+      varn == 'Temperature 2m':
+        varvals = ['tas', 'air_temperature', 240., 310., 'air|temperature|at|2m', '  \
+          K', 'YlOrRd']
+    elif varn == 'tds' or varn == 'TH2':
+        varvals = ['tds', 'air_dew_point_temperature', 240., 310.,                   \
+          'air|dew|point|temperature|at|2m', 'K', 'YlGnBu']
+    elif varn == 'time'or varn == 'time_counter':
+        varvals = ['time', 'time', 0., 1000., 'time',                                \
+          'hours|since|1949/12/01|00:00:00', 'Reds']
+    elif varn == 'ua' or varn == 'vitu' or varn == 'U' or varn == 'Zonal wind' or    \
+      varn == 'LVITU':
+        varvals = ['ua', 'eastward_wind', -30., 30., 'eastward|wind', 'ms-1',        \
+          'seismic']
+    elif varn == 'uas' or varn == 'u10m' or varn == 'U10' or varn =='Vent zonal 10m':
+        varvals = ['uas', 'eastward_wind', -30., 30., 'eastward|2m|wind',    \
+          'ms-1', 'seismic']
+    elif varn == 'va' or varn == 'vitv' or varn == 'V' or varn == 'Meridional wind'  \
+      or varn == 'LVITV':
+        varvals = ['va', 'northward_wind', -30., 30., 'northward|wind', 'ms-1',      \
+          'seismic']
+    elif varn == 'vas' or varn == 'v10m' or varn == 'V10' or                         \
+      varn =='Vent meridien 10m':
+        varvals = ['vas', 'northward_wind', -30., 30., 'northward|2m|wind', 'ms-1',  \
+          'seismic']
+    elif varn == 'wake_h' or varn == 'LWAKE_H':
+        varvals = ['wake_h', 'wake_height', 0., 1000., 'height|of|the|wakes', 'm',   \
+          'YlOrRd']
+    elif varn == 'wake_s' or varn == 'LWAKE_S':
+        varvals = ['wake_s', 'wake_area_fraction', 0., 0.5, 'wake|spatial|fraction', \
+          '1', 'BuGn']
+    elif varn == 'wa' or varn == 'W' or varn == 'Vertical wind':
+        varvals = ['wa', 'upward_wind', -10., 10., 'upward|wind', 'ms-1',            \
+          'seismic']
+    elif varn == 'wap' or varn == 'vitw' or varn == 'LVITW':
+        varvals = ['wap', 'upward_wind', -3.e-10, 3.e-10, 'upward|wind', 'mPa-1',    \
+          'seismic']
+    elif varn == 'wss' or varn == 'SPDUV':
+        varvals = ['wss', 'air_velocity',  0., 30., 'surface|horizontal|wind|speed', \
+          'ms-1', 'Reds']
+    elif varn == 'xtime' or varn == 'XTIME':
+        varvals = ['xtime', 'time',  0., 1.e5, 'time',                               \
+          'minutes|since|simulation|start', 'Reds']
+    elif varn == 'x' or varn == 'X':
+        varvals = ['x', 'x',  0., 100., 'x', '-', 'Reds']
+    elif varn == 'y' or varn == 'Y':
+        varvals = ['y', 'y',  0., 100., 'y', '-', 'Blues']
+    elif varn == 'z' or varn == 'Z':
+        varvals = ['z', 'z',  0., 100., 'z', '-', 'Greens']
+    elif varn == 'zg' or varn == 'WRFght' or varn == 'Geopotential height' or        \
+      varn == 'geop' or varn == 'LGEOP':
+        varvals = ['zg', 'geopotential_height', 0., 80000., 'geopotential|height',   \
+          'm2s-2', 'rainbow']
+    elif varn == 'zmax_th' or varn == 'LZMAX_TH':
+        varvals = ['zmax_th', 'thermal_plume_height', 0., 4000.,                     \
+          'maximum|thermals|plume|height', 'm', 'YlOrRd']
+    elif varn == 'zmla' or varn == 's_pblh' or varn == 'LS_PBLH':
+        varvals = ['zmla', 'atmosphere_boundary_layer_thickness', 0., 2500.,         \
+          'atmosphere|boundary|layer|thickness', 'm', 'Blues']
+    else:
+        print errormsg
+        print '  ' + fname + ': variable ' + varn + ' not defined !!!'
+        quit(-1)
+
+    if ifst: 
+      varvals[0] = varvals[0] + stname
+## Should be already there
+#      varvals[4] = varvals[4] + statsLong[stname]
+
+    return varvals
+
+def WRF_CFtime_creation(values, ncfile, varn):
+    """ Function to add a CF-convention time unit in a WRF file
+    WRF_CFtime_creation(values, ncfile, varn)
+      [values]= [refdate],[units] 
+        [refdate]: reference date to compute the times in 
+          [YYYY][MM][DD][HH][MI][SS] format
+        [units]: time units to use: 'days','hours','minutes','seconds'
+      [ncfile]= WRF file to add the CF-convention time variable
+      [varn]= name of the variable time to add
+    """
+    fname='WRF_CFtime_creation'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print WRF_CFtime_creation.__doc__
+        quit()
+
+    refdate=values.split(',')[0]
+    tunitsval=values.split(',')[1]
+
+    wrfnc = NetCDFFile(ncfile, 'a')
+
+    if wrfnc.variables.has_key(varn):
+        print errormsg
+        print '  ' + fname + ": WRF file '" + ncfile + "' already has variable '" +  \
+          varn + "' !!!"
+        quit(-1)
+
+    timeobj = wrfnc.variables['Times']
+    timewrfv = timeobj[:]
+
+    yrref=refdate[0:4]
+    monref=refdate[4:6]
+    dayref=refdate[6:8]
+    horref=refdate[8:10]
+    minref=refdate[10:12]
+    secref=refdate[12:14]
+
+    refdateS = yrref + '/' + monref + '/' + dayref + '_' + horref + ':' + minref +   \
+      ':' + secref
+
+    dt = timeobj.shape[0]
+    cftimes = np.zeros((dt), dtype=np.float)
+
+    for it in range(dt):
+        wrfdates = datetimeStr_conversion(timewrfv[it,:],'WRFdatetime', 'matYmdHMS')
+        cftimes[it] = realdatetime1_CFcompilant(wrfdates, refdate, tunitsval)
+
+    tunits = tunitsval + ' since ' + refdateS
+
+    newvar = wrfnc.createVariable('time','f4',('Time'))
+    newattr = basicvardef(newvar, 'time','time',tunits)
+    newvar[:] = cftimes
+    newattr = set_attribute(newvar, 'calendar', 'standard')
+
+    wrfnc.sync()
+    wrfnc.close()
+
+    return
+
+#WRF_CFtime_creation('19491201000000,hours', 'wrfout_d01_1995-01-15_00:00:00', 'time')
+
+def WRF_CFxtime_creation(values, ncfile, varn):
+    """ Function to add a CF-convention time unit in a WRF file using variable 'XTIME'
+    WRF_CFxtime_creation(values, ncfile, varn)
+      [values]= [refdate],[units] 
+        [refdate]: reference date to compute the times in 
+          [YYYY][MM][DD][HH][MI][SS] format
+        [units]: time units to use: 'days','hours','minutes','seconds'
+      [ncfile]= WRF file to add the CF-convention time variable
+      [varn]= name of the variable time to add
+    """
+    fname='WRF_CFxtime_creation'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print WRF_CFxtime_creation.__doc__
+        quit()
+
+    refdate=values.split(',')[0]
+    tunitsval=values.split(',')[1]
+
+    wrfnc = NetCDFFile(ncfile, 'a')
+
+    if  not wrfnc.variables.has_key('XTIME'):
+        print errormsg
+        print '  ' + fname + ": WRF file '" + ncfile + "' does not have variable '" +\
+          "XTIME' !!"
+        quit(-1)
+
+    if wrfnc.variables.has_key(varn):
+        print warnmsg
+        print '  ' + fname + ": WRF file '" + ncfile + "' already has variable '" +  \
+          varn + "' !!!"
+        print '    over-writting values'
+
+    if not searchInlist(wrfnc.ncattrs(), 'SIMULATION_START_DATE'):
+        print errormsg
+        print '  ' + fname + ": WRF file '" + ncfile + "' does not have attribute '"+\
+          "'SIMULATION_START_DATE' !!!"
+        quit(-1)
+ 
+    startdate = wrfnc.SIMULATION_START_DATE
+
+    timeobj = wrfnc.variables['XTIME']
+    timewrfv = timeobj[:]
+
+    yrref=refdate[0:4]
+    monref=refdate[4:6]
+    dayref=refdate[6:8]
+    horref=refdate[8:10]
+    minref=refdate[10:12]
+    secref=refdate[12:14]
+
+    refdateS = yrref + '-' + monref + '-' + dayref + '_' + horref + ':' + minref +   \
+      ':' + secref
+
+    dt = timeobj.shape[0]
+    cftimes = np.zeros((dt), dtype=np.float)
+
+    for it in range(dt):
+        wrfdates = datetimeStr_conversion(str(timewrfv[it]) +',minutes since ' +     \
+          startdate, 'cfTime', 'matYmdHMS') 
+        cftimes[it] = realdatetime1_CFcompilant(wrfdates, refdate, tunitsval)
+
+    tunits = tunitsval + ' since ' + refdateS
+
+    if wrfnc.variables.has_key('time'):
+        newvar = wrfnc.variables['time']
+    else:
+        newvar = wrfnc.createVariable('time','f4',('Time'))
+
+    newattr = basicvardef(newvar, 'time','time',tunits)
+    newvar[:] = cftimes
+    newattr = set_attribute(newvar, 'calendar', 'standard')
+
+    wrfnc.sync()
+    wrfnc.close()
+
+    return
+
+def insert_variable(onc, varn, varv, vardims, varvdims, onewnc):
+    """ Function to insert a variable in an existing file
+    insert_variable(onc, varn, varv, vardims, onewnc)
+      [onc]= object of the original file 
+      [varn]= name of the variable
+      [varv]= values of the variable
+      [vardims]= dimension names of the variable
+      [varvdims]= name of the variables with the values of the dimensions
+      [onewnc]= object of the new file
+    """
+
+    fname = 'insert_variable'
+
+    if onc == 'h':
+        print fname + '_____________________________________________________________'
+        print insert_variable.__doc__
+        quit()
+
+    ininewncdims = onewnc.dimensions
+    ininewncvars = onewnc.variables
+
+# Creation of dimensions
+    for idim in vardims:
+        if not ininewncdims.has_key(idim):
+            if not onc.dimensions.has_key(idim):
+                print errormsg
+                print '    ' + fname + ': initial file does not have dimension: "' + \
+                  idim + '"'
+                quit(-1)
+            else:
+                refdimv = onc.dimensions[idim]
+                if refdimv.isunlimited():
+                    dimsize = None
+                else:
+                    dimsize = len(refdimv)
+
+            onewnc.createDimension(idim,  dimsize)
+
+# Variables with dimension values
+    for ivdim in varvdims:
+        if not ininewncvars.has_key(ivdim):
+            if not onc.variables.has_key(ivdim):
+                print errormsg
+                print '    ' + fname + ': initial file does not have variable: "' + \
+                  ivdim + '"'
+                quit(-1)
+            else:
+                refvdimv = onc.variables[ivdim]
+                refvdimvals = refvdimv[:]
+
+            for dmn in refvdimv.dimensions:
+                if not onewnc.dimensions.has_key(dmn):
+                    print 'dmn:',dmn
+                    if onc.dimensions[dmn].isunlimited():
+                        newdim = onewnc.createDimension(dmn, None )
+                    else:
+                        newdim = onewnc.createDimension(dmn,len(onc.dimensions[dmn]))
+
+            newvar = onewnc.createVariable(ivdim, refvdimv.dtype,                    \
+              (refvdimv.dimensions))
+            varattrs = refvdimv.ncattrs()
+            newvar[:] = refvdimvals
+            for attrn in varattrs:
+                attrv = refvdimv.getncattr(attrn)
+                newattr = set_attribute(newvar, attrn, attrv)
+
+# Variable
+    varvalues = variables_values(varn)
+
+    if onewnc.variables.has_key(varvalues[0]):
+        print warnmsg
+        print '  ' + fname + ": file already has variable '" + varvalues[0] + "' !!"
+        print '    re-writting values'
+        newvar = onewnc.variables[varvalues[0]]
+    else:
+        newvar = onewnc.createVariable(varvalues[0], 'f4', (vardims))
+        newattr = basicvardef(newvar, varvalues[1], varvalues[4].replace('|',' '),   \
+          varvalues[5])
+    newvar[:] = varv
+
+    return
+
+def var_dim_dimv(dimvar, dimns, dimvns):
+    """ Function to bring back which variables with the values should be use for a 
+    given variable
+    var_dim_dimv(ovar, dimns, dimvns)
+      [dimvar]= list of the dimensions of the variable
+      [dimns]= names of the list of available dimensions
+      [dimvns]= correspondant name of variables with the values for the dimensions
+    >>> dimsvar = ['t', 'y', 'x']
+    >>> dimnames = ['t', 'z', 'l', 'y' , 'x']
+    >>> dimvarnames =  ['time', 'pressure', 'soil_levels', 'lat' ,' lon']
+    >>> var_dim_dimv(dimsvar, dimnames, dimvarnames)
+    ['time', 'lat', ' lon']
+    """
+    fname = 'var_dim_dimv'
+
+    if dimvar == 'h':
+        print fname + '_____________________________________________________________'
+        print var_dim_dimv.__doc__
+        quit()
+
+    dimvvar = list(dimvns)
+
+    Ndimvar = len(dimvar)
+    Ndimns = len(dimns)
+
+    for indimv in range(Ndimns):
+        for indima in range(Ndimvar):
+            found = False
+            print '  Lluis:',fname,dimns[indimv],dimvar[indima]
+            if dimns[indimv] == dimvar[indima]:
+                found = True
+                break
+        if not found: dimvvar.remove(dimvns[indimv])
+
+    return dimvvar
+
+def WRF_CFlonlat_creation(values, ncfile, varn):
+    """ Function to add a CF-convention longitude/latitude variables in a WRF file
+    WRF_CFlon_creation(values, ncfile, varn)
+      [values]= [lonname],[latname] names of the variables to add (standard names 
+        'longitude', 'latitude')
+      [ncfile]= WRF file to add the CF-convention time variable
+      [varn]= [lonname],[latname] name of the variables to use
+    """
+    fname='WRF_CFlonlat_creation'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print WRF_CFlonlat_creation.__doc__
+        quit()
+
+    cflonn = values.split(',')[0]
+    cflatn = values.split(',')[1]
+
+    wlonn = varn.split(',')[0]
+    wlatn = varn.split(',')[1]
+
+    wrfnc = NetCDFFile(ncfile, 'a')
+
+    if not searchInlist(wrfnc.variables.keys(),wlonn):
+        print errormsg
+        print '  ' + fname + ": file '" + ncfile + "' has not lon variable '" +      \
+          wlonn + "' !!!"
+        quit(-1)
+
+    if  not searchInlist(wrfnc.variables.keys(),wlatn):
+        print errormsg
+        print '  ' + fname + ": file '" + ncfile + "' has not lat variable '" +      \
+          wlatn + "' !!!"
+        quit(-1)
+
+    if  not searchInlist(wrfnc.dimensions.keys(),'west_east'):
+        print errormsg
+        print '  ' + fname + ": file '" + ncfile + "' has not 'west_east' dimension !!!"
+        quit(-1)
+
+    if  not searchInlist(wrfnc.dimensions.keys(),'south_north'):
+        print errormsg
+        print '  ' + fname + ": file '" + ncfile + "' has not 'south_north' dimension !!!"
+        quit(-1)
+
+    lonobj = wrfnc.variables[wlonn]
+    lonv = lonobj[:]
+
+    latobj = wrfnc.variables[wlatn]
+    latv = latobj[:]
+
+    if len(lonv.shape) == 3:
+        cflons = np.zeros((lonv.shape[1],lonv.shape[2]), dtype=np.float)
+        cflons = np.where(lonv[0,:,:] < 0., lonv[0,:,:] + 360., lonv[0,:,:])
+        cflats = np.zeros((latv.shape[1],latv.shape[2]), dtype=np.float)
+        cflats = latv[0,:,:]
+    elif len(lonv.shape) == 2:
+        cflons = np.zeros((lonv.shape), dtype=np.float)
+        cflons = np.where(lonv < 0., lonv + 360., lonv)
+        cflats = latv
+    elif len(lonv.shape) == 1:
+        cflons = np.zeros((lonv.shape), dtype=np.float)
+        cflons = np.where(lonv < 0., lonv + 360., lonv)
+        cflats = latv
+    else:
+        print errormsg
+        print '  ' + fname + ": original longitude variable '" + varn + "' shape:" + \
+          lonv.shape + "not ready !!!"
+        quit(-1)
+
+    if len(lonv.shape) == 3:
+        for ix in range(lonv.shape[2]):
+            print ix, lonv[0,10,ix], cflons[10,ix]
+    elif len(lonv.shape) == 2:
+        for ix in range(lonv.shape[1]):
+            print ix, lonv[10,ix], cflons[10,ix]
+
+    if wrfnc.variables.has_key(cflonn):
+        print warnmsg
+        print '  ' + fname + ": file '" + ncfile + "' already has variable '" +      \
+          cflonn + "' !!!"
+        print '    over-writting values'
+        newvar = wrfnc.variables[cflonn]
+    else:
+        newvar = wrfnc.createVariable(cflonn,'f4',('south_north','west_east'))
+    newattr = basicvardef(newvar, 'longitude','longitude','degrees East')
+    newvar[:] = cflons
+
+    if wrfnc.variables.has_key(cflatn):
+        print warnmsg
+        print '  ' + fname + ": file '" + ncfile + "' already has variable '" +      \
+          cflatn + "' !!!"
+        print '    over-writting values'
+        newvar = wrfnc.variables[cflatn]
+    else:
+        newvar = wrfnc.createVariable(cflatn,'f4',('south_north','west_east'))
+    newattr = basicvardef(newvar, 'latitude','latitude','degrees North')
+    newvar[:] = cflats
+
+    wrfnc.sync()
+    wrfnc.close()
+
+    return
+
+#WRF_CFlon_creation('longitude', 'wrfout_d01_1980-03-01_00:00:00_Time_B0-E48-I1.nc', 'XLONG')
+
+
+def dimVar_creation(values, ncfile):
+    """ Function to add a 1D variable with the size of a given dimension in a file
+    dimVar_creation(values, ncfile)
+      [values]= [dimname] name of the dimesion to use
+      [ncfile]= file to add the variable
+    """
+    fname='dimVar_creation'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print dimVar_creation.__doc__
+        quit()
+
+    ncobj = NetCDFFile(ncfile, 'a')
+
+    varn = 'varDIM' + values
+
+    if not searchInlist(ncobj.dimensions.keys(),values):
+        print errormsg
+        print '  ' + fname + ": file '" + ncfile + "' has not '" + values +          \
+          "' dimension !!"
+        quit(-1)
+
+    dimsize = len(ncobj.dimensions[values])
+
+    if ncobj.variables.has_key(varn):
+        print warnmsg
+        print '  ' + fname + ": file '" + ncfile + "' already has variable '" +      \
+          varn + "' !!!"
+        print '    over-writting values'
+        newvar = ncobj.variables[varn]
+    else:
+        newvar = ncobj.createVariable(varn,'f4',(values))
+    newattr = basicvardef(newvar, varn,"variable from '" +values+ "' dimension" ,'-')
+    newvar[:] = np.arange(dimsize)*1.
+
+    ncobj.sync()
+    ncobj.close()
+
+    print fname + ": successfull creation of variable '" + varn + "' !!"
+
+    return
+
+#dimVar_creation('bottom_top', 'wrfout_d01_1979-12-01_00:00:00_south_north_B3-E3-I1_west_east_B26-E26-I1.nc')
+
+def files_folder(folder,headfile):
+    """ Function to retrieve a list of files from a folder [fold] and head [headfile]
+    >>> files_folder('/media/data2/etudes/WRF_LMDZ/WL_HyMeX_HighRes/medic950116/', 
+      'wrfout_d03')
+    ['wrfout_d03_1995-01-13_02:00:00', 'wrfout_d03_1995-01-13_04:00:00', 'wrfout_d03_1995-01-13_06:00:00', 
+     'wrfout_d03_1995-01-13_06:15:00', 'wrfout_d03_1995-01-13_08:15:00', 'wrfout_d03_1995-01-13_10:15:00',
+     'wrfout_d03_1995-01-13_12:15:00', 'wrfout_d03_1995-01-13_14:15:00', 'wrfout_d03_1995-01-13_16:15:00',     
+     (...)
+     'wrfout_d03_1995-01-17_18:15:00', 'wrfout_d03_1995-01-17_20:15:00', 'wrfout_d03_1995-01-17_22:15:00']
+    """
+    import subprocess as sub
+    fname = 'files_folder'
+
+    if folder == 'h':
+        print fname + '_____________________________________________________________'
+        print files_folder.__doc__
+        quit()
+
+#    ins = folder + "/" + headfile + "*"
+    ins = folder + "/"
+    print 'ins:',ins
+    files = sub.Popen(["/bin/ls","-1",ins], stdout=sub.PIPE)
+    fileslist = files.communicate()
+    listfiles0 = str(fileslist).split('\\n')
+
+# Filtering output
+    Lheader=len(headfile)
+    listfiles = []
+    for ifile in listfiles0:
+        if ifile[0:Lheader] == headfile:
+            listfiles.append(ifile)
+
+    return listfiles
+
+def netcdf_fold_concatenation(values, ncfile, varn):
+    """ Function to concatenate netCDF files in a given folder for a given set of variables
+    netcdf_fold_concateation(values, ncfile, varn)
+      [values]= [fold],[dimname] folder with the location of the netCDF files
+        [fold]: folder with the location of the netCDF files
+        [dimname]: dimension along which files should be concatenated
+      [ncfile]= header of the name of the files to concatenate [ncfile]*
+      [varn]= ',' separated list of variables to concatenate 
+          [var1],[var2],[...[varN]] or 'all' for all variables
+    """
+    import subprocess as sub
+    fname='netcdf_fold_concatenate'
+
+    ofile = 'netcdf_fold_concatenated.nc'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print netcdf_fold_concatenation.__doc__
+        quit()
+
+    fold = values.split(',')[0]
+    condim = values.split(',')[1]
+
+    confiles = files_folder(fold,ncfile)
+    Nfiles = len(confiles)
+
+    print '  ' + fname +': concatenating:',Nfiles,'files'
+    print confiles
+
+# Opening all files
+    ncobjs = []
+    for filen in confiles:
+        print 'charging: ',filen
+        ncobjs.append(NetCDFFile(fold + '/' + filen, 'r'))
+
+# Looking for the new length of the concatenation dimension
+    if not ncobjs[0].dimensions.has_key(condim):
+        print errormsg
+        print '  ' + fname + ": files do not have dimensions '" + condim + "' !!!"
+        quit(-1)
+
+    totcondim = 0
+    for ifile in range(Nfiles):
+        ncobj = ncobjs[ifile]
+        totcondim = totcondim + len(ncobjs[ifile].dimensions[condim])
+
+    print "total concatenated dimension '" + condim + "': ", totcondim
+
+# concatenated file creation
+##
+    newnc = NetCDFFile(ofile, 'w')
+
+# dimension creation 
+##
+    if ncobjs[0].dimensions[condim].isunlimited():
+        newnc.createDimension(condim, None)
+    else:
+        newnc.createDimension(condim, totcondim)
+# Fake variable for the dimension
+    print 'condim:',condim
+    dims = []
+    dims.append(condim)
+    newvar = newnc.createVariable('int' + condim, 'i4', tuple(dims))
+    newvar[:] = range(totcondim)
+
+# Looping variables
+##
+    if varn == 'all':
+        desvars = ncobjs[0].variables
+    else:
+        desvars = varn.split(',')
+
+    for dvar in desvars:
+        if not ncobjs[0].variables.has_key(dvar):
+            print errormsg
+            print '  ' + fname + ": files do not have variable '" + dvar + "' !!!"
+            quit(-1)
+
+    for dvar in desvars:
+        print '  ' + fname + ": concatenating '" + dvar + "'..."
+        objvar = ncobjs[0].variables[dvar]
+# creation of dimensions
+        vardims = objvar.dimensions
+        for ndim in vardims:
+            if not newnc.dimensions.has_key(ndim):
+                vardimo = ncobjs[0].dimensions[ndim]
+                if vardimo.isunlimited():
+                    newnc.createDimension(ndim, None)
+                else:
+                    newnc.createDimension(ndim, len(vardimo))
+# creation of variable
+        kvar = objvar.dtype
+        newvar = newnc.createVariable(dvar, kvar, objvar.dimensions)
+        varattrs = objvar.ncattrs()
+        for atr in varattrs:
+            attrv = objvar.getncattr(atr)
+            newattr = set_attribute(newvar, atr, attrv)
+
+# variable values
+#        vartotv = np.zeros((newvar.shape), dtype=kvar)
+        objvar = ncobjs[0].variables[dvar]
+
+        if searchInlist(list(objvar.dimensions),condim):
+            begslicetot = 0
+            for ifile in range(Nfiles):
+                slicevartot = []
+                if ncobjs[ifile].variables.has_key(dvar):
+                    objvar = ncobjs[ifile].variables[dvar]
+                    for dimn in objvar.dimensions:
+                        ldimfile = len(ncobjs[ifile].dimensions[dimn])
+                        if dimn == condim:
+                            slicevartot.append(slice(begslicetot,begslicetot+ldimfile))
+                            begslicetot = begslicetot + ldimfile
+                        else:
+                            slicevartot.append(slice(0,ldimfile))
+                    newvar[tuple(slicevartot)] = objvar[:]
+                    newnc.sync()
+                else:
+                    print errormsg
+                    print '  ' + fname + ": file '" + fold + '/' + confiles[ifile] + \
+                      "' does not have variable '" + dvar + "' !!"
+                    quit(-1)
+        else:
+            newvar[:] = objvar[:]
+            newnc.sync()
+
+#        newvar[:] = vartotv
+
+    gattrs = ncobjs[0].ncattrs()
+    for attr in gattrs:
+        attrv = ncobjs[0].getncattr(attr)
+        newattr = set_attribute(newnc, attr, attrv)
+
+    for ifile in range(Nfiles):
+        ncobjs[ifile].close()
+
+    newnc.sync()
+    newnc.close()
+
+    print "Successfull creation of concatenated file '" + ofile + "' !!!"
+
+    return
+
+#netcdf_fold_concatenation('/media/data2/etudes/WRF_LMDZ/WL_HyMeX_HighRes/medic950116,Time', 'wrfout_d03', 'Times,XLONG,XLAT,T2,TH2,PSFC,U10,V10,MAPFAC_M')
+
+def index_mat(mat,val):
+    """ Function to provide the coordinates of a given value inside a matrix
+    index_mat(mat,val)
+      mat= matrix with values
+      val= value to search
+    >>> index_mat(np.arange(27).reshape(3,3,3),22)
+    [2 1 1]
+    """
+
+    fname = 'index_mat'
+
+    matshape = mat.shape
+
+    matlist = list(mat.flatten())
+    ifound = matlist.index(val)
+
+    Ndims = len(matshape)
+    valpos = np.zeros((Ndims), dtype=int)
+    baseprevdims = np.zeros((Ndims), dtype=int)
+
+    for dimid in range(Ndims):
+        baseprevdims[dimid] = np.product(matshape[dimid+1:Ndims])
+        if dimid == 0:
+            alreadyplaced = 0
+        else:
+            alreadyplaced = np.sum(baseprevdims[0:dimid]*valpos[0:dimid])
+        valpos[dimid] = int((ifound - alreadyplaced )/ baseprevdims[dimid])
+
+    return valpos
+
+def netcdf_concatenation(ncfile):
+    """ Function to concatenate netCDF files for a given set of variables
+    netcdf_concateation(values, ncfile, varn)
+      [ncfile]= [filename1]@[varn1]|[filename1]@[varn1] '|' list of file names and variables to concatenate 
+        [varn]= ',' separated list of variables to concatenate 
+          [var1],[var2],[...[varN]] or 'all' for all variables
+    """
+    fname='netcdf_concatenate'
+
+    ofile = 'netcdf_concatenated.nc'
+
+    if ncfile == 'h':
+        print fname + '_____________________________________________________________'
+        print netcdf_concatenation.__doc__
+        quit()
+
+    confiles = ncfile.split('|')
+    Nfiles = len(confiles)
+
+    print '  ' + fname +': concatenating:',Nfiles,'files'
+    print confiles
+
+# Opening all files
+    filenames = []
+    ncobjs = []
+    for files in confiles:
+        filen = files.split('@')[0]
+        filenames.append(filen)
+        if not os.path.isfile(filen):
+                print errormsg
+                print '  ' + fname + ": file '" + filen + "' does no exist!!"
+                quit(-1)
+
+        print 'charging: ',filen
+        ncobjs.append(NetCDFFile(filen, 'r'))
+
+# concatenated file creation
+##
+    newnc = NetCDFFile(ofile, 'w')
+
+# Looping variables
+##
+    ifile = 0
+    for files in confiles:
+        filen = files.split('@')[0]
+        desvar = files.split('@')[1]
+        if desvar == 'all':
+            desvars = ncobjs[ifile].variables
+        else:
+            desvars = desvar.split(',')
+
+        for dvar in desvars:
+            if not ncobjs[ifile].variables.has_key(dvar):
+                print errormsg
+                print '  ' + fname + ": files do not have variable '" +dvar+ "' !!!"
+                quit(-1)
+
+        for dvar in desvars:
+            if not newnc.variables.has_key(dvar):
+                print '  ' + fname + ": concatenating '" + dvar + "' from '" + filen+\
+                  "'..."
+                objvar = ncobjs[ifile].variables[dvar]
+# creation of dimensions
+                vardims = objvar.dimensions
+                for ndim in vardims:
+                    if not newnc.dimensions.has_key(ndim):
+                        vardimo = ncobjs[ifile].dimensions[ndim]
+                        if vardimo.isunlimited():
+                            newnc.createDimension(ndim, None)
+                        else:
+                            newnc.createDimension(ndim, len(vardimo))
+# creation of variable
+                kvar = objvar.dtype
+                newvar = newnc.createVariable(dvar, kvar, objvar.dimensions)
+                varattrs = objvar.ncattrs()
+                for atr in varattrs:
+                    attrv = objvar.getncattr(atr)
+                    newattr = set_attribute(newvar, atr, attrv)
+
+# variable values
+#        vartotv = np.zeros((newvar.shape), dtype=kvar)
+                objvar = ncobjs[ifile].variables[dvar]
+                newvar[:] = objvar[:]
+                newnc.sync()
+
+#        newvar[:] = vartotv
+        ifile = ifile + 1
+
+    gattrs = ncobjs[0].ncattrs()
+    for attr in gattrs:
+        attrv = ncobjs[0].getncattr(attr)
+        newattr = set_attribute(newnc, attr, attrv)
+
+    filesnvec = numVector_String(filenames,', ')
+    newattr = set_attribute(newnc, 'concatenated', filesnvec)
+
+    for ifile in range(Nfiles):
+        ncobjs[ifile].close()
+
+    newnc.sync()
+    newnc.close()
+
+    print "Successfull creation of concatenated file '" + ofile + "' !!!"
+
+    return
+
+#netcdf_concatenation('mean_pluc.nc@all|mean_dtcon.nc@all')
+
+def field_stats(values, ncfile, varn):
+    """ Function to retrieve statistics from a field
+    field_stats(values, ncfile, varn)
+      [values]= kind of statistics 
+        'full': all statistics given variable
+      [ncfile]= name of the netCDF file to use
+      [varn]= variable name to use ('all' for all variables)
+    """
+
+    fname='field_stats'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print field_stats.__doc__
+        quit()
+
+    ncobj = NetCDFFile(ncfile, 'r')
+
+    if varn == 'all':
+        varstats = list(ncobj.variables)
+    else:
+        varstats = [varn]
+
+    print '  ' + fname + '______ ______ _____ ____ ___ __ _'
+    for vn in varstats:
+        if not ncobj.variables.has_key(vn):
+            print errormsg
+            print '  ' + fname + ": file do not have variable '" + vn + "' !!"
+            quit(-1)
+    
+        objfield = ncobj.variables[vn]
+        field = objfield[:]
+
+        print '   ' + vn + '... .. .'
+        if values == 'full':
+            minv = np.min(field)
+            maxv = np.max(field)
+            meanv = np.mean(field)
+            mean2v = np.mean(field*field)
+            varv = np.sqrt(mean2v - meanv*meanv)
+
+            print '    Fstats shape:',field.shape
+            print '    Fstats min:', minv
+            print '    Fstats max:', maxv
+            print '    Fstats mean:', meanv
+            print '    Fstats mean2:', mean2v
+            print '    Fstats variability:', varv
+        else:
+            print errormsg
+            print '  ' + fname + ": kind of statistics '" + values + "' not ready!!"
+            print '    valid statistics: full'
+            quit(-1)
+
+    ncobj.close()
+
+    return
+
+#field_stats('full', 'geo_em.d01.nc', 'HGT_M')
+
+def check_arguments(funcname,Nargs,args,char,expectargs):
+    """ Function to check the number of arguments if they are coincident
+    check_arguments(funcname,Nargs,args,char)
+      funcname= name of the function/program to check
+      Nargs= theoretical number of arguments
+      args= passed arguments
+      char= character used to split the arguments
+    """
+
+    fname = 'check_arguments'
+
+    Nvals = len(args.split(char))
+    if Nvals != Nargs:
+        print errormsg
+        print '  ' + fname + ': wrong number of arguments:',Nvals," passed to  '",   \
+          funcname, "' which requires:",Nargs,'!!'
+        print '    given arguments:',args.split(char)
+        print '    expected arguments:',expectargs
+        quit(-1)
+
+    return
+
+def Str_Bool(val):
+    """ Function to transform from a String value to a boolean one
+    >>> Str_Bool('True')
+    True
+    >>> Str_Bool('0')
+    False
+    >>> Str_Bool('no')
+    False
+    """
+
+    fname = 'Str_Bool'
+
+    if val == 'True' or val == '1' or val == 'yes': 
+        boolv = True
+    elif val == 'False' or val == '0' or val== 'no':
+        boolv = False
+    else:
+        print errormsg
+        print '  ' + fname + ": value '" + val + "' not ready!!"
+        quit(-1)
+
+    return boolv
+
+def get_namelist_vars(values, namelist):
+    """ Function to get namelist-like  values ([varname] = [value]) 
+    get_namelist_vars(namelist)
+      values= [sectionname],[kout]
+        [sectionname]: name of the section from which one want the values ('all', for all)
+        [kout]: kind of output
+          'tex3': printed output as LaTeX table of three columns \verb+namelist_name+ & value
+          'column': printed output as namelist_name value
+          'dic': as python dictionary object
+      namelist= namelist_like file to retrieve values
+    >>> get_namelist_vars('geogrid,dic','/home/lluis/etudes/domains/medic950116/namelist.wps')
+    {'e_sn': '32, 97,', 'stand_lon': '0.', 'opt_geogrid_tbl_path': "'./'", 'geog_data_path': "'/home/lluis/DATA/WRF/geog'", 'pole_lat': '90.0', 'ref_lat': '35.0,', 'map_proj': "'lat-lon',", 'parent_id': '1, 1,', 'geog_data_res': "'2m','2m',", 'e_we': '32, 112,', 'dx': '0.35,', 'dy': '0.35,', 'parent_grid_ratio': '1, 3,', 'pole_lon': '0.0', 'ref_lon': '20,', 'j_parent_start': '1, 17,', 'i_parent_start': '1, 31,'}
+    """
+
+    fname = 'get_namelist_vars'
+
+# List of characters which split pairs name/value
+    valuessep = ['=']
+# List of characters which indicate a comment
+    commentchars = ['#']
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print get_namelist_vars.__doc__
+        quit()
+
+    expectargs = '[sectionname],[kout]'
+    check_arguments(fname,len(expectargs.split(',')),values,',',expectargs)
+
+    secname = values.split(',')[0]
+    kout = values.split(',')[1]
+
+    if not os.path.isfile(namelist):
+        print errormsg
+        print '  ' + fname + ": namelist file '" + namelist + "' does not exist !!"
+        quit(-1)
+
+    ncml = open(namelist, 'r')
+
+    sections = {}
+    namelistvals = {}
+    sectionnames = []
+    namessec = []
+    allnames = []
+    namelistvalssec = {}
+    sectionname = ''
+
+    for line in ncml:
+        linevals = reduce_spaces(line)
+        Nvals = len(linevals)
+
+        if Nvals >= 1 and linevals[0][0:1] == '&':
+            if len(sectionnames) > 1:
+                sections[sectionname] = namessec
+
+            sectionname = linevals[0][1:len(linevals[0])+1]
+            print '    ' + fname + ": new section '" + sectionname + "' !!!"
+            sectionnames.append(sectionname)
+            namessec = []
+        elif Nvals >= 1 and not searchInlist(commentchars,linevals[0][0:1]):
+            if Nvals >= 3 and searchInlist(valuessep,linevals[1]):
+                nmlname = linevals[0]
+                nmlval = numVector_String(linevals[2:Nvals],' ')
+            elif Nvals == 1:
+                for valsep in valuessep:
+                    if linevals[0].find(valsep) != -1:
+                        nmlname = linevals[0].split(valsep)[0]
+                        nmlval = linevals[0].split(valsep)[1]
+                        break
+            elif Nvals == 2:
+                for valsep in valuessep:
+                    if linevals[0].find(valsep) != -1:
+                        nmlname = linevals[0].split(valsep)[0]
+                        nmlval = linevals[1]
+                        break
+                    elif linevals[1].find(valsep) != -1:
+                        nmlname = linevals[0]
+                        nmlval = linevals[1].split(valsep)[0]
+                        break
+            else:
+                print warnmsg
+                print '  ' + fname + ': wrong number of values', Nvals,              \
+                  'in the namelist line!'
+                print '    line: ',line
+                print '    line values:',linevals
+#                quit(-1)
+            namelistvals[nmlname] = nmlval
+            namessec.append(nmlname)
+            allnames.append(nmlname)
+
+    if len(sectionname) > 1:
+        sections[sectionname] = namessec
+
+    if secname != 'all':
+        if not searchInlist(sections.keys(),secname):
+            print errormsg
+            print '  ' + fname + ": section '" + values + "' does not exist !!"
+            print '    only found:',sectionnames
+            quit(-1)
+
+        namestouse = []
+        for nml in allnames:
+            for nnml in sections[secname]:
+                namelistvalssec[nnml] = namelistvals[nnml]
+                if nml == nnml: namestouse.append(nml)
+    else:
+        namestouse = allnames
+        namelistvalssec = namelistvals
+
+    if kout == 'tex3':
+        ofile='get_namelist_vars_3col.tex'
+        fobj = open(ofile, 'w')
+
+        vals = namestouse
+        Nvals = len(vals)
+        Nvals3 = int(Nvals/3)
+        latextab = '\\begin{center}\n\\begin{tabular}{lclclc}\n'
+        for il in range(2):
+            latextab = latextab + '{\\bfseries{name}} & {\\bfseries{value}} & '
+        latextab= latextab+ '{\\bfseries{name}} & {\\bfseries{value}} \\\\ \\hline\n'
+
+        if np.mod(Nvals,3) != 0:
+            Nvals0 = Nvals - np.mod(Nvals,3)
+        else:
+            Nvals0 = Nvals
+
+        for ival in range(0,Nvals0,3):
+            line = ''
+            print '  ival:',ival
+            for il in range(2):
+                line = line + '\\verb+' + vals[ival+il] + '+ & ' +                   \
+                   namelistvalssec[vals[ival+il]].replace('_','\\_') +' & '
+            line = line + '\\verb+' + vals[ival+2] + '+ & ' +                       \
+               namelistvalssec[vals[ival+2]].replace('_','\\_') + ' \\\\\n'
+            latextab = latextab + line
+
+        latextab = latextab + '%not multiple of three!!!!\n'
+        print 'mod:', np.mod(Nvals,3),Nvals0,Nvals
+        if np.mod(Nvals,3) != 0:
+            ival = Nvals0
+            line = ''
+            for il in range(np.mod(Nvals,3)):
+                print 'ival:',ival + il
+                line = line + '\\verb+' + vals[ival+il] + '+ & ' +                   \
+                      namelistvalssec[vals[ival+il]].replace('_','\\_') + ' & '
+            for il in range(2-np.mod(Nvals,3)):
+                line = line + ' & & '
+            latextab = latextab + line + ' & \\\\\n'
+        latextab = latextab + '\\end{tabular}\n\\end{center}\n'
+
+#        print latextab
+        fobj.write(latextab)
+ 
+        fobj.close()
+        print fname + ": successful writen '" + ofile + "' LaTeX tale file !!"
+
+        return 
+    elif kout == 'column':
+        for dictv in namestouse:
+            print dictv + ' = ' + namelistvalssec[dictv]
+        return
+    elif kout == 'dict':
+        return namelistvalssec
+    else:
+        print errormsg
+        print '  ' + fname + ": kind of output '" + kout + "' not ready!!!"
+        quit(-1)
+
+    return
+
+def WRF_d0Nref(values, geofold):
+    """ Function for the generation of an extra WRF domain from a given one 
+    field_stats(values, ncfile, varn)
+      [values]= [namelist],[minLON],[minLAT],[maxLON],[maxLAT],[Ndomref],[factor],[geogres]
+        [namelist]: namelist.wps to use
+        [minLON],[minLAT]: minimum longitude and latitude
+        [maxLON],[maxLAT]: maximum longitude and latitude
+        [Ndomref]: domain reference number
+        [factor]: resolution factor with respect d01
+        [geogres]: which topography resolution to use
+      [geofold]= folder where to found the geo_em.d0[N-1].nc file
+    """
+
+    fname='WRF_d0Nref'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print WRF_d0Nref.__doc__
+        quit()
+
+    expectargs = '[namelist],[minLON],[minLAT],[maxLON],[maxLAT],[Ndomref],[factor],'
+    expectargs = expectargs + '[geogres]'
+ 
+    check_arguments(fname,len(expectargs.split(',')),values,',',expectargs)
+
+    namelist = values.split(',')[0]
+    minLON = np.float(values.split(',')[1])
+    minLAT = np.float(values.split(',')[2])
+    maxLON = np.float(values.split(',')[3])
+    maxLAT = np.float(values.split(',')[4])
+    Ndomref = int(values.split(',')[5])
+    factor = int(values.split(',')[6])
+    geogres = values.split(',')[7]
+
+    onml = 'namelist.wps_d0' + str(Ndomref+1)
+
+# Namelist variables to which new value is a copy of the last one
+    repeatvalue = ['start_date' ,'end_date']
+# Namelist variables to which value is increased by 1 (single value)
+    add1 = ['max_dom']
+# Namelist variables to which new value is an increase by 1 of the last one
+    add1value = ['parent_id']
+
+#    ncfile = geofold + '/geo_em.d' + zeros(Ndomref,2) + '.nc'
+    ncfile = geofold + '/geo_em.d0' + str(Ndomref) + '.nc'
+
+    if not os.path.isfile(ncfile):
+        print errormsg
+        print '  ' + fname + ': geo_em file "' + ncfile + '" does not exist !!'
+        quit(-1)    
+
+    ncobj = NetCDFFile(ncfile, 'r')
+
+    nlon='XLONG_M'
+    nlat='XLAT_M'
+
+    lonobj = ncobj.variables[nlon]
+    latobj = ncobj.variables[nlat]
+
+    lon = lonobj[0,:,:]
+    lat = latobj[0,:,:]
+
+    ncobj.close()
+
+    diffmin = np.sqrt((lon - minLON)**2. + (lat - minLAT)**2.)
+    diffmax = np.sqrt((lon - maxLON)**2. + (lat - maxLAT)**2.)
+
+    posdiffmin = index_mat(diffmin,np.min(diffmin))
+    posdiffmax = index_mat(diffmax,np.min(diffmax))
+#    print 'min vals. min:',np.min(diffmin),'max:',np.min(diffmax)
+
+#    print 'min:', minLON, ',', minLAT, ':', posdiffmin, '.', lon[tuple(posdiffmin)], \
+#      ',', lat[tuple(posdiffmin)]
+#    print 'max:', maxLON, ',', maxLAT, ':', posdiffmax, '.', lon[tuple(posdiffmax)], \
+#      ',', lat[tuple(posdiffmax)]
+
+    print '  ' + fname +': coordinates of the SW corner:', posdiffmin, ' NE corner:',\
+      posdiffmax
+
+    nmlobj = open(namelist, 'r')
+    onmlobj = open(onml, 'w')
+    for line in nmlobj:
+        listline = reduce_spaces(line)
+        nvals = len(listline)
+        if nvals > 0:
+            if searchInlist(add1,listline[0]):
+                nmlval = int(listline[nvals-1].replace(',','')) + 1
+                onmlobj.write(' ' + listline[0] + ' = ' + str(nmlval) + ',\n')
+            elif searchInlist(add1value,listline[0]):
+                if Ndomref == 1:
+                    nmlval = 1
+                else:
+                    nmlval = int(listline[nvals-1].replace(',','')) + 1   
+                onmlobj.write(' ' + listline[0] + ' = ' +                            \
+                  numVector_String(listline[2:nvals+1], ' ') + ' ' +str(nmlval)+',\n')
+            elif searchInlist(repeatvalue,listline[0]):
+                nmlval = listline[nvals-1]
+                onmlobj.write(' ' + listline[0] + ' = ' +                            \
+                  numVector_String(listline[2:nvals+1],' ') + ' ' + str(nmlval)+'\n')
+            elif listline[0] == 'parent_grid_ratio':
+                nmlval = factor
+                onmlobj.write(' ' + listline[0] + ' = ' +                            \
+                  numVector_String(listline[2:nvals+1],' ') + ' ' + str(nmlval)+',\n')
+            elif listline[0] == 'i_parent_start':
+                nmlval = posdiffmin[1] - 10
+                onmlobj.write(' ' + listline[0] + ' = ' +                            \
+                  numVector_String(listline[2:nvals+1],' ') + ' ' + str(nmlval)+',\n')
+            elif listline[0] == 'j_parent_start':
+                nmlval = posdiffmin[0] - 10
+                onmlobj.write(' ' + listline[0] + ' = ' +                            \
+                  numVector_String(listline[2:nvals+1],' ') + ' ' + str(nmlval)+',\n')
+            elif listline[0] == 'e_we':
+                nmlval = (posdiffmax[1] - posdiffmin[1] + 20)*factor
+                nmlval = nmlval + np.mod(nmlval,factor) + 1
+                onmlobj.write(' ' + listline[0] + ' = ' +                            \
+                  numVector_String(listline[2:nvals+1],' ') + ' ' + str(nmlval)+',\n')
+            elif listline[0] == 'e_sn':
+                nmlval = (posdiffmax[0] - posdiffmin[0] + 20)*factor
+                nmlval = nmlval + np.mod(nmlval,factor) + 1
+                onmlobj.write(' ' + listline[0] + ' = ' +                            \
+                  numVector_String(listline[2:nvals+1],' ') + ' ' + str(nmlval)+',\n')
+            elif listline[0] == 'geog_data_res':
+                nmlval = "'" + geogres + "'"
+                onmlobj.write(' ' + listline[0] + ' = ' +                            \
+                  numVector_String(listline[2:nvals+1],' ') + ' ' + str(nmlval)+',\n')
+            else:
+                onmlobj.write(line)
+        else:
+            onmlobj.write('\n')
+
+    nmlobj.close()
+    onmlobj.close()
+
+    print fname + ": successfully written new namelist '" + onml + "' !!"
+
+    return
+
+def filter_2dim(values, ncfile, varn):
+    """ Function to filter along 2 dimensions (moving grid-box means of a given size) values of the netCDF file
+    filter_2dim(values, ncfile, variable)
+      values= [Ngrid],[dimnh1],[dimnh2],[dimvnh1],[dimvnh2]
+        Ngrid: box size to make means
+        dimnh[1/2]: name of the 2 dimensions to make the averages
+        dimvnh[1/2]: name of the 2 variables with the values of the dimensions to make the averages
+      ncfile= netCDF file to use
+      varn= name of the variable to filter ('all' for all variables)
+      filter_2dim('80,y,x,lon,lat', 'tahiti_5m_ll.grd', 'z')
+    """
+
+    fname = 'filter_2dim'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print filter_2dim.__doc__
+        quit()
+
+    expectargs = '[Ngrid],[dimnh1],[dimnh2],[dimvnh1],[dimvnh2]'
+ 
+    check_arguments(fname,len(expectargs.split(',')),values,',',expectargs)
+
+    Ngrid = int(values.split(',')[0])
+    dimnh1 = values.split(',')[1]
+    dimnh2 = values.split(',')[2]
+    dimvnh1 = values.split(',')[3]
+    dimvnh2 = values.split(',')[4]
+
+    Ngrid2 = Ngrid/2
+    dimhorns = [dimnh1, dimnh2]
+    dimvhorns = [dimvnh1, dimvnh2]
+
+    if varn == 'all':
+        varns = ncobj.variables
+        ofile = 'filter_hor.nc'
+    else:
+        varns = [varn]
+        ofile = 'filter_hor_' + varn + '.nc'
+
+    ncobj = NetCDFFile(ncfile,'r')
+    newnc = NetCDFFile(ofile, 'w')
+
+    for vn in varns:
+        varvobj = ncobj.variables[vn]
+        vardims = varvobj.dimensions
+        print '  ' + fname + ' var:', vn, 'variable shape:', varvobj.shape
+        for dimn in vardims:
+            dimobj = ncobj.dimensions[dimn]
+            if not newnc.dimensions.has_key(dimn):
+                if dimobj.isunlimited():
+                    newnc.createDimension(dimn, None)
+                else:
+                    newnc.createDimension(dimn, len(dimobj))
+
+        if searchInlist(varvobj.ncattrs(),'_FillValue'): 
+            vfillValue = varvobj._FillValue
+        else:
+            vfillValue = fillValue
+
+        vtype = varvobj.dtype
+        if searchInlist(dimvhorns,vn):
+            print '  ' + fname + ': dimension values variable!'
+            print "    keeping original values as '" + vn + "' and filtered as '" +  \
+              vn+'_flt'+str(Ngrid)+'x'+str(Ngrid) + "'"
+            newvar = newnc.createVariable(vn, vtype, vardims)
+            newvar[:] = varvobj[:]
+            vattr = varvobj.ncattrs()
+            for nattr in vattr:
+                attrv = varvobj.getncattr(nattr)
+                if nattr != '_FillValue': newattr = set_attribute(newvar,nattr,attrv)
+            newvar = newnc.createVariable(vn+'_flt'+str(Ngrid)+'x'+str(Ngrid),       \
+              vtype, vardims)
+        else:
+            newvar = newnc.createVariable(vn, vtype, vardims, fill_value = fillValue)
+
+        if searchInlist(vardims,dimnh1) or searchInlist(vardims,dimnh2):
+            varv = varvobj[:]
+            varfilt = varvobj[:]
+            dimh1id = -1
+            dimh2id = -1
+            if searchInlist(vardims,dimnh1): dimh1id= vardims.index(dimnh1)
+            if searchInlist(vardims,dimnh2): dimh2id= vardims.index(dimnh2)
+
+            if dimh1id != -1 and dimh2id != -1:
+                print '    ' + fname + ': 2D filtered variable'
+                dh1 = varvobj.shape[dimh1id]
+                dh2 = varvobj.shape[dimh2id]
+
+                for i in range(Ngrid2,dh1-Ngrid2+1):
+                    for j in range(Ngrid2,dh2-Ngrid2+1):
+                        percendone(i*(dh1-Ngrid)*1.+j,(dh1-Ngrid)*(dh2-Ngrid)*1., 1.,   \
+                          vn + ' filtered: ' + str(i) + ', ' + str(j))
+                        varslice = []
+                        varslicesum = []
+                        for dimn in vardims:
+                            if dimn == dimnh1:
+                                varslicesum.append(slice(i-Ngrid2,i+Ngrid2+1))
+                                varslice.append(slice(i,i+1))
+                            elif dimn == dimnh2:
+                                varslicesum.append(slice(j-Ngrid2,j+Ngrid2+1))
+                                varslice.append(slice(j,j+1))
+                            else:
+                                varslicesum.append(slice(0,                          \
+                                  len(ncobj.dimensions[dimn])))
+                                varslice.append(slice(0, len(ncobj.dimensions[dimn])))
+
+# Doing nothing for _FillValue values
+                        varvalssum = varv[tuple(varslicesum)]
+                        if varvalssum.mask.all():
+                            varfilt[tuple(varslice)] = fillValue
+                        else:
+                            numberValues = len(varvalssum.compressed())
+                            if dimh1id < dimh2id:
+                                varfilt[tuple(varslice)] = np.sum(np.sum(varvalssum, \
+                                  axis=dimh1id), axis=dimh2id-1)/(numberValues*1.)
+                            else:
+                                varfilt[tuple(varslice)] = np.sum(np.sum(varvvlssum, \
+                                  axis=dimh2id), axis=dimh1id-1)/(numberValues*1.)
+                print '    ' + fname + ': 2D Finished!!'
+            elif dimh1id != -1 and dimh2id == -1:
+                print '    ' + fname + ': 1D filtered variable'
+                for i in range(Ngrid2,varvobj.shape[dimh1id]-Ngrid2+1):
+                    percendone(i,(dh1-Ngrid), 1, vn + ' filtered')
+                    varslice = []
+                    varslicesum = []
+                    for dimn in vardims:
+                        if dimn == dimhn1:
+                            varslicesum.append(slice(i-Ngrid2,i+Ngrid2+1))
+                        else:
+                            varslicesum.append(slice(0, len(ncobj.dimensions[dimn])))
+
+                        varvalssum = varv[tuple(varslicesum)]
+                        if varvalssum.mask.all():
+                            varfilt[tuple(varslice)] = fillValue
+                        else:
+                            numberValues = len(varvalssum.compressed())
+                            varfilt[tuple(varslice)] = np.sum(varvalssum,            \
+                              axis=dimh1id)/numberValues*1.
+                print '    ' + fname + ': 1D Finished!!'
+            elif dimh2id != -1 and dimh1id == -1:
+                print '    ' + fname + ': 1D filtered variable'
+                for j in range(Ngrid2,varvobj.shape[dimh2id]-Ngrid2+1):
+                    percendone(j,(dh2-Ngrid), 1, vn + ' filtered')
+                    varslice = []
+                    varslicesum = []
+                    for dimn in vardims:
+                        if dimn == dimhn2:
+                            varslicesum.append(slice(j-Ngrid2,j+Ngrid2+1))
+                        else:
+                            varslicesum.append(slice(0, len(ncobj.dimensions[dimn])))
+
+                        varvalssum = varv[tuple(varslicesum)]
+                        if varvalssum.mask.all():
+                            varfilt[tuple(varslice)] = fillValue
+                        else:
+                            numberValues = len(varvalssum.compressed())
+                            varfilt[tuple(varslice)] = np.sum(varvalssum,            \
+                              axis=dimh2id)/numberValues
+                print '    ' + fname + ': 1D Finished!!'
+            newvar[:] = varfilt
+        else:
+            newvar[:] = varvobj[:]
+
+        vattr = varvobj.ncattrs()
+        for nattr in vattr:
+            attrv = varvobj.getncattr(nattr)
+            if nattr != '_FillValue': newattr = set_attribute(newvar, nattr, attrv)
+
+    gattr = ncobj.ncattrs()
+    for nattr in gattr:
+        attrv = ncobj.getncattr(nattr)
+        newattr = set_attribute(newnc, nattr, attrv)
+    
+    ncobj.close()
+    newnc.sync()
+    newnc.close()
+
+    print fname + ": successfull creation of '" + ofile + "' !!!"
+
+    return
+
+#filter_2dim('80,y,x,lon,lat', 'tahiti_5m_ll.grd', 'z')
+
+
+def ncreplace(values, ncfile, varn):
+    """ Function to replace something from a netCDF file
+      values= [kind],[kindn],[netcdffileref]
+        kind: element to substitute
+          'var': variable
+          'vattr': variable attributes
+          'gattr': global attributes
+        kindn: name of the 'something' to replace ('all', for all possible values, 
+          [varn]@[attrn] for attribute of a given variable)
+        netcdffileref: netCDF file from which replace values will be taken
+      ncfile= netCDF file to replace something
+      varn= name to use (accordingly to '[kind]')
+      ncreplace('var,HGT_M,Polynesie_filtered_nn.nc', 'geo_em.d04.nc', 'HGT_M')
+    """
+
+    fname = 'ncreplace'
+
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print ncreplace.__doc__
+        quit()
+
+    expectargs = '[kind],[kindn],[netcdffileref]'
+ 
+    check_arguments(fname,len(expectargs.split(',')),values,',',expectargs)
+
+    kind = values.split(',')[0]
+    kindn = values.split(',')[1]
+    netcdffileref = values.split(',')[2]
+
+    print '  ' + fname + ": replacing '" + kind + "' in '" + ncfile + "' using '" +  \
+      netcdffileref + "' ..."
+
+    if not os.path.isfile(netcdffileref):
+        print errormsg
+        print '  ' + fname + ": reference file '" + netcdffileref +                  \
+          "' does not exist !!"
+        quit(-1)
+
+    ncrefobj = NetCDFFile(netcdffileref, 'r')
+    ncobj = NetCDFFile(ncfile, 'a')
+
+    if kind == 'var' and kindn != 'all':
+        if not ncrefobj.variables.has_key(kindn):
+            print errormsg
+            print '  ' + fname + ": reference file does not have variable '" + kindn \
+              + "' !!"
+            print '    it has: ',ncrefobj.variables.keys()
+            quit(-1)
+    elif kind == 'vattr' and kindn != 'all':
+        if kindn.index('@') == -1:
+            print errormsg
+            print '  ' + fname + ": an pair [var]@[attrn] is not given! '" + kindn + \
+              + "' !!"
+            quit(-1)
+        varn = kindn.split('@')[0]
+        attrn = kindn.split('@')[1]
+        if not ncrefobj.variables.has_key(varn):
+            print errormsg
+            print '  ' + fname + ": reference file does not have variable '" + varn +\
+              "' !!"
+            quit(-1)
+        varobj = ncrefobj.variables[varn]
+        if not searchInlist(varobj.ncattrs(), attrn):
+            print errormsg
+            print '  ' + fname + ": reference variable '" + varn +                   \
+              "' does not have attribute '" + attrn + "' !!"
+            quit(-1)
+    else:
+        print errormsg
+        print '  ' + fname + ": kind to replace '" + kind + "' not ready !!"
+        quit(-1)
+
+    if kind == 'var':
+        if kindn == 'all':
+            varrefns = ncrefobj.variables
+            varns = ncobj.variables
+        else:
+            varrefns = [kindn]
+            varns = [varn]
+# On kindn= 'all' &  varn= 'all' one has to assume same variables' names
+        for vnref in varrefns:
+            if not ncrefobj.variables.has_key(vnref):
+                print errormsg
+                print '  ' + fname + ": reference file does not have variable '" +   \
+                  vnref + "' !!"
+                quit(-1)
+            for vn in varns:  
+                if not ncobj.variables.has_key(vn):
+                    print errormsg
+                    print '  ' + fname + ": file does not have variable '" + vn +    \
+                      "' !!"
+                    quit(-1)
+                if kindn == 'all' and vnref == vn:
+                    print '    ' + fname + ": replacing all now '" + vn + "' with '"+\
+                      vnref + "' ..."
+                    varv = ncobj.variables[vn]
+                    varrefv = ncrefobj.variables[vnref][:]
+                    varv[:] = varrefv
+                    ncobj.sync()
+                    break
+                else:
+                    vdimns = numVector_String(ncobj.variables[vn].shape,':')
+                    vrefdimns = numVector_String(ncrefobj.variables[vnref].shape,':')
+
+                    if vdimns != vrefdimns:
+                        print errormsg
+                        print '  ' + fname + ': values can not be replaced!'
+                        print '    different shapes! original:',                     \
+                           ncobj.variables[vn].shape,'reference:',                   \
+                           ncrefobj.variables[vnref].shape
+# In case of HGT_M... #                        quit(-1)
+                        quit(-1)
+
+                    print '    ' + fname + ": replacing '" + vn + "' with '" +       \
+                      vnref + "' ..."
+                    varv = ncobj.variables[vn]
+                    varrefv = ncrefobj.variables[vnref][:]
+# In case of HGT_M...                   varv[0,:,:] = varrefv
+                    varv[:] = varrefv
+                    ncobj.sync()
+    else:
+        print errormsg
+        print '  ' + fname + ": kind to replace '" + kind + "' not exactly ready !!"
+        quit(-1)
+
+    ncobj.sync()
+    ncobj.close()
+    ncrefobj.close()
+
+    return
+
+#quit()
+
+"""operation to make: 
+  addfattr, add a attributes to a variable from another file: addfattr -S [file]:[var] 
+  addfdim, add a new dimension from another file: addfdim -S [file]:[dimension] 
+  addfgattr, add global attribute from another file: addfgattr -S [file]
+  addfvar, add a new variable from another file: addfvar -S [file]:[variable] 
+  addgattr, add a new global attribute: addatr -S [attrname]|[attrvalue]
+  addgattrk, add a new global attribute: addatr -S [attrname]|[attrvalue]|[kind(S (!, white spaces),I,R,D)]
+  addref, add a new variable with dimension and attributes from an already existing 'variable ref' in the file: addref -S [variable ref]:[attr name]@[value]:[[attr2]@[value2], ...]:[value/file with values]  mname, modify name -S newname
+  addvals, Function to add values to a given variable at a given dimension: addvals -S [dimension]:[position]:[Nvals]:[addval], 
+    *[position]: position within the dimension at which the variable wants to be increased
+       'first': first position of the dimension
+       'middle': middle position of the dimension
+       'last': last position of the dimension
+       'num': before given value
+    *[addval]: value to give to the added values
+       'val': a given value
+       'missing': as a missing value
+  addvattr, add a new attribute to any given variable: addvattr -S [attrname]|[attrvalue]
+  addvattrk, add a new attribute to any given variable: addvattrk -S [attrname]|[attrvalue]|[kind(S (!, white spaces),I,R,D)]
+  checkNaNs, checks for NaN values over all variables in a file
+  checkAllValues, check for variables with along all their dimensions with the same value in a file
+  flipdim, flips the value following one dimension: flipdim -S Ndim
+  infgattrs, give the values of all the global attributes of the file: infgattrs
+  infsinggattrs, give the value of a single global attribute of the file: infsinggattrs -S [attribute name]
+  infsingvattrs, give the value of a single attribute of the variable: infsingvattrs -S [attribute name]
+  inftime, give all the information of the variable time: inftime
+  infvars, give the names of all the variables of the file: infvars
+  infvattrs, give the values of all the attributes of a variable: infvattrs
+  mdname, modify dimension name: mdname -S olddname:newdname
+  means, computes the spatial mean of the variable: means
+  meanseas, compute the seasonal mean of a variable: meanseas -S [timename]
+  meant, computes the temporal mean of the variable: meant -S [power](power of the polynomial fit)
+  mname, modify name: mname -S newname
+  out, output values: out -S inidim1,[inidim2,...]:enddim1,[enddim2,...]
+  rgattr, read a global attribute: rgattr -S [attrname]
+  rvattr, read a variable attribute: rvattr -S [attrname]
+  rmgattr, remove a global attribute: rmgattr -S [attrname]
+  rmvariable, remove a variable: rmvariable
+  rmvattr, remove an attribute to any given variable: rmvattr -S [attrname]
+  subsetmns, retrieve a subset of values based on months: subsetmns -S [MM1]:[...:[MMn]] or [MMi]-[MMe] for a period (output as 'subsetmns.nc')
+  subsetyrs, retrieve a subset of values based on years: subsetyrs -S [YYYY1]:[...:[YYYYn]] or [YYYYi]-[YYYYe] for a period (output as 'subsetyrs.nc')
+  timescheck, checks time-steps of a given file: timescheck -S [FirstDate]:[LastDate][freq]:[[auxmonth]]
+      [FirstDate] = first date within file (in [YYYY][MM][DD][HH][MI][SS] format)
+      [LastDate] = last date within file (in [YYYY][MM][DD][HH][MI][SS] format)
+      [freq] = frequency of the data within the file (in time units) or 'month' (monthly values)
+      [auxmonth] = in case of 'month'
+        midmon: dates are given according to the mid time value of the month
+        real: dates are given increassing a month from the previous date
+  timesort, sort a variable time: timesort
+  timestepchg, changes a time-step value from a file, using a given time-step from another one: timestepchg -S [origtime_step]:[newfile]:[newtime_step]
+  valmod, modifiy values of variable -S [modification]:
+     sumc,[constant]: add [constant] to variables values
+     subc,[constant]: substract [constant] to variables values
+     mulc,[constant]: multipy by [constant] to variables values
+     divc,[constant]: divide by [constant] to variables values
+     lowthres,[threshold],[newvalue]: modify all values below [threshold] to [newvalue]
+     upthres,[threshold],[newvalue]: modify all values above [threshold] to [newvalue]
+  valmod_dim(values, ncfile, varn)
+
+  vartimeshidft, temporaly shift a number of time-steps a given variable inside a netCDF file: vartimeshift -S [nsteps]:[[FillValue]]
+  varmask, mask a variable using a mask: varmask -S [maskfilename]:[maskvar]:[dimsmask]:[timename]. It is assumed that mask[...,dimM,dimJ,dimK] 
+    and var[...,dimM,dimJ,dimK] share the last dimensions
+
+'addfattr': fattradd(opts.varname, opts.values, opts.ncfile)
+'addfdim': fdimadd(opts.values, opts.ncfile)
+'addfgattr': fgaddattr(opts.values, opts.ncfile)
+'addfvar': fvaradd(opts.values, opts.ncfile)
+'addgattr': gaddattr(opts.values, opts.ncfile)
+'addgattrk': gaddattrk(opts.values, opts.ncfile)
+'addref': varaddref(opts.values, opts.ncfile, opts.varname)
+'addvattr': varaddattr(opts.values, opts.ncfile, opts.varname)
+'addvattrk': varaddattrk(opts.values, opts.ncfile, opts.varname)
+'DataSetSection': datasetsection(opts.values,opts.ncfile)
+'dimflip': flipdim(opts.values,opts.ncfile,opts.varname)
+'infgattrs': igattr(opts.ncfile)
+'infsinggattrs': isgattrs(opts.values, opts.ncfile)
+'infsingvattrs': isvattrs(opts.values, opts.ncfile, opts.varname)
+'inftime': timeinf(opts.ncfile, opts.varname)
+'infvars': ivars(opts.ncfile)
+'infvattrs': ivattr(opts.ncfile, opts.varname)
+'mdname': chdimname(opts.values, opts.ncfile, opts.varname)
+'means': spacemean(opts.ncfile, opts.varname)
+'meanseas': spacemean(opst.values, opts.ncfile, opts.varname)
+'meant': timemean(opts.values, opts.ncfile, opts.varname)
+'mname': chvarname(opts.values, opts.ncfile, opts.varname)
+'out': varout(opts.values, opts.ncfile, opts.varname)
+'rgattr': grattr(opts.values, opts.ncfile)
+'rvattr': vrattr(opts.values, opts.ncfile, opts.varname)
+'rmgattr': grmattr(opts.values, opts.ncfile)
+'rmvariable': varrm(opts.ncfile, opts.varname)
+'rmvattr': varrmattr(opts.values, opts.ncfile, opts.varname)
+'subsetmns': submns(opts.values, opts.ncfile, opts.varname)
+'subsetyrs': subyrs(opts.values, opts.ncfile, opts.varname)
+'timescheck': check_times_file(opts.values, opts.ncfile, opts.varname)
+'timesort': sorttimesmat(opts.ncfile, opts.varname)
+'timestepchg': chgtimestep(opts.values, opts.ncfile, opts.varname)
+'valsadd': addvals(opts.values, opts.ncfile, opts.varname)
+'valmod': valmod(opts.values, opts.ncfile, opts.varname)
+'varmask': maskvar(opts.values, opts.ncfile, opts.varname)
+'vartimeshift': timeshiftvar(opts.values, opts.ncfile, opts.varname)
+"""
