Changeset 1383 in lmdz_wrf for trunk/tools

Timestamp:

Dec 14, 2016, 10:18:31 AM (8 years ago)

Author:

lfita

Message:

Adding:

`linearint_weights': Function to provide the weights for a linear interpolation of a value between a couple of values as a weighted distance mean
`linearint_3x3weights': Function to provide the weights for a linear interpolation of a value inside a 3x3 matrix of values as a weighted distance mean

File:

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

trunk/tools/generic_tools.py

@@ -71 +71 @@
 # latex_fig_array: Function to add an array of figures to an existing tex file
 # latex_text: Function to transform a text to LaTeX following style rules
+# linearint_weights: Function to provide the weights for a linear interpolation of a value between a couple of values as a weighted distance mean
+# linearint_3x3weights: Function to provide the weights for a linear interpolation of a value inside a 3x3 matrix of values as a weighted distance mean
 # list_combos: Function to construct a new list with all possible N-combinations of the list-values
 # list_coincidences: Function to provide the coincidences between two lists
@@ -10787 +10789 @@
    else:
       raise ValueError, 'input is not a valid roman numeral: %s' % input
+
+def linearint_weights(vals, intval):
+    """ Function to provide the weights for a linear interpolation of a value between a couple of values as a weighted distance mean
+      vals: couple of values
+      intval: value to interpolate between [vals]
+    >>> linearint_weights([1., 2.], 1.5)
+    [0.5  0.5]
+    >>> linearint_weights([-2., -1.], -1.0005)
+    [  5.00000000e-04   9.99500000e-01]
+    """
+    fname = 'linear_wegiths'
+
+    if vals[0] > vals[1]: 
+        sign = 'neg'
+    else:
+        sign = 'pos'
+
+    if sign == 'neg' and not (intval <= vals[0] and intval >= vals[1]):
+        print errormsg
+        print '  ' + fname + ': wrong value:', intval , ' to interpolate for:',      \
+          vals, ' range'
+        quit(-1)
+
+    if sign == 'pos' and not (intval >= vals[0] and intval <= vals[1]):
+        print intval >= vals[0]
+        print intval <= vals[1]
+        print errormsg
+        print '  ' + fname + ': wrong value:', intval , ' to interpolate for:',      \
+          vals, ' range'
+        quit(-1)
+
+    inc = np.abs(vals[0] - vals[1])
+    linearwgt = [np.abs(intval - vals[0]), np.abs(intval - vals[1])]
+    linearwgt = 1. - linearwgt / inc
+
+    return linearwgt
+
+def linearint_3x3weights(xvals, yvals, intval):
+    """ Function to provide the weights for a linear interpolation of a value inside a 3x3 matrix of values as a weighted distance mean
+      xvals: 3x3 matrix of x-values
+      yvals: 3x3 matrix of y-values
+      intval: value to interpolate between [yintval, xintval]
+      It returns: 
+        * 3x3 matrix with weights (zero if are above the 4th shortest distacce, masked values for outside dx,dy positions) 
+        * Number of closest grid points (<=4)
+        * 2x9 matrix with distance-sorted positions within the 3x3 matrix
+    xvals = np.zeros(9).reshape(3,3)
+    xvals[:,0] = 1.
+    xvals[:,1] = 2.
+    xvals[:,2] = 3.
+    xvals[2,2] = None
+    yvals = xvals.transpose()
+    >>> linearint_3x3weights(xvals, yvals, [1.5, 2.5])
+    (masked_array(data =
+     [[0.0 0.25 0.25]
+     [0.0 0.25 0.25]
+     [0.0 0.0 --]],
+                 mask =
+     [[False False False]
+     [False False False]
+     [False False  True]],
+           fill_value = 1e+20)
+    , 4, array([[ 0,  0,  1,  1,  0,  1,  2,  2, -1],
+           [ 1,  2,  1,  2,  0,  0,  1,  0, -1]]))
+    """
+    fname = 'linear_wegiths'
+
+    # Assuming that values come from `vals_around' function (None, when outside matrix size)
+    xvalsma = ma.masked_equal(xvals,None)
+    yvalsma = ma.masked_equal(yvals,None)
+
+    # Check data
+    nx = np.min(xvals)
+    xx = np.max(xvals)
+    ny = np.min(yvals)
+    xy = np.max(yvals)
+
+    if not intval[1] >= nx and intval[1] <= xx:
+        print errormsg
+        print '  ' + fname + ': wrong value:', intval[1] , ' to interpolate for range:'
+        for i in range(3):
+            print '    ', xvals[:,i]
+        quit(-1)
+    if not intval[0] >= ny and intval[0] <= xy:
+        print errormsg
+        print '  ' + fname + ': wrong value:', intval[0] , ' to interpolate for range:'
+        for i in range(3):
+            print '    ', yvals[:,i]
+        quit(-1)
+
+    dist = np.sqrt( (xvalsma-intval[1])**2 + (yvalsma-intval[0])**2)
+    inc = np.sum(dist)
+    print 'inc:', inc, 'intval', intval
+    for i in range(3):
+        print dist[:,i]
+
+    ijvals = dist.copy()
+    distpos = np.ones((2,9), dtype=int)*(-1)
+
+    # shortest minium distance
+    sortdist = list(dist.flatten())
+    sortdist.sort()
+    iijj = 0    
+    if sortdist[0] == 0.:
+        ij = index_mat(ijvals,0.)
+        distpos[:,iijj] = ij[:]
+        wgt = np.zeros((3,3), dtype=np.float)
+        wgt[ij[0], ij[1]] = 1.
+        return wgt, 1, distpos
+
+    # Getting ij values of distances, removing he already localized values
+    iijj = 0
+    for ijdist in sortdist:
+        if ijdist is not ma.masked:
+            ij = index_mat(ijvals,ijdist)
+            distpos[:,iijj] = ij[:]
+            ijvals[ij[0],ij[1]] = fillValueF
+            iijj = iijj + 1
+
+    # Normalizing values (onlyl the first 4)
+    if iijj >= 3:
+        inc = np.sum(sortdist[0:4])
+        maxdist = sortdist[3]
+        Nvals = 4
+    else:
+        inc = np.sum(sortdist[0:iijj])
+        maxdist = sortdist[iijj]
+        Nvals = iijj
+
+    wgt = np.where(dist <= maxdist, dist / inc, 0.)
+
+    return wgt, Nvals, distpos
+
+def curvelocalize_2D(curve,xvals,yvals):
+    """ Function to provide the localization a curve in a 2D field of positions via the equivalent i,j-quads 
+      within which the curve lays (-1, no value for the given quad [2x2 points around]) and provide the weights
+      of the quad to perform a distance-weighted mean at the given curve point
+             x,y_j,i       x,y_j,i+1
+
+                curve(t)
+
+                           curve(t+1)
+
+             x,y_j-1,i     x,y_j-1,i+1
+
+      curve= [2, Npts] matrix of values of the curve
+        yval0, xval0
+        yval1, xval1
+        (...)
+        yvalNpts, xvalNpts
+      xvals= 2D matrix of x-coordinate values
+      yvals= 2D matrix of y-coordinate values
+      RETURNS: 
+        curvloc = [2,Npts] matrix with the closest i,j grid point in the 2D space of the field positions
+        curvweights = [3,3,Npts] 3x3 matrix weights around the curve position
+    """
+    fname = 'curvelocalize_2D'
+
+    Npts = curve.shape[1]
+
+    curvloc = np.ones((curve.shape), dtype=int)*(-1)
+    Nquad = np.ones((Npts), dtype=int)*(-1)
+    curvweights = np.zeros((3,3,Npts), dtype=float)
+
+    for icv in range(Npts):
+        # Closest grid-point
+        dist = np.sqrt((xvals - curve[1,icv])**2 + (yvals - curve[0,icv])**2)
+        mindist = np.min(dist)
+        ijloc = index_mat(dist,mindist)
+        iloc[icv] = ijloc[1]
+        jloc[icv] = ijloc[0]
+
+        # Values around the nearest 2D-point to the curve point
+        xaroundvls = vals_around(xvals,ijloc)
+        yaroundvls = vals_around(yvals,ijloc)
+
+        curveweights[, Npts, ijaorund3x3 = linearint_3x3weights(xvals, yvals, intval)
+        
+ 
+    return
+
+
+#quit()