Changeset 2370 in lmdz_wrf for trunk

Timestamp:

Feb 26, 2019, 8:27:25 PM (6 years ago)

Author:

lfita

Message:

Adding:

• `Nloops_1D': Function to compress a series of multiples loops into a single vector

File:

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

trunk/tools/generic_tools.py

@@ -154 +154 @@
 # multi_index_string: Function to provide the indeces of every repetition of a group of characters within a string
 # multi_index_vec: Function to provide the coordinates of multiples repetitions of a value inside a vector
+# Nloops_1D: Function to compress a series of multiples loops into a single vector
 # Nomasked: Function to bring back a given array wthout the masked values reducing a given dimension
 # Nstr: Function to transform a number to string, but making sure it preserves 
@@ -15169 +15170 @@
     return iszero
 
+def Nloops_1D(loops):
+    """ Function to compress a series of multiples loops into a single vector
+      loops: list with the length of the N-loops
+    >>> Nloops_1D([3,5,2])
+    [[0 0 0]
+     [0 0 1]
+     [0 1 0]
+     [0 1 1]
+     [0 2 0]
+     [0 2 1]
+     [0 3 0]
+     [0 3 1]
+     [0 4 0]
+     [0 4 1]
+     [1 0 0]
+     [1 0 1]
+     [1 1 0]
+     [1 1 1]
+     [1 2 0]
+     [1 2 1]
+     [1 3 0]
+     [1 3 1]
+     [1 4 0]
+     [1 4 1]
+     [2 0 0]
+     [2 0 1]
+     [2 1 0]
+     [2 1 1]
+     [2 2 0]
+     [2 2 1]
+     [2 3 0]
+     [2 3 1]
+     [2 4 0]
+     [2 4 1]]
+    """
+    fname = 'Nloops_1D'
+
+    Nloops = len(loops)
+    Tloops = np.prod(np.array(loops))
+    loops1D = np.zeros((Tloops, Nloops), dtype=int)
+    prevl = np.zeros((Nloops), dtype=int)
+    loops1D[0,...] = prevl[:]
+    for il in range(1,Tloops):
+        prevl[Nloops-1] = prevl[Nloops-1] + 1
+        if prevl[Nloops-1] > loops[Nloops-1]-1:
+            prevl[Nloops-1] = 0
+            for ii in range(Nloops-2,-1,-1):
+                prevl[ii] = prevl[ii] + 1
+                if prevl[ii] <= loops[ii]-1:
+                    break
+                else:
+                    prevl[ii] = 0
+        loops1D[il,...] = prevl[:]
+
+    return loops1D
+
+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
+        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})
+    """
+    fname = 'range_slicing'
+
+    Ndims = len(dimns)
+
+    # Constructing dictionary with dimn and dimvs (ensuring same order !)
+    dims = {}
+    for iid in range(Ndims):
+        dims[dimns[iid]] = dimvs[iid]
+
+    # Getting individual intervals
+    intslices = {}
+    Lslcdim = {}
+    islcdim = {}
+    doneallslices = {}
+    for dimn in intdims.keys():
+        slicev = range(0,dims[dimn],intdims[dimn])
+        if np.mod(dims[dimn],intdims[dimn]) != 0: slicev.append(dims[dimn])
+
+        intslices[dimn] = slicev
+        Lslcdim[dimn] = len(slicev)-1
+        islcdim[dimn] = 0
+        doneallslices[dimn] = False
+        print 'intervals ', dimn, ':', intslices[dimn]
+
+    origslicesize = {}
+    Tslicesize = 1
+    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
+
+    slices = []
+    for il in range(Tslicesize):
+        advanced = False
+        print 'il:', 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
+            else:
+                islice.append(slice(0,origslicesize[dimn]))
+
+        print il, ':', islcdim, doneallslices
+
+        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]
+
 #quit()