Changeset 1874 in lmdz_wrf

Timestamp:

Mar 27, 2018, 9:57:55 PM (7 years ago)

Author:

lfita

Message:

Adding:

• `movie_2D_shad': creation of a movie with shading

Location:

trunk/tools

Files:

• drawing.py (modified) (6 diffs)
• drawing_tools.py (modified) (2 diffs)

trunk/tools/drawing.py

@@ -56 +56 @@
 ## e.g. # drawing.py -o draw_cycle -f 'Forcing_tairstats_OKstomate_CRUNCEP_spinup_SESA.nc;time_counter,-1|stats,2;time_centered;tair_stats' -S 'auto;y;centered;tair;K;None;12,3;lines,rainbow,horizontal,auto,-,2.;1,3,5@Sep/Nov,Jan/Jul,Mar/May;year|seconds!since!1958-01-01!00:00:00|exct,5,y|%Y;SESA;year-evolution!of!CRUNCEP!tair!forcing!at!SESA;0|10;png;cycle_tair_CRUNCEP_spinup_SESA;yes'
 ## e.g. # drawing.py -o draw_multi_2D_shad -f '../PY/wrfout_d01_1995-01-01_00:00:00@T2@west_east|-1,south_north|-1,Time|0;../PY/wrfout_d01_1995-01-01_00:00:00@T2@west_east|-1,south_north|-1,Time|1;../PY/wrfout_d01_1995-01-01_00:00:00@T2@west_east|-1,south_north|-1,Time|2;../PY/wrfout_d01_1995-01-01_00:00:00@T2@west_east|-1,south_north|-1,Time|3' -S 'tas:XLONG:XLAT:auto:rainbow,auto,auto:Srange,Srange:png:None:cyl,l:0!UTC,1!UTC,2!UTC,3!UTC:2:2:tas!at!2001-11-11:True'
-
+# movie_2D_shad -f '../PY/wrfout_d01_1995-01-01_00:00:00' -S 'tas:west_east|-1,south_north|-1,Time|-1:XLONG:XLAT:auto:rainbow,auto,auto:Srange,Srange:png:None:cyl,l:Time,Times:WRFdate,$%d^{%H}$:15:mp4' -v T2
 
 #######
@@ -99 +99 @@
 # draw_vertical_levels: plotting vertical levels distribution
 # draw_WindRose: Function to plot a wind rose (from where the dinw blows)
+# movie_2D_shad: creation of a movie with shading
 
 mainn = 'drawing.py'
@@ -119 +120 @@
   'draw_topo_geogrid_boxes', 'draw_trajectories', 'draw_vals_trajectories',          \
   'draw_vectors',  'draw_vertical_levels', 'list_graphics', 'draw_WindRose',         \
-  'variable_values']
+  'movie_2D_shad', 'variable_values']
 
 def draw_2D_shad(ncfile, values, varn, axfig=None, fig=None):
@@ -8460 +8461 @@
         [globaltitle]: global title of the figure ('!' for spaces)
         [close]: Whether figure should be finished or not
-      valules= 'rh:z|-1,x|-1:z|-1,x|-1:lat:pressure:BuPu:0.,100.:rh:pdf:flip@y:None'
-      varn= 
     """
 
@@ -8596 +8595 @@
     return
 #python drawing.py -o draw_multi_2D_shad -f '../PY/wrfout_d01_1995-01-01_00:00:00@T2@west_east|-1,south_north|-1,Time|0;../PY/wrfout_d01_1995-01-01_00:00:00@T2@west_east|-1,south_north|-1,Time|1;../PY/wrfout_d01_1995-01-01_00:00:00@T2@west_east|-1,south_north|-1,Time|2;../PY/wrfout_d01_1995-01-01_00:00:00@T2@west_east|-1,south_north|-1,Time|3' -S 'tas:XLONG:XLAT:auto:rainbow,auto,auto:Srange,Srange:png:None:cyl,l:0!UTC,1!UTC,2!UTC,3!UTC:2:2:tas!at!2001-11-11:True'
+
+def movie_2D_shad(ncfile, values, varn, axfig=None, fig=None):
+    """ creation of a movie with shading
+    movie_2D_shad(ncfile, values, varn)
+      ncfile= file to use
+      values=[vnamefs]:[dimvals]:[dimxvn]:[dimyvn]:[dimxyfmt]:[colorbarvals]:[sminv],[smaxv]:[figt]:
+       [kindfig]:[reverse]:[mapv]:[moviedim]:[fps]:[kmov]
+        [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:
+            * [integer]: which value of the dimension
+            * -1: all along the dimension
+            * -9: last value of the dimension
+            * [beg]@[end]@[inc] slice from [beg] to [end] every [inc]
+            * NOTE, no dim name all the dimension size
+        [dimx/yvn]: name of the variables with the values of the final dimensions (x,y)
+        [dimxyfmt]=[dxs],[dxf],[Ndx],[ordx],[dys],[dyf],[Ndy],[ordx]: format of the values at each axis (or 'auto')
+          [dxs]: style of x-axis ('auto' for 'pretty')
+            'Nfix', values computed at even 'Ndx'
+            'Vfix', values computed at even 'Ndx' increments
+            'pretty', values computed following aprox. 'Ndx' at 'pretty' intervals (2.,2.5,4,5,10)
+          [dxf]: format of the labels at the x-axis ('auto' for '%5g')
+          [Ndx]: Number of ticks at the x-axis ('auto' for 5)
+          [ordx]: angle of orientation of ticks at the x-axis ('auto' for horizontal)
+          [dys]: style of y-axis ('auto' for 'pretty')
+          [dyf]: format of the labels at the y-axis ('auto' for '%5g')
+          [Ndy]: Number of ticks at the y-axis ('auto' for 5)
+          [ordy]: angle of orientation of ticks at the y-axis ('auto' for horizontal)
+        [colorbarvals]=[colbarn],[fmtcolorbar],[orientation]
+          [colorbarn]: name of the color bar
+          [fmtcolorbar]: format of the numbers in the color bar 'C'-like ('auto' for %6g)
+          [orientation]: orientation of the colorbar ('vertical' (default, by 'auto'), 'horizontal')
+        [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)
+        [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', lambert conformal
+          [res]: resolution:
+            * 'c', crude
+            * 'l', low
+            * 'i', intermediate
+            * 'h', high
+            * 'f', full
+        [movievals] = [moviedim],[movivar] way to get values for the movie
+          [moviedime]: name of the dimension to get the movie (following outcome from [dimvals])
+          [movievar]: name of the variable to get the values
+        [framelabels]: values for the production of the labels of each frame
+          * 'varVal',[HeadTit],[TailTit],[fmt]: Following direct values from variable as:
+            [HeadTit] + ' ' + [varValue] + ' ' + [TailTit]
+              [HeadTit]: Head of title ('!', for spaces)
+              [TailTit]: title of title ('!', for spaces)
+              [fmt]: format of the values of the variable in the title (C-like)
+          * 'listtit',[Ftitles]: Providing manually title for each frame
+              [Ftitle]: '@' separated list of titles ('!', for titles)
+          * 'CFdate',[datefmt]: Just title with the date (assuming CF-time compilant variable)
+              [tfmt]: format of the date (C-like)
+          * 'WRFdate',[datefmt]: Just title with the date (assuming WRF time variable)
+              [tfmt]: format of the date (C-like)
+        [fps]: frames per second of the output movie
+        [kmov]: kind of movie (mp4, ....)
+      varn= [varsn] name of the variable to plot with shading
+    """
+    fname = 'movie_2D_shad'
+    if values == 'h':
+        print fname + '_____________________________________________________________'
+        print movie_2D_shad.__doc__
+        quit()
+
+    expectargs = '[vnamefs]:[dimvals]:[dimxvn]:[dimyvn]:[dimxyf]:[colbarvals]:' +    \
+      '[sminv],[smaxv]:[kindfig]:[reverse]:[mapv]:[movidime]:[framelabels]:[fps]' +  \
+      ':[kmov]'
+ 
+    drw.check_arguments(fname,values,expectargs,':')
+
+    vnamesfig = values.split(':')[0]
+    dimvals= values.split(':')[1].replace('|',':')
+    vdimxn = values.split(':')[2]
+    vdimyn = values.split(':')[3]
+    dimxyf = values.split(':')[4]
+    colorbarvals = values.split(':')[5]
+    shadminmax = values.split(':')[6]
+    figkind = values.split(':')[7]
+    revals = values.split(':')[8]
+    mapvalue = values.split(':')[9]
+    movievals = values.split(':')[10].split(',')
+    framelabelS = values.split(':')[11]
+    fps = int(values.split(':')[12])
+    kmov = values.split(':')[13]
+
+    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 + '" !!'
+        varns = sorted(objsf.variables.keys())
+        print '    available ones:', varns
+        quit(-1)
+
+# Variables' values
+    objvars = objsf.variables[varns]
+
+    valshad, dimsshad = drw.slice_variable(objvars, dimvals.replace(',','|'))
+    dimnamesv = [vdimxn, vdimyn]
+
+    # Movie variable
+    moviedim = movievals[0]
+    movievar = movievals[1]
+    idd = 0
+    for dn in objvars.dimensions:
+        if dn == moviedim: 
+            NumDimT = idd
+        break
+        idd = idd + 1 
+
+    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 = '-'
+
+    odimxv, odimyv = drw.dxdy_lonlatDIMS(objdimx[:], objdimy[:], objdimx.dimensions,     \
+      objdimy.dimensions, dimvals.replace(':','|').split(','))
+
+    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
+
+    colbarn, fmtcolbar, colbaror = drw.colorbar_vals(colorbarvals,',')
+    colormapv = [colbarn, fmtcolbar, colbaror]
+
+    xstyl, xaxf, Nxax, xaxor, ystyl, yaxf, Nyax, yaxor = drw.format_axes(dimxyf,',')
+    xaxis = [xstyl, xaxf, Nxax, xaxor]
+    yaxis = [ystyl, yaxf, Nyax, yaxor]
+
+    if revals == 'None':
+        revals = None
+
+    if not objsf.variables.has_key(movievar):
+        oncvars = objsf.variables.keys()
+        oncvars.sort()
+        print errormsg
+        print '  ' + fname + ": file '" + ncfile + "' does not have variable '" +    \
+          movievar + "' to get from the values for the frames!!"
+        print '    available ones:', oncvars
+        quit(-1)
+    omovievar = objsf.variables[movievar]
+    movievarv, dimsmov = drw.slice_variable(omovievar, dimvals.replace(',','|'))
+
+    # Labels for frames
+    framelabels = []
+    if framelabelS[0:6] == 'varVal':
+        HeadTit = framelabelS.split(',')[1]
+        TailTit = framelabelS.split(',')[2]
+        fmt = framelabelS.split(',')[3]
+
+        if len(movievarv.shape) != 1:
+            print errormsg
+            print '  ' + fname + ": for frame labels type 'varVal' is required a " + \
+              " rank 1 variable !!"
+            print "    variable '" + movievar + "' shape:", vn.shape
+            quit(-1)
+        dimt = movievarv.shape[0]
+        for it in range(dimt):
+            framelabels.append(gen.latex_tex(HeadTit) + ' ' +                        \
+              '{}'.format(movievarv[it]) + ' ' + gen.latex_tex(TailTit))
+
+    elif framelabelS[0:7] == 'listtit':
+        frameS = framelabelS.split(',')[1].split('@')
+        dimt = len(frameS)
+        for it in range(dimt):
+            framelabels.append(gen.latex_tex(frameS[it].replace('!', ' ')))
+
+    elif framelabelS[0:6] == 'CFdate':
+        import datetime as dt
+        tfmt = framelabelS.split(',')[1]
+        if len(movievarv.shape) != 1:
+            print errormsg
+            print '  ' + fname + ": for frame labels type 'CFdate' is required a " + \
+              " rank 1 variable !!"
+            print "    variable '" + movievar + "' shape:", movievarv.shape
+            quit(-1)
+        tunits = omovievar.getncattr('units')
+        tcalendar = omovievar.getncattr('calendar')
+        datesv = gen.netCDFdatetime_realdatetime(tunits, tcalendar, movievarv[:])
+        dimt = omovievar.shape[0]
+        for it in range(dimt):
+            dateV = dt.datetime(datesv[it][0], datesv[it][1], datesv[it][2],         \
+              datesv[it][3], datesv[it][4], datesv[it][5])
+            framelabels.append(dateV.strftime(tfmt))
+
+    elif framelabelS[0:7] == 'WRFdate':
+        import datetime as dt
+        tfmt = framelabelS.split(',')[1]
+        if len(movievarv.shape) != 2:
+            print errormsg
+            print '  ' + fname + ": for frame labels type 'WRFtime' is required a "+ \
+              " rank 2 variable !!"
+            print "    variable '" + movievar + "' shape:", movievarv.shape
+            quit(-1)
+        timev, tunits = ncvar.compute_WRFtime(movievarv[:])
+        datesv = gen.netCDFdatetime_realdatetime(tunits, 'standard', timev)
+        dimt = omovievar.shape[0]
+        for it in range(dimt):
+            dateV = dt.datetime(datesv[it][0], datesv[it][1], datesv[it][2],         \
+              datesv[it][3], datesv[it][4], datesv[it][5])
+            framelabels.append(dateV.strftime(tfmt))
+
+    drw.movie_2D_shadow(valshad, NumDimT, vnamesfig, odimxv, odimyv, odimxu, odimyu, \
+      xaxis, yaxis, dimnamesv, colormapv, shading_nx, varunits, framelabels,         \
+      figkind, revals, mapvalue, fps, kmov)
+
+    return
+
+#python drawing.py -o movie_2D_shad -f '../PY/wrfout_d01_1995-01-01_00:00:00' -S 'tas:west_east|-1,south_north|-1,Time|-1:XLONG:XLAT:auto:rainbow,auto,auto:Srange,Srange:png:None:cyl,l:Time,Times:WRFdate,$%d^{%H}$:15:mp4' -v T2
 
 #quit()
@@ -8748 +9022 @@
     elif oper == 'draw_WindRose':
         draw_WindRose(opts.ncfile, opts.values, opts.varname)
+    elif oper == 'movie_2D_shad':
+        movie_2D_shad(opts.ncfile, opts.values, opts.varname)
     elif oper == 'variable_values':
         variable_values(opts.values)

trunk/tools/drawing_tools.py

@@ -117 +117 @@
 # check_arguments:
 # Str_Bool:
+# movie_2D_shadow: Plot of a 2D field with shadow
+# multi_plot_2D_shadow: plot of multiple 2D shadowing variables sharing colorbar
 # pixelgrid: Function to provide the kind of grid distribution for a plot
 # plot_points:
@@ -11098 +11100 @@
     return
 
+def movie_2D_shadow(varsv, dimT, vnames, dimxv, dimyv, dimxu, dimyu, xaxv, yaxv,     \
+  dimn, cbarv, vs, uts, ltit, kfig, reva, mapv, framesec, kmov):
+    """ Plot of a 2D field with shadow
+      varsv= 3D values to plot each frame with shading
+      dimT= number of the dimension to be used as time-loop
+      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
+      xaxv= list with the x-axis paramteres [style, format, number and orientation]
+      yaxv= list with the y-axis paramteres [style, format, number and orientation]
+      dimn= dimension names to plot
+      cbarv= list with the parameters of the color bar [colorbar, cbarfmt, cbaror]
+        colorbar: name of the color bar to use
+        cbarfmt: format of the numbers in the colorbar
+        cbaror: orientation of the colorbar
+      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
+      ltit= list of titles for each frame
+      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
+      fremessec= frames per second of the output movie
+      kmov= kind of movie putput (mp4)
+    """
+    import matplotlib.animation as manimation
+    fname = 'movie_2D_shadow'
+
+    ofile = "movie_2D_shadow." + kmov
+
+    if type(varsv) == type('S') and varsv == 'h':
+        print fname + '_____________________________________________________________'
+        print movie_2D_shadow.__doc__
+        quit()
+
+    if len(varsv.shape) != 3:
+        print errormsg
+        print '  ' + fname + ': wrong variable shadow rank:', varsv.shape,           \
+          'is has to be 3D!!'
+        quit(-1)
+
+
+    # Getting the right lon values for plotting
+    if mapv is not None:
+        dimxv = np.where(dimxv > 180., dimxv-360., dimxv)
+
+    # Axis ticks
+    # Usually axis > x must be the lon, thus...
+    dimxv0 = dimxv.copy()
+    dimyv0 = dimyv.copy()
+
+    dxn = dimxv.min()
+    dxx = dimxv.max()
+    dyn = dimyv.min()
+    dyx = dimyv.max()
+
+    if xaxv[0] == 'pretty':
+        dimxt0 = np.array(gen.pretty_int(dxn,dxx,xaxv[2]))
+    elif xaxv[0] == 'Nfix':
+        dimxt0 = np.arange(dxn,dxx,(dxx-dxn)/(1.*xaxv[2]))
+    elif xaxv[0] == 'Vfix':
+        dimxt0 = np.arange(0,dxx,xaxv[2])
+    if yaxv[0] == 'pretty':
+        dimyt0 = np.array(gen.pretty_int(dyn,dyx,yaxv[2]))
+    elif yaxv[0] == 'Nfix':
+        dimyt0 = np.arange(dyn,dyx,(dyx-dyn)/(1.*yaxv[2]))
+    elif yaxv[0] == 'Vfix':
+        dimyt0 = np.arange(0,dyx,yaxv[2])
+
+    dimxl0 = []
+    for i in range(len(dimxt0)): dimxl0.append('{:{style}}'.format(dimxt0[i], style=xaxv[1]))
+    dimyl0 = []
+    for i in range(len(dimyt0)): dimyl0.append('{:{style}}'.format(dimyt0[i], style=yaxv[1]))
+
+    dimxT0 = variables_values(dimn[0])[0] + ' (' + units_lunits(dimxu) + ')'
+    dimyT0 = variables_values(dimn[1])[0] + ' (' + units_lunits(dimyu) + ')'
+
+    if mapv is not None:
+        pixkind = 'data'
+    else:
+        # No following data values
+        dimxt0 = np.arange(len(dimxt0),dtype=np.float)/(len(dimxt0))
+        dimyt0 = np.arange(len(dimyt0),dtype=np.float)/(len(dimyt0))
+        pixkind = 'fixpixel'
+
+    if reva is not None:
+        varsv, dimxv, dimyv, dimxt, dimyt, dimxl, dimyl, dimxT, dimyT =              \
+          transform(varsv, reva, dxv=dimxv0, dyv=dimyv0, dxt=dimxt0, dyt=dimyt0,     \
+          dxl=dimxl0, dyl=dimyl0, dxtit=dimxT0, dytit=dimyT0)
+    else:
+        dimxv = dimxv0
+        dimyv = dimyv0
+        dimxt = dimxt0
+        dimyt = dimyt0
+        dimxl = dimxl0
+        dimyl = dimyl0
+        dimxT = dimxT0
+        dimyT = dimyT0
+
+    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 = dimxv
+#    lat0 = dimyv
+    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 = 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]
+
+        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:
+        # No following data values
+        x = (dimxv-np.min(dimxv))/(np.max(dimxv) - np.min(dimxv))
+        y = (dimyv-np.min(dimyv))/(np.max(dimyv) - np.min(dimyv))
+
+# Changing limits of the colors
+    vsend = graphic_range(vs,varsv)
+
+    # FROM: https://matplotlib.org/examples/animation/moviewriter.html
+    FFMpegWriter = manimation.writers['ffmpeg']
+    cmt = vnames
+    metadata = dict(title=cmt, artist='Matplotlib', comment='PyNCplot')
+    writer = FFMpegWriter(fps=framesec, metadata=metadata)
+
+    fig = plt.figure()
+    plt.rc('text', usetex=True)
+
+    dimt = varsv.shape[dimT]
+
+    with writer.saving(fig, ofile, dimt):
+        for it in range(dimt):
+            slicev = []
+            for idn in range(3):
+                if idn == dimT: slicev.append(it)
+                else: slicev.append(slice(0,varsv.shape[idn]))
+            vv = varsv[tuple(slicev)]
+
+            plt.pcolormesh(x, y, vv, cmap=plt.get_cmap(cbarv[0]), vmin=vsend[0], vmax=vsend[1])
+            if cbarv[2] == 'horizontal':
+                cbar = plt.colorbar(format=cbarv[1],orientation=cbarv[2])
+                # From: http://stackoverflow.com/questions/32050030/rotation-of-colorbar-tick-labels-in-matplotlib
+                ticklabels= cbar.ax.get_xticklabels()
+                Nticks = len(ticklabels)
+                ticklabs = []
+                for itick in range(Nticks): ticklabs.append(ticklabels[itick].get_text())
+                cbar.ax.set_xticklabels(ticklabs,rotation=90)
+            else:
+                cbar = plt.colorbar(format=cbarv[1],orientation=cbarv[2])
+        
+            if not mapv is None:
+                if cbarv[0] == 'gist_gray':
+                    m.drawcoastlines(color="red")
+                else:
+                    m.drawcoastlines()
+    
+                meridians = gen.pretty_int(nlon,xlon,xaxv[2])
+                m.drawmeridians(meridians,labels=[True,False,False,True])
+                parallels = gen.pretty_int(nlat,xlat,yaxv[2])
+                m.drawparallels(parallels,labels=[False,True,True,False])
+    
+                plt.xlabel('W-E')
+                plt.ylabel('S-N')
+            else:
+                plt.xlabel(dimxT)
+                plt.ylabel(dimyT)
+
+            plt.axis([x.min(), x.max(), y.min(), y.max()])
+
+            if mapv is None:
+                plt.xticks(dimxt, dimxl, rotation=xaxv[3])
+                plt.yticks(dimyt, dimyl, rotation=yaxv[3])
+
+            # units labels
+            cbar.set_label(gen.latex_text(vnames) + ' (' + units_lunits(uts) + ')')
+
+            graphtit = gen.latex_text(ltit[it])
+            plt.title(gen.latex_text(graphtit))
+
+            #figname = '2D_shadow_frame' + str(it).zfill(int(np.log10(dimt))+1)
+            #output_kind(kfig, figname, True)
+
+            writer.grab_frame()
+            plt.clf()
+            plt.cla()
+    
+
+    print fname + ": successful creation of movie '" + ofile + "' !!"
+
+    return
+
+