feectools 0.1.0__py3-none-any.whl

feectools/ddm/tests/test_cart_3d.py

@@ -0,0 +1,158 @@
+# File test_cart_3d.py
+
+from feectools.ddm.blocking_data_exchanger    import BlockingCartDataExchanger
+from feectools.ddm.nonblocking_data_exchanger import NonBlockingCartDataExchanger
+
+#===============================================================================
+# TEST CartDecomposition and CartDataExchanger in 3D
+#===============================================================================
+def run_cart_3d( data_exchanger_type, verbose=False ):
+
+    import numpy as np
+    from feectools.ddm.mpi import mpi as MPI 
+    from feectools.ddm.cart import DomainDecomposition, CartDecomposition
+
+    #---------------------------------------------------------------------------
+    # INPUT PARAMETERS
+    #---------------------------------------------------------------------------
+
+
+    # Number of cells
+    nc1 = 135
+    nc2 = 77
+    nc3 =  98
+
+    # Padding ('thickness' of ghost region)
+    p1 = 3
+    p2 = 2
+    p3 = 5
+
+    # Periodicity
+    period1 = True
+    period2 = False
+    period3 = True
+
+    # Number of Points
+    n1 = nc1 + p1*(1-period1)
+    n2 = nc2 + p2*(1-period2)
+    n3 = nc3 + p3*(1-period3)
+    #---------------------------------------------------------------------------
+    # DOMAIN DECOMPOSITION
+    #---------------------------------------------------------------------------
+
+    # Parallel info
+    comm = MPI.COMM_WORLD
+    size = comm.Get_size()
+    rank = comm.Get_rank()
+
+    domain_decomposition = DomainDecomposition(ncells=[nc1,nc2,nc3], periods=[period1,period2,period3], comm=comm)
+    
+    npts          = [n1,n2,n3]
+    global_starts = [None]*3
+    global_ends   = [None]*3
+    for axis in range(3):
+        es = domain_decomposition.global_element_starts[axis]
+        ee = domain_decomposition.global_element_ends  [axis]
+
+        global_ends  [axis]     = (ee+1)-1
+        global_ends  [axis][-1] = npts[axis]-1
+        global_starts[axis]     = np.array([0] + (global_ends[axis][:-1]+1).tolist())
+
+    # Decomposition of Cartesian domain
+    cart = CartDecomposition(
+            domain_decomposition      = domain_decomposition,
+            npts          = [n1,n2,n3],
+            global_starts = global_starts,
+            global_ends   = global_ends,
+            pads          = [p1,p2,p3],
+            shifts        = [1,1,1],
+    )
+
+    # Local 3D array with 3D vector data (extended domain)
+    shape = list( cart.shape ) + [3]
+    u = np.zeros( shape, dtype=int )
+
+    # Global indices of first and last elements of array
+    s1,s2,s3 = cart.starts
+    e1,e2,e3 = cart.ends
+
+    # Create object in charge of exchanging data between subdomains
+    synchronizer = data_exchanger_type( cart, u.dtype, coeff_shape=[3] )
+
+    # Print some info
+    if rank == 0:
+        print( "" )
+
+    for k in range(size):
+        if k == rank:
+            print( "Proc. # {}".format( rank ) )
+            print( "---------" )
+            print( ". s1:e1 = {:2d}:{:2d}".format( s1,e1 ) )
+            print( ". s2:e2 = {:2d}:{:2d}".format( s2,e2 ) )
+            print( ". s3:e3 = {:2d}:{:2d}".format( s3,e3 ) )
+            print( "", flush=True )
+        comm.Barrier()
+
+    #---------------------------------------------------------------------------
+    # TEST
+    #---------------------------------------------------------------------------
+
+    # Fill in true domain with u[i1_loc,i2_loc,i3_loc,:]=[i1_glob,i2_glob,i3_glob]
+    u[p1:-p1,p2:-p2,p3:-p3,:] = [[[(i1,i2,i3) for i3 in range(s3,e3+1)] \
+                                              for i2 in range(s2,e2+1)] \
+                                              for i1 in range(s1,e1+1)]
+
+    request = synchronizer.prepare_communications(u)
+    # Update ghost regions
+    synchronizer.start_update_ghost_regions( u, request )
+    synchronizer.end_update_ghost_regions( u, request )
+
+    #---------------------------------------------------------------------------
+    # CHECK RESULTS
+    #---------------------------------------------------------------------------
+
+    # Verify that ghost cells contain correct data (note periodic domain!)
+    val = lambda i1,i2,i3: (i1%n1,i2,i3%n3) if 0<=i2<n2 else (0,0,0)
+
+    uex = [[[val(i1,i2,i3) for i3 in range(s3-p3,e3+p3+1)] \
+                           for i2 in range(s2-p2,e2+p2+1)] \
+                           for i1 in range(s1-p1,e1+p1+1)]
+
+    success = (u == uex).all()
+
+    # MASTER only: collect information from all processes
+    success_global = comm.reduce( success, op=MPI.LAND, root=0 )
+
+    return locals()
+
+#===============================================================================
+# RUN TEST WITH PYTEST
+#===============================================================================
+import pytest
+
+@pytest.mark.parametrize( 'data_exchanger_type', [BlockingCartDataExchanger, NonBlockingCartDataExchanger] )
+@pytest.mark.parallel
+def test_cart_3d(data_exchanger_type):
+
+    namespace = run_cart_3d(data_exchanger_type)
+
+    assert namespace['success']
+
+#===============================================================================
+# RUN TEST MANUALLY
+#===============================================================================
+if __name__=='__main__':
+
+    locals().update( run_cart_3d( BlockingCartDataExchanger, verbose=True ) )
+
+    # Print error messages (if any) in orderly fashion
+    for k in range(size):
+        if k == rank and not success:
+            print( "Rank {}: wrong ghost cell data!".format( rank ), flush=True )
+        comm.Barrier()
+
+    if rank == 0:
+        if success_global:
+            print( "PASSED", end='\n\n', flush=True )
+        else:
+            print( "FAILED", end='\n\n', flush=True )

feectools/ddm/tests/test_multicart_2d.py

@@ -0,0 +1,173 @@
+# File test_multicart_2d.py
+
+#===============================================================================
+# TEST MultiCartDecomposition in 2D
+#===============================================================================
+
+#------------------------------------------------------------------------------
+def get_minus_starts_ends(plus_starts, plus_ends, minus_npts, plus_npts, minus_axis, plus_axis,
+                          minus_ext, plus_ext, minus_pads, plus_pads, minus_shifts, plus_shifts,
+                          diff):
+    """
+    Compute the coefficients needed by the minus patch in a given interface.
+    """
+    starts = [max(0,s-m*p) for s,m,p in zip(plus_starts, minus_shifts, minus_pads)]
+    ends   = [min(n,e+m*p) for e,n,m,p in zip(plus_ends, minus_npts, minus_shifts, minus_pads)]
+    starts[minus_axis] = 0 if minus_ext == -1 else ends[minus_axis]-minus_pads[minus_axis]
+    ends[minus_axis]   = ends[minus_axis] if minus_ext == 1 else minus_pads[minus_axis]
+    return starts, ends
+
+#------------------------------------------------------------------------------
+def get_plus_starts_ends(minus_starts, minus_ends, minus_npts, plus_npts, minus_axis, plus_axis,
+                         minus_ext, plus_ext, minus_pads, plus_pads, minus_shifts, plus_shifts,
+                         diff):
+    """
+    Compute the coefficients needed by the plus patch in a given interface.
+    """
+    starts = [max(0,s-m*p) for s,m,p in zip(minus_starts, plus_shifts, plus_pads)]
+    ends   = [min(n,e+m*p) for e,n,m,p in zip(minus_ends, plus_npts, plus_shifts, plus_pads)]
+    starts[plus_axis] = 0 if plus_ext == -1 else ends[plus_axis]-plus_pads[plus_axis]
+    ends[plus_axis]   = ends[plus_axis] if plus_ext == 1 else plus_pads[plus_axis]
+    return starts, ends
+
+
+#===============================================================================
+# TEST MultiPatchDomainDecomposition and CartDataExchanger in 2D
+#===============================================================================
+def run_carts_2d():
+    import numpy as np
+    
+    from feectools.ddm.mpi import mpi as MPI
+    from feectools.ddm.cart import MultiPatchDomainDecomposition, CartDecomposition, create_interfaces_cart
+    from feectools.ddm.blocking_data_exchanger  import BlockingCartDataExchanger
+    from feectools.ddm.interface_data_exchanger import InterfaceCartDataExchanger
+
+    #---------------------------------------------------------------------------
+    # INPUT PARAMETERS
+    #---------------------------------------------------------------------------
+
+    # Number of patches
+    N = 2
+
+    # Number of cells
+    nc1,nc2 = 16,16
+    nc = [[nc1,nc2] for i in range(N)]
+
+    # Padding ('thickness' of ghost region)
+    p1,p2 = 2,2
+    p = [[p1,p2] for i in range(N)]
+
+    # Periodicity
+    P = [[False, False] for i in range(N)]
+
+    connectivity = {(i,i+1):( ((0,1),(0,-1)) if i%2 ==0 else ((0,-1),(0,1)))  for i in range(N-1)}
+
+    #---------------------------------------------------------------------------
+    # DOMAIN DECOMPOSITION
+    #---------------------------------------------------------------------------
+
+    # Parallel info
+    comm = MPI.COMM_WORLD
+
+    domain_decomposition =  MultiPatchDomainDecomposition(nc, P, comm=comm)
+
+    # Number of Points
+    n = [[ncij + pij*(1-periodij) for ncij,pij,periodij in zip(nci,pi,periodi)] for nci,pi,periodi in zip(nc,p,P)]
+
+    carts = []
+    for i in range(N):
+        global_starts = [None]*2
+        global_ends   = [None]*2
+        for axis in range(2):
+            es = domain_decomposition.domains[i].global_element_starts[axis]
+            ee = domain_decomposition.domains[i].global_element_ends  [axis]
+
+            global_ends  [axis]     = (ee+1)-1
+            global_ends  [axis][-1] = n[i][axis]-1
+            global_starts[axis]     = np.array([0] + (global_ends[axis][:-1]+1).tolist())
+
+        carts.append(CartDecomposition(
+                        domain_decomposition      = domain_decomposition.domains[i],
+                        npts          = n[i],
+                        global_starts = global_starts,
+                        global_ends   = global_ends,
+                        pads          = p[i],
+                        shifts        = [1,1]))
+    carts = tuple(carts)
+
+    communication_info = (get_minus_starts_ends, get_plus_starts_ends)
+    interfaces_cart = create_interfaces_cart(domain_decomposition, carts, connectivity, communication_info=communication_info)
+
+    us         = [None]*len(carts)
+    syn        = [None]*len(carts)
+    syn_interface = {}
+    dtype         = int
+
+    val = lambda k,i1,i2: k*n[k][0]*n[k][1]+i1*n[k][0]+i2 if (0<=i1<n[k][0] and 0<=i2<n[k][1]) else 0
+    for i,ci in enumerate(carts):
+        if not ci.is_comm_null:
+            s1,s2 = ci.starts
+            e1,e2 = ci.ends
+            m1,m2 = ci.shifts
+            us[i] = np.zeros( ci.shape, dtype=dtype )
+            us[i][m1*p1:-m1*p1,m2*p2:-m2*p2] = [[val(i,i1,i2)for i2 in range(s2,e2+1)] for i1 in range(s1,e1+1)]
+            synchronizer = BlockingCartDataExchanger( ci, us[i].dtype)
+            syn[i] = synchronizer
+
+    for i,j in connectivity:
+        if not interfaces_cart[i,j].is_comm_null:
+            if carts[i].is_comm_null:
+                shape = interfaces_cart[i,j].get_interface_communication_infos(interfaces_cart[i,j]._axis)['gbuf_recv_shape'][0]
+                us[i] = np.zeros(shape, dtype=dtype)
+
+            if carts[j].is_comm_null:
+                shape = interfaces_cart[i,j].get_interface_communication_infos(interfaces_cart[i,j]._axis)['gbuf_recv_shape'][0]
+                us[j] = np.zeros(shape, dtype=dtype)
+
+            syn_interface[i,j] = InterfaceCartDataExchanger(interfaces_cart[i,j], dtype)
+
+    for minus,plus in connectivity:
+        if not interfaces_cart[minus,plus].is_comm_null:
+            req = syn_interface[minus,plus].start_update_ghost_regions(us[minus], us[plus])
+            syn_interface[minus,plus].end_update_ghost_regions(req=req)
+
+    for i,ci in enumerate(carts):
+        if not ci.is_comm_null:
+            # Update ghost regions
+            syn[i].start_update_ghost_regions( us[i], None )
+            syn[i].end_update_ghost_regions( us[i], None )
+
+    for i,ci in enumerate(carts):
+        if not ci.is_comm_null:
+            s1,s2 = ci.starts
+            e1,e2 = ci.ends
+            m1,m2 = ci.shifts
+            uex = [[val(i,i1,i2) for i2 in range(s2-m2*p2,e2+m2*p2+1)] for i1 in range(s1-m1*p1,e1+m1*p1+1)]
+            success = (us[i] == uex).all()
+            assert success
+
+#    for minus,plus in connectivity:
+#        if not interfaces[minus,plus].is_comm_null:
+#            axis = interfaces[minus,plus].axis
+#            I = interfaces[minus,plus]
+
+#            if not carts[minus].is_comm_null:
+#                uex =  [[val(plus,i1,i2)for i2 in range(*ranges[1])] for i1 in range(*ranges[0])]
+#                uex = np.pad(uex, [(m*p,m*p) for m,p in zip(carts[minus].shifts, carts[minus].pads)])
+#                u_ij = us[plus]
+#            elif not carts[plus].is_comm_null:
+#                uex =  [[val(minus,i1,i2)for i2 in range(*ranges[1])] for i1 in range(*ranges[0])]
+#                uex = np.pad(uex, [(m*p,m*p) for m,p in zip(carts[plus].shifts, carts[plus].pads)])
+#                u_ij = us[minus]
+
+#            success = (u_ij == uex).all()
+#            assert success
+
+#===============================================================================
+# RUN TEST MANUALLY
+#===============================================================================
+if __name__=='__main__':
+
+    run_carts_2d()
+
+

feectools/ddm/tests/test_partition.py

@@ -0,0 +1,124 @@
+import pytest
+
+from feectools.ddm.partition import compute_dims
+
+#==============================================================================
+@pytest.mark.parametrize( 'mpi_size', [1,2,5,10] )
+
+def test_partition_1d_uniform( mpi_size ):
+
+    # ...
+    # Should pass: all blocks are identical and have size=11
+    n1 = 11 * mpi_size
+    p1 = 3
+
+    dims, blocksizes = compute_dims( mpi_size, [n1,], [p1,] ) 
+
+    assert dims[0] == mpi_size
+    assert blocksizes[0] == 11
+
+    # ...
+    # Should fail: minimum block size is too large
+    n1 = 4 * mpi_size
+    p1 = 5
+
+    with pytest.raises( Exception ):
+        dims, blocksizes = compute_dims( mpi_size, [n1,], [p1,] )
+
+#==============================================================================
+@pytest.mark.parametrize( 'mpi_size', [1,2,5,10] )
+
+def test_partition_1d_general( mpi_size ):
+
+    # ...
+    # Should pass, nominal block size is 11
+    n1 = 11 * mpi_size + int( mpi_size > 1 )
+    p1 = 4
+
+    dims, blocksizes = compute_dims( mpi_size, [n1,], [p1,] ) 
+
+    assert dims[0] == mpi_size
+    assert blocksizes[0] == 11
+
+    # ...
+    # Should fail: minimum block size is too large
+    n1 = 4 * mpi_size + int( mpi_size > 1 )
+    p1 = 5
+
+    with pytest.raises( Exception ):
+        dims, blocksizes = compute_dims( mpi_size, [n1,], [p1,] )
+
+#==============================================================================
+@pytest.mark.parametrize( 'mpi_size', [1,2,5,10] )
+@pytest.mark.parametrize( 'mask', [[True, False], [False, True]] )
+@pytest.mark.parametrize( 'npts', [[64, 64], [58, 64], [64, 31]] )
+
+def test_partition_2d_dims_mask( mpi_size, npts, mask ):
+  
+    # General partition: blocks are not all identical but closer to a cube
+    dims, blocksizes = compute_dims( mpi_size, npts, [3,3] )   
+    
+    # Mask dimensions
+    dims, blocksizes = compute_dims( mpi_size, npts, [3,3], mpi_dims_mask=mask )   
+    
+    # test
+    assert dims[0]*dims[1] == mpi_size
+    for bsize, n, use_dim in zip(blocksizes, npts, mask):
+        if not use_dim:
+            assert bsize == n
+        else:
+            assert bsize == n//mpi_size
+
+#==============================================================================
+def test_partition_3d():
+
+    npts = [64,128,50]
+    mpi_size = 100
+
+    # ...
+    # Uniform partition, yields small block size along 3rd dimension
+    dims, blocksizes = compute_dims( mpi_size, npts, try_uniform=True )    
+
+    assert tuple( dims ) == (2, 2, 25)
+    assert tuple( blocksizes ) == (32, 64, 2)
+
+    # ...
+    # General partition: blocks are not all identical but closer to a cube
+    dims, blocksizes = compute_dims( mpi_size, npts, [3,3,3] )    
+
+    assert tuple( dims ) == (5, 5, 4)
+    assert tuple( blocksizes ) == (12, 25, 12)
+    
+#==============================================================================
+@pytest.mark.parametrize( 'mpi_size', [1,2,5,10] )
+@pytest.mark.parametrize( 'mask', [[True, False, False], 
+                                   [False, True, False], 
+                                   [False, False, True], 
+                                   [True, True, False],
+                                   [True, False, True],
+                                   [False, True, True]] )
+@pytest.mark.parametrize( 'npts', [[32, 64, 128], [62, 59, 41]] )
+
+def test_partition_3d_dims_mask( mpi_size, npts, mask ):
+   
+    # General partition: blocks are not all identical but closer to a cube
+    dims, blocksizes = compute_dims( mpi_size, npts, [3,3,3] )   
+    
+    # Mask dimensions
+    dims, blocksizes = compute_dims( mpi_size, npts, [3,3,3], mpi_dims_mask=mask )   
+    
+    # test
+    assert dims[0]*dims[1]*dims[2] == mpi_size
+    for bsize, n, use_dim in zip(blocksizes, npts, mask):
+        if not use_dim:
+            assert bsize == n
+    
+    
+if __name__ == '__main__':
+    # test_partition_2d_dims_mask(10, [64, 64], [True, False])
+    # test_partition_2d_dims_mask(10, [58, 64], [True, False])
+    
+    test_partition_3d_dims_mask(10, [32, 64, 128], [True, False, True])
+
+
+

feectools/ddm/utilities.py

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+from .cart                       import CartDecomposition, InterfaceCartDecomposition
+from .blocking_data_exchanger    import BlockingCartDataExchanger
+from .nonblocking_data_exchanger import NonBlockingCartDataExchanger
+from .interface_data_exchanger   import InterfaceCartDataExchanger
+
+__all__ = ('get_data_exchanger',)
+
+def get_data_exchanger(cart, dtype, *, coeff_shape=(),  assembly=False, axis=None, shape=None, blocking=True):
+
+    if isinstance(cart, InterfaceCartDecomposition):
+        return InterfaceCartDataExchanger(cart, dtype, coeff_shape=coeff_shape)
+
+    elif isinstance(cart, CartDecomposition):
+        if blocking:
+            return BlockingCartDataExchanger(cart, dtype, coeff_shape=coeff_shape, assembly=assembly, axis=axis, shape=shape)
+
+        else:
+            return NonBlockingCartDataExchanger(cart, dtype, coeff_shape=coeff_shape, assembly=assembly, axis=axis, shape=shape)
+    else:
+        raise TypeError('cart can only be of type CartDecomposition or InterfaceCartDecomposition')
+        
+