Changeset 2371 in lmdz_wrf

Timestamp:

Feb 26, 2019, 8:51:00 PM (6 years ago)

Author:

lfita

Message:

Adding:

• `range_slicing': Function to provide a list of slices for a series of dimensions giving intervals for a sub-set of the dimensions in order to avoid memory problems

File:

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

trunk/tools/generic_tools.py

@@ -175 +175 @@
 # 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
+# range_slicing: Function to provide a list of slices for a series of dimensions giving
+#   intervals for a sub-set of the dimensions in order to avoid memory problems
 # rectangular_spiral: Function to provide a rectangular spiral (along x,y-axis values) of values
 # remove_monotones: Function to remove the monotones (len(dim) = 1) from an array
@@ -15227 +15229 @@
 
 def range_slicing(dimns, dimvs, intdims):
-    """ Function to provide a list of slices for a series of dimensions giving       
-          intervals for a series of dimensions in order to avoid memory problems
+    """ Function to provide a list of slices for a series of dimensions giving
+          intervals for a sub-set of the dimensions in order to avoid memory problems
+          * returns: list of slices, array with the start and end for each dimension 
+           and slice
         dimns: list with the names of dimensions
         dimvs: list with the lengths of dimensions (same order)
         intdims: dictionary with the name of dimensions with the length of intervals
     >>> range_slicing(['z', 't', 'y', 'x'], [2, 3, 10, 20], {'x': 5, 'y': 7})
+    [[slice(0, 2, None), slice(0, 3, None), slice(0, 7, None), slice(0, 5, None)], 
+     [slice(0, 2, None), slice(0, 3, None), slice(0, 7, None), slice(5, 10, None)], 
+     [slice(0, 2, None), slice(0, 3, None), slice(0, 7, None), slice(10, 15, None)], 
+     [slice(0, 2, None), slice(0, 3, None), slice(7, 10, None), slice(0, 5, None)], 
+     [slice(0, 2, None), slice(0, 3, None), slice(7, 10, None), slice(5, 10, None)], 
+     [slice(0, 2, None), slice(0, 3, None), slice(7, 10, None), slice(10, 15, None)]], 
+    array([[[ 0,  2],
+            [ 0,  3],
+            [ 0,  7],
+            [ 0,  5]],
+
+           [[ 0,  2],
+            [ 0,  3],
+            [ 0,  7],
+            [ 5, 10]],
+    
+           [[ 0,  2],
+            [ 0,  3],
+            [ 0,  7],
+            [10, 15]],
+
+           [[ 0,  2],
+            [ 0,  3],
+            [ 7, 10],
+            [ 0,  5]],
+
+           [[ 0,  2],
+            [ 0,  3],
+            [ 7, 10],
+            [ 5, 10]],
+
+           [[ 0,  2],
+            [ 0,  3],
+            [ 7, 10],
+            [10, 15]]])
     """
     fname = 'range_slicing'
@@ -15256 +15295 @@
         islcdim[dimn] = 0
         doneallslices[dimn] = False
-        print 'intervals ', dimn, ':', intslices[dimn]
-
-    origslicesize = {}
-    Tslicesize = 1
+        #print 'intervals ', dimn, ':', intslices[dimn]
+
+    # Constructing the list for the length for each interval dimension
+    intloopvals = []
+    # indices of the interval dimensions
+    iintd = {}
+    iid = 0
     for dimn in dimns:
-        idim = index_vec(dimns, dimn)
-        origslicesize[dimn] = dims[dimn]
-        if searchInlist(intdims.keys(), dimn):
-            Tslicesize = Tslicesize*Lslcdim[dimn]
-            lastintdimn = dimn
-
-    print '  ' + fname + ': Total number of slices to provide:', Tslicesize
+        if intdims.has_key(dimn): 
+            intloopvals.append(Lslcdim[dimn])
+            iintd[dimn] = iid
+            iid = iid + 1
+
+    # Getting all the combinations of the interval slices
+    intcombs = Nloops_1D(intloopvals)
+    Tslicesize = intcombs.shape[0]
+
+    #print '  ' + fname + ': Total number of slices to provide:', Tslicesize
 
     slices = []
+    inddims = np.zeros((Tslicesize,Ndims,2), dtype=int)
     for il in range(Tslicesize):
-        advanced = False
-        print 'il:', il
+        # indices of the looping dimensions
+        loopv = intcombs[il]
         islice = []
         for idim in range(Ndims):
             dimn = dimns[idim]
             if intdims.has_key(dimn):
-                # getting dimension slice status
-                Lslc = Lslcdim[dimn]
-                slcsd = intslices[dimn]
-                dimdone = doneallslices[dimn]
-                islc = islcdim[dimn]            
-                
-                # Which is the status of later dimensions
-                if idim < Ndims-1:
-                    allintdns = True
-                    for iid in range(idim+1,Ndims):
-                        if intdims.has_key(dimns[iid]):
-                            # Up to the dimension without all the intervals done
-                            if not doneallslices[dimns[iid]]:
-                                allintdns = False
-                                break
-                else:
-                    allintdns = False
-
-                if allintdns:
-                    if not advanced:
-                        if islc+1 <= Lslc-1:
-                            print 'Advancing dim !!', dimn, islc, islc+1, '.', Lslc, slcsd
-                            islc = islc + 1
-                            advanced = True
-                        else:
-                            doneallslices[dimn] = True
-                    # Zeroeing later dims
-                    for iid in range(idim+1,Ndims):
-                        if intdims.has_key(dimns[iid]):
-                            islcdim[dimns[iid]] = 0
-                            doneallslices[dimns[iid]] = False
-                islice.append(slice(slcsd[islc], slcsd[islc+1]))
-                islcdim[dimn] = islc
+                dslcv = intslices[dimn]
+                iid = iintd[dimn]
+                intdslcv = loopv[iid]
+                islice.append(slice(dslcv[intdslcv],dslcv[intdslcv+1]))
+                inddims[il,idim,0]=dslcv[intdslcv]
+                inddims[il,idim,1]=dslcv[intdslcv+1]
             else:
-                islice.append(slice(0,origslicesize[dimn]))
-
-        print il, ':', islcdim, doneallslices
+                islice.append(slice(0,dims[dimn]))
+                inddims[il,idim,0]=0
+                inddims[il,idim,1]=dims[dimn]
 
         slices.append(islice)
-        if not advanced: 
-            islc = islcdim[lastintdimn] 
-            islc = islc + 1
-            islcdim[lastintdimn] = islc
-            if islc > Lslc-1:
-                doneallslices[lastintdimn] = islc
-
-    return slices
-
-slcs = range_slicing(['z', 't', 'y', 'x'], [2, 3, 10, 20], {'x': 5, 'y': 7})
-Nslcs = len(slcs)
-for i in range(Nslcs):
-    print i, ':', slcs[i]
+
+    return slices, inddims
+
+#slcs, inds = range_slicing(['z', 't', 'y', 'x'], [2, 3, 10, 20], {'x': 5, 'y': 7})
+#Nslcs = len(slcs)
+#for i in range(Nslcs):
+#    print i, ':', slcs[i]
+#    for j in range(4):
+#        print '  ' , '(', inds[i,j,0], ',', inds[i,j,1], ')'
+#print range_slicing(['z', 't', 'y', 'x'], [2, 3, 10, 20], {'x': 5, 'y': 7})
 
 #quit()