Changeset 2384 in lmdz_wrf for trunk

Timestamp:

Mar 8, 2019, 2:04:38 PM (6 years ago)

Author:

lfita

Message:

Adding:

• `CFfile_creation': Operation to create a file folowing CF-conventions

Location:

trunk/tools

Files:

• nc_var.py (modified) (5 diffs)
• nc_var_tools.py (modified) (6 diffs)

trunk/tools/nc_var.py

@@ -74 +74 @@
 ## e.g. # nc_var.py -o usefile_compute_slices_stats_areaweighted -S 'compute_slices_stats_areaweighted.nc@XLAT_M-HGT_M-rangefaces@Time|WRFtime:west_east|XLONG_M:south_north|XLAT_M:land_cat|INTrange@Time,land_cat' -f 'geo_em.d01.nc' -v 'LANDUSEF'
 ## e.g. # nc_var.py -o compress_data -S 'XLAND:Time|0:single,1:X|west_east|XLONG,Y|south_north|XLAT' -f wrfout_d01_1995-01-01_00:00:00 -v T2,LU_INDEX,Times
+## e.g. # nc_var.py -o CFfile_creation -S 'lon|360,lat|180,time|None@20:global' -v 'tas#time;lat;lon#f#None,time#time#f8#units|seconds!since!1949-12-01!00:00:00|S' -f newCF.nc
 
 from optparse import OptionParser
@@ -90 +91 @@
 #   of matrices assuming regular lon/lat projections without taking into account Earth's curvature
 # CDO_toCF: Function to pass a CDO output file to CF-conventions
+# CFfile_creation: Operation to create a file folowing CF-conventions 
 # CFmorzization: Function to provide a CF-compilation version of a variable within a file
 # chdimname: Changing the name of the dimension
@@ -229 +231 @@
 
 operations=['addDim', 'addVar', 'addvals', 'area_weighted', 'CDO_toCF',              \
-  'CFmorzization', 'chdimname', 'changevartype',                                     \
+  'CFfile_creation', 'CFmorzization', 'chdimname', 'changevartype',                  \
   'checkallvars', 'checkAllValues', 'checkNaNs',                                     \
   'chgtimestep', 'chvarname', 'cleaning_varsfile', 'compress_data',                  \
@@ -311 +313 @@
 
 # Operations which file name is not a real file
-NotCheckingFile = ['area_weighted', 'DatesFiles', 'compute_opersvarsfiles',          \
-  'file_creation',                                                                   \
+NotCheckingFile = ['area_weighted', 'CFfile_creation','DatesFiles',                  \
+  'compute_opersvarsfiles', 'file_creation',                                         \
   'join_singlestation_obsfiles', 'join_sounding_obsfiles', 'list_operations',        \
   'merge_files',                                                                     \
@@ -352 +354 @@
 elif oper == 'CDO_toCF':
     ncvar.CDO_toCF(opts.ncfile)
+elif oper == 'CFfile_creation':
+    ncvar.CFfile_creation(opts.values, opts.ncfile, opts.varname)
 elif oper == 'CFmorzization':
     ncvar.CFmorzization(opts.values, opts.ncfile, opts.varname)

trunk/tools/nc_var_tools.py

@@ -33 +33 @@
 # basicvardef: Function to give the basic attributes to a variable (std_name, long_name, units)
 # CDO_toCF: Function to pass a CDO output file to CF-conventions
+# CFfile_creation: Operation to create a file folowing CF-conventions 
 # CFmorzization: Function to provide a CF-compilation version of a variable within a file
 # CFvars: Function to adapt a given variable and file following CF-standards
@@ -31068 +31069 @@
     """ Operation to create a file folowing CF-conventions 
       values= [dimensions]:[lonlatbox]
-        [dimensions]: lon|[dsizelon],lat|[dsizelat],...,[dimnN]:[dsizeN], ',' pairs of variable 
-          name [dimn] and [size]
-          if [dsize] = 'None' (for UNLIMITED), give a third value with the real size
+        [dimensions]: lon|[dsizelon],lat|[dsizelat],...,[dimnN]|[dsizeN], ',' pairs 
+          of variable name [dimn] and [size]
+          * if [dsize] = 'None' (for UNLIMITED), provide size of dimension as 
+             'None'@[size]
         [lonlatbox]: ',' separated list of the extremes of the domain [SWlon],[SWlat],
           [NElon],[NElat] or 'global' for a global file [assuing lon/lat regular 
           projection]
-      ncfile= name of the file
-      variables= ',' list of variables to create [varn]:[dims]:[kind]:[varaddattributes] 
+      ncfile= name of the file to produce
+      variables= ',' list of variables to create [varn]#[dims]#[kind]#[vaddattributes]
           and its characterisitcs
-        [varn]: CF name of the variable (attributes will be retrived from 
-           'variables_values.dat')
-        [dims]: ',' python sorted list of dimensions of the variable
+        [varn]: CF name of the variable (basic attributes: standard_name, long_name 
+           and units, will be retrived from 'variables_values.dat')
+        [dims]: ';' sorted list of dimensions of the variable ([...], [t], [z], y, x)
         [kind]: type of variable (standard netCDF4/C-like values, 'c', 'i', 'f', 
           'f8',...)
-        [varaddattributes]: ',' list of additional attributes and their values for 
-          the variable [attrn]|[attrv]
+        [varaddattributes]: ';' list of additional attributes and their values for 
+          the variable [attrn]|[attrv]|[attrk] ('None' for any) '!' for spaces in 
+          string attributes
+          [attrn]: name of the attribute
+          [attrv]: value of the attribute
+          [attrk]: kind of the attribute('S': string, 'I': integer, 'F': float, ...)
     """
     fname = 'CFfile_creation'
+    availkind = ['c', 'i', 'f', 'f8']
 
     if values == 'h':
@@ -31109 +31116 @@
     onewnc = NetCDFFile(ncfile, 'w')
 
-    dimx = dimensions['lon']
-    dimy = dimensions['lat']
+    dimx = int(dimensions['lon'])
+    dimy = int(dimensions['lat'])
 
     # Assuming regular lon/lat projection
     if lonlatbox == 'global':
-        ddx = 360./(dimx-1)
+        ddx = 360./(dimx)
         ddx2 = ddx/2.
         lons = np.arange(-180.+ddx2,180.+ddx2,ddx)
-        ddy = 180./(dimy-1)
+        ddy = 180./(dimy)
         ddy2 = ddy/2.
         lats = np.arange(-90.+ddy2,90.+ddy2,ddy)
     elif lonlatbox.count(',') == 3:
         [lonSW, latSW, lonNE, latNE] = str_listk(lonlatbox, ',', 'F')
-        ddx = (lonNE-lonSW)/(dimx-1)
+        ddx = (lonNE-lonSW)/(dimx)
         ddx2 = ddx/2.
         lons = np.arange(lonSW-ddx2,lonNE+ddx2,ddx)
-        ddy = (latNE-latSW)/(dimy-1)
+        ddy = (latNE-latSW)/(dimy)
         ddy2 = ddy/2.
         lats = np.arange(latSW-ddy2,latNE+ddy2,ddy)
 
+    print 'Lluis shapes lons:', lons.shape, 'lats:', lats.shape
     # Sorting lon/lat_bounds
-    lon_bnds = np.zeros((2,dimx), dtype=np.float64)
-    lat_bnds = np.zeros((2,dimy), dtype=np.float64)
+    lon_bnds = np.zeros((dimx,2), dtype=np.float64)
+    lat_bnds = np.zeros((dimy,2), dtype=np.float64)
     for i in range(dimx):
-        lon_bnds[0,i] = lons[i]-ddx2
-        lon_bnds[1,i] = lons[i]+ddx2
+        lon_bnds[i,0] = lons[i]-ddx2
+        lon_bnds[i,1] = lons[i]+ddx2
     for j in range(dimy): 
-        lat_bnds[0,j] = lats[j]-ddy2
-        lat_bnds[1,j] = lats[j]+ddy2
+        lat_bnds[j,0] = lats[j]-ddy2
+        lat_bnds[j,1] = lats[j]+ddy2
 
     # Dimensions
@@ -31147 +31155 @@
     for dn in dimensions:
         if dn != 'lon' and dn != 'lat':
-            if dn == 'time': dl = None
-            else: dl = dimensions[dn]
-            newdim = onewnc.createDimension(dn, None)
+            if dimensions[dn][0:4] == 'None': dl = None
+            else: dl = int(dimensions[dn])
+            newdim = onewnc.createDimension(dn, dl)
     onewnc.sync()
 
@@ -31159 +31167 @@
     newvar.setncattr('axis', 'X')
     newvar.setncattr('_CoordinateAxisType', 'Lon')
+    newvar.setncattr('bounds', 'lon_bnds')
 
     newvar = onewnc.createVariable('lat', 'f4', ('lat'))
@@ -31166 +31175 @@
     newvar.setncattr('axis', 'Y')
     newvar.setncattr('_CoordinateAxisType', 'Lat')
+    newvar.setncattr('bounds', 'lat_bnds')
+
+    # Creation of variable dimensions
+    newvar = onewnc.createVariable('lon_bnds', 'f4', ('lon', 'bnds'))
+    newvar[:] = lon_bnds[:]
+    newvar = onewnc.createVariable('lat_bnds', 'f4', ('lat', 'bnds'))
+    newvar[:] = lat_bnds[:]
+
+    # Projection
+    projn = 'regular_latlon'
+    newvar = onewnc.createVariable(projn, 'c')
+    newvar.setncattr('grid_mapping_name', 'latitude_longitude')
 
     onewnc.sync()
 
     varns = variables.split(',')
-    for varn in varns:
-        print varn
-
-    dnames = []
-    dsize = []
-    for dim in dimensions:
-#        print "  Adding: '" + dim + "' ..."
-        dimn = dim.split(':')[0]
-        dimv = dim.split(':')[1]
-        if dimv == 'None':
-            if len(dim.split(':')) != 3:
+    for varvn in varns:
+        varn = varvn.split('#')[0]
+        dims = varvn.split('#')[1].split(';')
+        kind = varvn.split('#')[2]
+
+        # Checking variable's dimensions
+        varshape = []
+        for dn in dims:
+            if not onewnc.dimensions.has_key(dn):
                 print errormsg
-                print '  ' + fname + ": dimension '" + dimn + "' is None but the " + \
-                  'size is requried!!'
+                print '  ' + fname + ": CF netCDF file does not have dimension '" +  \
+                  dn + "' !!"
+                print "    provide values for the dimension as [dimensions]= " +     \
+                  "[dimnN]|[dsizeN]"
+                Dims = list(onewnc.dimensions.keys())
+                Dims.sort()
+                print '    available ones:', Dims
                 quit(-1)
             else:
-                dv = None
-                dsize.append(int(dim.split(':')[2]))
+                if dimensions[dn][0:4] == 'None':
+                    dsize = int(dimensions[dn].split('@')[1])
+                else:
+                    dsize = len(onewnc.dimensions[dn])
+                varshape.append(dsize)
+
+        # Getting variable basic attributes
+        cfvarvals = gen.variables_values(varn)
+
+        print '  ' + fname + ": adding '" + varn + "' (", dims, ") '", kind, "' ..."
+
+        varaddattributes = varvn.split('#')[3]
+        if varaddattributes != 'None': 
+            vaddattr = {}
+            addattr = varaddattributes.split(';')
+            for attr in addattr:
+                attrv = attr.split('|')
+                vaddattr[attrv[0]] = attrv[1:4]
+            print '    addiditional attributes _______'
+            gen.printing_dictionary(vaddattr)
         else:
-            dv = int(dimv)
-            dsize.append(dv)
-
-        dnames.append(dimn)
-
-        newdim = onc.createDimension(dimn, dv)
+            vaddattr = None
+
+        # creation
+        if kind == 'c':
+            newvar = onewnc.createVariable(varn, 'c', tuple(dims))
+        if kind == 'f' or kind == 'f4':
+            newvar = onewnc.createVariable(varn, 'f4', tuple(dims),                  \
+              fill_value=gen.fillValueF)
+            newvar[:] = np.zeros(tuple(varshape), dtype=np.float)
+        elif kind == 'f8':
+            newvar = onewnc.createVariable(varn, 'f8', tuple(dims),                  \
+              fill_value= gen.fillValueD)
+            newvar[:] = np.zeros(tuple(varshape), dtype=np.float64)
+        elif kind == 'i':
+            newvar = onewnc.createVariable(varn, 'i', tuple(dims),                   \
+              fill_value=gen.fillValueI)
+            newvar[:] = np.zeros(tuple(varshape), dtype=int)
+        else:
+            print errormsg
+            print '  ' + fname + ": variable kind '" + kind + "' not ready!!"
+            print '    available ones:', availkind
+            quit(-1)
     
-    onc.sync()
-
-# Variable
-    if kind == 'c':
-        newvar = onc.createVariable(varn, 'c', tuple(dnames))
-#        newvar[:] = np.zeros(tuple(dsize), dtype=np.float)
-    if kind == 'f' or kind == 'f4':
-        newvar = onc.createVariable(varn, 'f4', tuple(dnames),                       \
-          fill_value=gen.fillValueF)
-        newvar[:] = np.zeros(tuple(dsize), dtype=np.float)
-    elif kind == 'f8':
-        newvar = onc.createVariable(varn, 'f8', tuple(dnames),                       \
-          fill_value= gen.fillValueD)
-        newvar[:] = np.zeros(tuple(dsize), dtype=np.float64)
-    elif kind == 'i':
-        newvar = onc.createVariable(varn, 'i', tuple(dnames),                        \
-          fill_value=gen.fillValueI)
-        newvar[:] = np.zeros(tuple(dsize), dtype=int)
-    else:
-        print errormsg
-        print '  ' + fname + ": variable kind '" + kind + "' not ready!!"
-        quit(-1)
-
-    sname = attributes.split('@')[0].replace('!', ' ')
-    lname = attributes.split('@')[1].replace('!', ' ')
-    u = attributes.split('@')[2].replace('!', ' ')
-    
-    newattr = basicvardef(newvar, sname, lname, u)
-
-    onc.sync()
-
-# Global attributes
-    newattr = set_attribute(onc, 'description', "file creation using " + fname )
-    onc.sync()
-    onc.close()
-
-#file_creation('time_counter:12,sizes:24|time@time@seconds since 1949-12-01 00:00:00|f8', 'test.nc', 't_instant')
+        basicvardef(newvar, cfvarvals[1], cfvarvals[4].replace('|',' '), cfvarvals[5])
+        newvar.setncattr('grid_mapping', projn)
+        if vaddattr is not None:
+            for attrn in vaddattr.keys():
+                attrv = vaddattr[attrn]
+                if attrv[1] == 'S': 
+                    set_attributek(newvar, attrn, attrv[0].replace('!', ' '), attrv[1])
+                else:
+                    set_attributek(newvar, attrn, attrv[0], attrv[1])
+
+        onewnc.sync()
+
+    # Global attributes
+    onewnc.setncattr('Conventions', 'CF-1.5')
+    add_global_PyNCplot(onewnc, 'nc_var_tools', fname, '1.0')
+
+    onewnc.sync()
+    onewnc.close()
+
+    print fname + ": Successfully written CF-file '" + ncfile + "' !!"
+
+    return
+
+#values='lon|360,lat|180,time|None@20:global'
+#varsS='tas#time;lat;lon#f#None,time#time#f8#units|seconds!since!1949-12-01!00:00:00|S'
+#CFfile_creation(values, 'CFtest.nc', varsS)