Changeset 1096 in lmdz_wrf for trunk

Timestamp:

Sep 11, 2016, 8:23:07 PM (9 years ago)

Author:

lfita

Message:

Adding:

• `index_flatten_mat': Function to provide the matrix coordinates of an index from its flatten version
• `oper_submatrix': Function to perform an operation of a given matrix along a sub-set of values along its dimensions
• `same_shape': Function to check if two matrices have the same shape

File:

• trunk/tools/generic_tools.py (modified) (3 diffs)

trunk/tools/generic_tools.py

@@ -47 +47 @@
 # ijlonlat: Function to provide the imin,jmin imax,jmax of a lon,lat box
 # incomming_flow: Function to determine if a fgrid-flow inflows to the central grid point
+# index_flatten_mat: Function to provide the matrix coordinates of an index from its flatten version
 # index_mat_way: Function to look for a value within a matrix following a direction
 # index_mat: Function to provide the coordinates of a given value inside a matrix
@@ -56 +57 @@
 # num_chainSnum: Function to pass a value to a `ChainStrNum' number
 # num_split: Function to split a string at each numeric value keeping the number as the last character of each cut
+# oper_submatrix: Function to perform an operation of a given matrix along a sub-set of values along its dimensions
 # printing_dictionary: Function to print the content of a dictionary
 # PolyArea: Function to compute the area of the polygon following 'Shoelace formula'
 # radius_angle: Function to generate a matrix with the angle at a given point
 # radius_dist: Function to generate a matrix with the distance at a given point
+# same_shape: Function to check if two matrices have the same shape
 # search_sec_list: Function to provide the values and indices on a list which matches a section of a string
 # significant_decomposition: Function to decompose a given number by its signifcant potencies
@@ -8599 +8602 @@
     return tB
 
+def same_shape(mat1,mat2):
+    """ Function to check if two matrices have the same shape
+      mat1,2= matrices to check
+    """
+    fname = 'same_shape'
+
+    shape1 = mat1.shape
+    shape2 = mat2.shape
+
+    Ndims1 = len(shape1)
+    Ndims2 = len(shape2)
+
+    if Ndims1 != Ndims2:
+        print errormsg
+        print '  ' + fname + ': mat1 and mat2 have different number of dimensions !!'
+        print '    Ndims mat 1:', Ndims1,' Ndims mat2:', Ndims2
+        quit(-1)
+
+    for idn in range(Ndims1):
+        if shape1[idn] != shape2[idn]:
+            print errormsg
+            print '  ' +fname+ ': length of',idn,'diemsion in mat1 and mat2 differ !!'
+            print '    Length mat 1:', shape1[idn],' Length mat2:', shape2[idn]
+            quit(-1)
+
+    return 
+
+def index_flatten_mat(index,Ldims):
+    """ Function to provide the matrix coordinates of an index from its flatten version
+      index= index of the matrix's flatten version
+      Ldims= lengths of the dimensions of the matrix
+    >>> index_flatten_mat(17,[3,3,3])
+    [1 2 2]
+    """
+    fname = 'index_flatten_mat'
+    Ndims = len(Ldims)
+
+    if index < Ldims[Ndims-1]:
+        indices = np.zeros((len(Ldims)), dtype=int)
+        indices[Ndims-1] = index
+    else:
+        for idn in range(1,Ndims):
+            indices = np.zeros((len(Ldims)), dtype=int)
+            subsize = int(np.prod(Ldims[Ndims-idn-1:Ndims]))
+            # Reaching depth level in the matrix
+            if subsize > idn:
+                # Getting index for each dimension from the depth
+                prevsubsizeind = index
+                for idnd in range(Ndims-idn, Ndims):
+                    prevsubsize = int(np.prod(Ldims[idnd:Ndims]))
+                    Nprevsubsize = int(prevsubsizeind/prevsubsize)
+                    indices[idnd-1] = Nprevsubsize
+                    prevsubsizeind = prevsubsizeind - Nprevsubsize*prevsubsize
+                # Final index
+                indices[Ndims-1] = prevsubsizeind
+                
+    return indices
+
+def oper_submatrix(mat,dimns,submatval,oper,opdims):
+    """ Function to perform an operation of a given matrix along a sub-set of values along its dimensions
+      mat= matrix with values
+      dimns= names of the matrix dimensions
+      submatval= matrix value to use with some dimensions reduced
+      oper= operation to perform
+        'sumc', add [val]
+        'subc', substraction [val]
+        'mulc', multiply by [val] 
+        'divc', divide by [val] 
+        'lowthres',[val]: modify all values below [val] to submatval
+        'upthres',[val]: modify all values above [val] to submatval
+      opdims= dimensions of the operation
+      >>> mat = np.arange(12).reshape(3,2,2)
+      >>> dimsn = ['time', 'lon', 'lat']
+      >>> oper_submatrix(mat, dimsn, np.matrix([[1., 1.],[2., 2.]]), 'sumc', ['time'])
+      [[[ 1  2]
+       [ 4  5]]
+
+       [[ 5  6]
+        [ 8  9]]
+
+       [[ 9 10]
+        [12 13]]
+    """
+    fname = 'dimoper_matrix'
+
+    operations = ['sumc', 'subc', 'mulc', 'divc', 'lowthres', 'upthres']
+    matype = mat.dtype
+
+    if oper.find(',') != -1:
+        opern = oper.split(',')[0]
+        val = retype(oper.split(',')[1], matype)
+    else:
+        opern = oper
+
+    Ndims = len(dimns)
+    # Getting the slice, on '-1', dimension to operate along
+    # Keeping in 'ldimuse': length of the dimensions of the values to use
+    # Keeping in 'ldimop': length of the dimension to operate along
+    idim = 0
+    ldimuse = []
+    ldimop = []
+    slicevals = []
+    for dimn in dimns:
+        for dn in opdims:
+            if dimn == dn:
+                slicevals.append(-1)
+                ldimop.append(mat.shape[idim])
+            else:
+                slicevals.append(mat.shape[idim])
+                ldimuse.append(mat.shape[idim])
+        idim = idim + 1
+
+    Ndop = len(opdims)
+    Ntotdims = np.prod(ldimop)
+
+    # Checking for coincidence in shapes
+    try:
+        with Capturing() as output:
+            same_shape(submatval,np.zeros(ldimuse))
+    except:
+        print errormsg
+        print '  ' + fname + ': shape of matrix to use and shape of values to ' +    \
+          'operate differ!!'
+        for sout in output: print sout
+        quit(-1)
+
+    # Operation
+    newmat = np.zeros(tuple(mat.shape), dtype=mat.dtype)
+    for ijk in range(Ntotdims):
+        ijkop = -1
+        opslice = []
+        idcalc = index_flatten_mat(ijk,ldimop)
+        for idn in range(Ndims):
+            if slicevals[idn] == -1:
+                ijkop = ijkop + 1
+                opslice.append(idcalc[ijkop])
+            else:
+                opslice.append(slice(0,slicevals[idn]))
+
+        if opern == 'sumc':
+            newmat[tuple(opslice)] = mat[tuple(opslice)] + submatval
+        elif opern == 'subc':
+            newmat[tuple(opslice)] = mat[tuple(opslice)] - submatval
+        elif opern == 'mulc':
+            newmat[tuple(opslice)] = mat[tuple(opslice)] * submatval
+        elif opern == 'divc':
+            newmat[tuple(opslice)] = mat[tuple(opslice)] / submatval
+        elif opern == 'lowthres':
+            newmat[tuple(opslice)] = np.where(mat[tuple(opslice)] < val, submatval,  \
+              mat[tuple(opslice)])
+        elif opern == 'upthres':
+            newmat[tuple(opslice)] = np.where(mat[tuple(opslice)] > val, submatval,  \
+              mat[tuple(opslice)])
+        else:
+            print errormsg
+            print '  ' + fname + ": operation '" + opern + "' not ready !!"
+            print '    ready operations:', operations
+            quit(-1)
+
+    return newmat
+
 #quit()