Changeset 2312 in lmdz_wrf for trunk/tools


Ignore:
Timestamp:
Feb 1, 2019, 10:24:29 PM (6 years ago)
Author:
lfita
Message:

Starting to deal with 1D-dimensions on 2D fields !

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/tools/nc_var_tools.py

    r2311 r2312  
    2773127731      values=[slicevarsinf]@[dimvars]@[sliceremovedim]@[slicebndsdim]@
    2773227732          [slicebndsvar]@[slicestatsdim]
    27733         [slicevarsinf] ';' separated list of [varn1],[minvar1],[maxvar1],
    27734           [slcevar1]; ...;[varnN],[minvarN],[maxvarN],[slcevarN]
     27733        [slicevarsinf] ';' separated list of [varn1],[slcvar1];...;[varnN],[slcvarN]
    2773527734          varn[i]: name of the variable i
    27736           minvar[i]: minimum value to start the slices for variable i
    27737           maxvar[i]: maximum value to end the slices for variable i
    27738           slcevar[i]: length of slices in variable i
    27739             NOTE: slices will be:
    27740                [minvar[i]-slicevar[i]/2., minvar[i]+slicevar[i]/2.), ...,
    27741                [maxvar[i]-slicevar[i]/2., maxvar[i]+slicevar[i]/2.)
     27735          slcvar[i]: characteristics of the slicing of the variable. Two options:
     27736            *slcvar[i] = minvar[i], maxvar[i], slcevar[i] equi-distributed
     27737              minvar[i]: minimum value to start the slices for variable i
     27738              maxvar[i]: maximum value to end the slices for variable i
     27739              slcevar[i]: length of slices in variable i
     27740                NOTE: slices will be:
     27741                   [minvar[i]-slicevar[i]/2., minvar[i]+slicevar[i]/2.), ...,
     27742                   [maxvar[i]-slicevar[i]/2., maxvar[i]+slicevar[i]/2.)
     27743            *slcvar[i] = 'fixed',slcevals[i] fixed values
     27744              slcevals[i]: ',' separated list of pairs ('|' separated) of values to
     27745                  determine slices:
     27746                slcvals[i] = [begslc1]|[endslc1],...,[begslcM]|[endslcM]
     27747                NOTE: slices will be:
     27748                  [[begslc1], [endslc1]), ...,  [begslcM], [endslcM]]
    2774227749        [dimvars]: ':' separated list of [dimn]|[vardimn] dimension name [dimn] and
    2774327750          its associated dimension-variable to get its values to provide values for
    … …  
    2781527822        sliceremovdim = None
    2781627823
    27817     varvals = {}
     27824    Svarvals = {}
    2781827825    slcvarns = []
    2781927826    for varvls in varvalues:
    27820         expectargs = '[varni],[minvari],[maxvari],[slcevari]'
    27821         gen.check_arguments(fname, varvls, expectargs, ',')
    27822 
    27823         varni = varvls.split(',')[0]
    27824         minvari = np.float(varvls.split(',')[1])
    27825         maxvari = np.float(varvls.split(',')[2])
    27826         slicevari = np.float(varvls.split(',')[3])
    27827         varvals[varni] = [minvari, maxvari, slicevari]
     27827        vvv = varvls.split(',')
     27828        Nvvv = len(vvv)
     27829
     27830        varni = vvv[0]
    2782827831        slcvarns.append(varni)
     27832        Svarvals[varni] = vvv[1:Nvvv+1]
    2782927833    Nslcvars = len(slcvarns)
    2783027834
    … …  
    2785827862
    2785927863    # Preparing slices and output file
     27864    varvals= {}
    2786027865    for varn in slcvarns:
    2786127866        if not onc.variables.has_key(varn):
    … …  
    2787227877        dimnv = list(ovar.dimensions)
    2787327878         
    27874         vvls = varvals[varn]
    27875         minvar = vvls[0]
    27876         maxvar = vvls[1]
    27877         slicevar = vvls[2]
    27878 
    27879         dvar = (maxvar-minvar+slicevar)/slicevar
    27880         slices = np.arange(minvar, maxvar+slicevar, slicevar)
    27881         Nslices = slices.shape[0]
    27882 
    27883         print '    ' + fname + ': slices ____'
    27884         print '      var:', varn, ':', Nslices, '(', minvar, ',', maxvar+slicevar,   \
    27885           ',', slicevar, ')'
     27879        vvls = Svarvals[varn]
     27880        if vvls[0] == 'fixed':
     27881            Nslices = len(vvls) - 1
     27882            slices = np.zeros((Nslices), dtype=np.float)
     27883            ivv = 0
     27884            print '    ' + fname + ': variable:', varn, ':', Nslices, 'slices ____'
     27885            islc = 0
     27886            for vv in vvls[1:Nslices+1]:
     27887                islc = np.float(vv.split('|')[0])
     27888                eslc = np.float(vv.split('|')[1])
     27889                slices[ivv] = (islc+eslc)/2.
     27890                ivv = ivv + 1
     27891                print '      ', islc, ':', '[', islc,',', eslc, ')'
     27892                islc = islc + 1
     27893
     27894        else:
     27895            minvar = np.float(vvls[0])
     27896            maxvar = np.float(vvls[1])
     27897            slicevar = np.float(vvls[2])
     27898            varvals[varni] = [minvar, maxvar, slicevar]
     27899
     27900            dvar = (maxvar-minvar+slicevar)/slicevar
     27901            slices = np.arange(minvar, maxvar+slicevar, slicevar)
     27902            Nslices = slices.shape[0]
     27903
     27904            print '    ' + fname + ': slices ____'
     27905            print '      var:', varn, ':', Nslices, '(', minvar,',', maxvar+slicevar,\
     27906              ',', slicevar, ')'
    2788627907
    2788727908        # Removing undesired dimensions from slicing variable
    … …  
    2790427925        for islc in range(Nslices):
    2790527926            slcvalsc[islc] = slices[islc]
    27906             slcvals[islc,0] = slices[islc]-slicevar/2.
    27907             slcvals[islc,1] = slices[islc]+slicevar/2.
     27927
     27928            if vvls[0] == 'fixed':
     27929                vv = vvls[islc+1]
     27930                slci = np.float(vv.split('|')[0])
     27931                slce = np.float(vv.split('|')[1])
     27932                slcvals[islc,0] = slci
     27933                slcvals[islc,1] = slce
     27934            else:
     27935                slcvals[islc,0] = slices[islc]-slicevar/2.
     27936                slcvals[islc,1] = slices[islc]+slicevar/2.
    2790827937
    2790927938            #slcvar[islc,] = ma.masked_inside(varv, slcvals[islc,0], slcvals[islc,1]).mask
    … …  
    2802828057                    print infmsg
    2802928058                    print '    ' + fname + ": slicing dimension '" + dn + "' ... "
     28059
     28060                    # Checking for the existence of slicing information for the 
     28061                    #   bounded variable
     28062                    if not slicesinf.has_key(dn):
     28063                        # Equivalent dimension-variable which should already by there
     28064                        dnn = gen.dictionary_key(slicebndsdim, dn)
     28065                        slicesinf[dn] = slicesinf[dnn]
     28066
    2803028067                    varslcv = slicesinf[dn]
    2803128068                    Nslices = varslcv[0]
    … …  
    2803928076                    # Shapping 2D slices
    2804028077                    reflon = np.zeros((1,Nslices), dtype=np.float)
    28041                     reflon[0,:] = slcvalsc
     28078                    reflon[0,:] = lcvalsc
    2804228079                    reflat = np.zeros((1,Nslices), dtype=np.float)
    2804328080                    xslice2D = np.zeros((4,1,Nslices), dtype=np.float)
    … …  
    2805228089                    yslice2D[3,0,:] = -1.
    2805328090   
    28054                     dd = len(onc.dimensions[dn])
     28091                    dd = len(onc.dimensions[gen.dictionary_key(slicebndsdim, dn)])
    2805528092                    getlon = np.zeros((1,dd), dtype=np.float)
    2805628093                    getlon[0,:] = dv
    … …  
    2807528112
    2807628113                    # Values for file
    28077                     dref = [dn]
     28114                    dref = [gen.dictionary_key(slicebndsdim, dn)]
    2807828115                    sref = [dxref]
    28079                     dget = [dn]
     28116                    dget = [gen.dictionary_key(slicebndsdim, dn)]
    2808028117                    sget = [dxget]
    2808128118       
    2808228119                elif len(dv.shape) == 2:
    2808328120                    print "  2D slicing  bounded variable: '" + varn + "': ", dv.shape
    28084                     xdim = rmdims[2]
    28085                     ydim = rmdims[1]
     28121                    if len(rmdims) == 3:
     28122                        xdim = rmdims[2]
     28123                        ydim = rmdims[1]
     28124                    else:
     28125                        rankv = len(ovar.dimensions)
     28126                        xdim = ovar.dimensions[rankv-1]
     28127                        ydim = ovar.dimensions[rankv-2]
    2808628128                    getdims = dimdbnds[xdim]
    2808728129
    2808828130                    # ref values
    28089                     if slicesinf.has_key(dimvars[getdims[2]]):
    28090                         varslcv = slicesinf[dimvars[getdims[2]]]
     28131                    if slicesinf.has_key(dimvars[xdim]):
     28132                        varslcv = slicesinf[dimvars[xdim]]
    2809128133                        dxref = varslcv[0]
    2809228134                        reflon1D = varslcv[3]
    … …  
    2809528137                        print infmsg
    2809628138                        print '  ' + fname + ": 2D slicing varibale '" + varn +      \
    28097                           "' with x-dimension '" +dimvars[getdims[2]]+ "' without "+ \
     28139                          "' with x-dimension '" + dimvars[xdim] + "' without " +    \
    2809828140                          "related slicing-variable !!"
    28099                         oxvar = onc.variables[dimvars[getdims[2]]]
     28141                        oxvar = onc.variables[dimvars[xdim]]
    2810028142
    2810128143                        # Removing undesired dimensions from bounds slicing variable
    … …  
    2811128153                        dxref = 1
    2811228154                        reflon1D = xvar
    28113                         refblon1D = np.array([xn, xx])
    28114                         print '    using variable extremes instead: ',reflon1D
    28115 
    28116                     if slicesinf.has_key(dimvars[getdims[1]]):
    28117                         varslcv = slicesinf[dimvars[getdims[1]]]
     28155                        refblon1D = np.zeros((1,4), dtype=np.float)
     28156                        refblon1D[0,0] = xn
     28157                        refblon1D[0,1] = xx
     28158                        refblon1D[0,2] = xx
     28159                        refblon1D[0,3] = xn
     28160                        print '    using variable extremes instead: ', xn, xx
     28161
     28162                    if slicesinf.has_key(dimvars[ydim]):
     28163                        varslcv = slicesinf[dimvars[ydim]]
    2811828164                        dyref = varslcv[0]
    2811928165                        reflat1D = varslcv[3]
    … …  
    2812228168                        print infmsg
    2812328169                        print '  ' + fname + ": 2D slicing varibale '" + varn +      \
    28124                           "' with y-dimension '" +dimvars[getdims[1]]+ "' without " +\
     28170                          "' with y-dimension '" + dimvars[ydim] + "' without " +    \
    2812528171                          "related slicing-variable !!"
    28126                         oyvar = onc.variables[dimvars[getdims[1]]]
     28172                        oyvar = onc.variables[dimvars[ydim]]
    2812728173
    2812828174                        # Removing undesired dimensions from bounds slicing variable
    … …  
    2813828184                        dyref = 1
    2813928185                        reflat1D = yvar
    28140                         refblat1D = np.array([yn, yx])
    28141                         print '    using variable extremes instead: ',reflat1D
     28186                        refblat1D = np.zeros((1,4), dtype=np.float)
     28187                        refblat1D[0,0] = yx
     28188                        refblat1D[0,1] = yx
     28189                        refblat1D[0,2] = yn
     28190                        refblat1D[0,3] = yn
     28191                        print '    using variable extremes instead: ', yn, yx
     28192
     28193                    # Wrong 3D reflon, reflat!!! lon, lat 1D on 2D var !!!
     28194 
    2814228195                    # Slicing following boundaries, dimensions are 1D thus expand to
    2814328196                    #    2D filling as NW, NE, SE, SW
    … …  
    2816228215
    2816328216                    # get values
    28164                     if dimvars.has_key(getdims[2]):
    28165                         ogetlon = onc.variables[dimvars[getdims[2]]]
     28217                    if dimvars.has_key(xdim):
     28218                        ogetlon = onc.variables[dimvars[xdim]]
    2816628219                        # Removing undesired dimensions from bounds slicing variable
    2816728220                        if sliceremovedim is not None:
    … …  
    2817428227                        print infmsg
    2817528228                        print '  ' + fname + ": 2D bounded varibale '" + varn +      \
    28176                           "' with x-dimension '" + getdims[2] + "' without related "+\
     28229                          "' with x-dimension '" + xdim + "' without related "+      \
    2817728230                          " dimension-variable !!"
    2817828231                        quit(-1)
    28179                     if dimvars.has_key(getdims[1]):
    28180                         ogetlat = onc.variables[dimvars[getdims[1]]]
     28232                    if dimvars.has_key(ydim):
     28233                        ogetlat = onc.variables[dimvars[ydim]]
    2818128234                        # Removing undesired dimensions from bounds slicing variable
    2818228235                        if sliceremovedim is not None:
    … …  
    2818928242                        print infmsg
    2819028243                        print '  ' + fname + ": 2D bounded varibale '" + varn +      \
    28191                           "' with y-dimension '" + getdims[1] + "' without related "+\
     28244                          "' with y-dimension '" + ydim + "' without related "+      \
    2819228245                          " dimension-variable !!"
    2819328246                        quit(-1)
    2819428247
    2819528248                    getshape = dimsbnds[xdim]
    28196                     dxget = getshape[2]
    28197                     dyget = getshape[1]
    28198                     dvget = getshape[0]
     28249                    if len(getshape) == 3:
     28250                        dxget = getshape[2]
     28251                        dyget = getshape[1]
     28252                        dvget = getshape[0]
     28253                    else:
     28254                        dxget = getshape[0]
     28255                        getshape = dimsbnds[ydim]
     28256                        dyget = getshape[0]
     28257                        dvget = 4
    2819928258                    xdimvarbnds2D = dimvbnds[xdim]
    2820028259                    ydimvarbnds2D = dimvbnds[ydim]
    2820128260
     28261                    # Reshaping to2D
     28262                    if len(getlon.shape) == 1 or len(getlat.shape) == 1:
     28263                        getlonold = getlon + 0.
     28264                        getlatold = getlat + 0.
     28265                        getlon, getlat = gen.lonlat2D(getlonold, getlatold)
     28266                        ddx = getlon.shape[1]
     28267                        ddy = getlon.shape[0]
     28268                        xdimvarbnds2Dold = xdimvarbnds2D + 0.
     28269                        ydimvarbnds2Dold = ydimvarbnds2D + 0.
     28270                        xdimvarbnds2D = np.zeros((4,ddy,ddx), dtype=np.float)
     28271                        ydimvarbnds2D = np.zeros((4,ddy,ddx), dtype=np.float)
     28272                        for j in range(ddy):
     28273                            xdimvarbnds2D[0,j,:] = xdimvarbnds2Dold[:,0]
     28274                            xdimvarbnds2D[1,j,:] = xdimvarbnds2Dold[:,1]
     28275                            xdimvarbnds2D[2,j,:] = xdimvarbnds2Dold[:,1]
     28276                            xdimvarbnds2D[3,j,:] = xdimvarbnds2Dold[:,0]
     28277                        for i in range(ddx):
     28278                            ydimvarbnds2D[0,:,i] = ydimvarbnds2Dold[:,1]
     28279                            ydimvarbnds2D[1,:,i] = ydimvarbnds2Dold[:,1]
     28280                            ydimvarbnds2D[2,:,i] = ydimvarbnds2Dold[:,0]
     28281                            ydimvarbnds2D[3,:,i] = ydimvarbnds2Dold[:,0]
     28282
    2820228283                    # Values for file
    28203                     dref = [dimvars[getdims[1]], dimvars[getdims[2]]]
     28284                    dref = [dimvars[ydim], dimvars[xdim]]
    2820428285                    sref = [dyref, dxref]
    28205                     dget = [getdims[1], getdims[2]]
     28286                    dget = [ydim, xdim]
    2820628287                    sget = [dyget, dxget]
    2820728288
    … …  
    2822328304                getvarybndst = ydimvarbnds2D.transpose()
    2822428305
     28306                print 'Lluis dxref, dyref, dvref:', dxref, dyref, dvref, 'shapes: reflon', reflon.shape, 'reflat:', reflat.shape, \
     28307                  'refvarxbnds:', xslice2D.shape, 'refvarybnds:', yslice2D.shape
     28308                print 'Lluis dxget, dyget, dvget:', dxget, dyget, dvget, 'shapes: getlon', getlon.shape, 'getlat:', getlat.shape, \
     28309                  'getvarxbnds:', xdimvarbnds2D.shape, 'getvarybnds:', ydimvarbnds2D.shape
     28310
    2822528311                Ngridsint, gridsint, areast, percenst =                              \
    2822628312                  fsci.module_scientific.grid_spacepercen(xcavals=reflont,           \
    … …  
    2824528331
    2824628332                Ngridsinmax = np.max(Ngridsin)
     28333                print 'Lluis shapes: Ngridsin', Ngridsin.shape, 'gridsin:', gridsin.shape, \
     28334                  'areas:', areas.shape, 'percens:', percens.shape
    2824728335        else:
    2824828336            dn = varn + ''
    … …  
    2843528523            anewvar[:] = areas[:]
    2843628524
    28437             aanewvar = onewnc.createVariable(dn+'area','f',tuple(Srgrid),             \
     28525            aanewvar = onewnc.createVariable(dn+'area','f',tuple(Srgrid),            \
    2843828526              fill_value=gen.fillValueF)
    2843928527            basicvardef(aanewvar ,dn+'area', "area of the slice", vu)
    … …  
    2844728535            onewnc.sync()
    2844828536
     28537            print 'Lluis dv shape:', dv.shape, 'Ngridsin:', Ngridsin.shape,          \
     28538              'gridsin:', gridsin.shape
    2844928539            if len(dv.shape) == 1:
    28450                 for j in range(1):
    28451                    for i in range(Nslices):
    28452                         innewvar[:,0:Ngridsin[j,i],i] =                              \
    28453                           gridsin[:,0:Ngridsin[j,i],j,i]
    28454                         pnewvar[0:Ngridsin[j,i],i]= percens[0:Ngridsin[j,i],j,i]
    28455                         slicearea = 0.
    28456                         for iv in range(Ngridsin[j,i]):
    28457                             ix = gridsin[1,iv,i]
    28458                             iy = gridsin[0,iv,i]
    28459                             slicearea = slicearea + areas[iy,ix]*percens[iv,j,i]
    28460                         aanewvar[i]= slicearea
     28540                j = 0
     28541                for i in range(Nslices):
     28542                    innewvar[:,0:Ngridsin[j,i],i] = gridsin[:,0:Ngridsin[j,i],j,i]
     28543                    pnewvar[0:Ngridsin[j,i],i]= percens[0:Ngridsin[j,i],j,i]
     28544                    slicearea = 0.
     28545                    for iv in range(Ngridsin[j,i]):
     28546                        ix = gridsin[1,iv,j,i]
     28547                        iy = gridsin[0,iv,j,i]
     28548                        slicearea = slicearea + areas[iy,ix]*percens[iv,j,i]
     28549                    aanewvar[i]= slicearea
    2846128550            elif len(dv.shape) == 2:
    2846228551                for j in range(dyref):
Note: See TracChangeset for help on using the changeset viewer.