grid_dist_id_iterators_unit_tests.hpp

/*
 * grid_dist_id_iterators_unit_tests.hpp
 *
 *  Created on: Jan 4, 2017
 *      Author: i-bird
 */
 
#ifndef SRC_GRID_ITERATORS_GRID_DIST_ID_ITERATORS_UNIT_TESTS_HPP_
#define SRC_GRID_ITERATORS_GRID_DIST_ID_ITERATORS_UNIT_TESTS_HPP_
 
#include "grid_dist_id_iterator_dec_skin.hpp"
 
BOOST_AUTO_TEST_SUITE( grid_dist_id_iterators_test )
 
void print_test(std::string test, size_t sz)
{
    if (create_vcluster().getProcessUnitID() == 0)
        std::cout << test << " " << sz << "\n";
}
 
void Test2D_sub(const Box<2,float> & domain, long int k)
{
    long int big_step = k / 30;
    big_step = (big_step == 0)?1:big_step;
    long int small_step = 21;
 
    // this test is only performed when the number of processor is <= 32
    if (create_vcluster().getProcessingUnits() > 32)
        return;
 
    print_test( "Testing 2D grid sub iterator k<=",k);
 
    // 2D test
    for ( ; k >= 2 ; k-= (k > 2*big_step)?big_step:small_step )
    {
        BOOST_TEST_CHECKPOINT( "Testing 2D grid k=" << k );
 
        // grid size
        size_t sz[2];
        sz[0] = k;
        sz[1] = k;
 
        float factor = pow(create_vcluster().getProcessingUnits()/2.0f,1.0f/2.0f);
 
        // Ghost
        Ghost<2,float> g(0.01 / factor);
 
        // Distributed grid with id decomposition
        grid_dist_id<2, float, aggregate<float>> g_dist(sz,domain,g);
 
        // check the consistency of the decomposition
        bool val = g_dist.getDecomposition().check_consistency();
        BOOST_REQUIRE_EQUAL(val,true);
 
        size_t count;
 
        // Grid sm
        grid_sm<2,void> info(sz);
 
        {
 
        grid_key_dx<2> one(1,1);
        grid_key_dx<2> one_end(k-2,k-2);
 
        bool check = true;
        count = 0;
 
        // get the sub-domain iterator
        auto dom = g_dist.getSubDomainIterator(one,one_end);
 
        while (dom.isNext())
        {
            auto key = dom.get();
            auto key_g = g_dist.getGKey(key);
 
            // key_g should never be 1 or k-1
            check &= (key_g.get(0) == 0 || key_g.get(0) == k-1)?false:true;
            check &= (key_g.get(1) == 0 || key_g.get(1) == k-1)?false:true;
 
            g_dist.template get<0>(key) = info.LinId(key_g);
 
            // Count the point
            count++;
 
            ++dom;
        }
 
        BOOST_REQUIRE_EQUAL(check,true);
 
 
        }
 
        // Get the virtual cluster machine
        Vcluster<> & vcl = g_dist.getVC();
 
        // reduce
        vcl.sum(count);
        vcl.execute();
 
        // Check
        BOOST_REQUIRE_EQUAL(count,(size_t)(k-2)*(k-2));
 
        // check with a 1x1 square
 
        {
 
        grid_key_dx<2> one(k/2,k/2);
        grid_key_dx<2> one_end(k/2,k/2);
 
        count = 0;
 
        // get the sub-domain iterator
        auto dom = g_dist.getSubDomainIterator(one,one_end);
 
        while (dom.isNext())
        {
            auto key = dom.get();
            auto key_g = g_dist.getGKey(key);
 
            // key_g
            BOOST_REQUIRE_EQUAL(key_g.get(0),k/2);
            BOOST_REQUIRE_EQUAL(key_g.get(1),k/2);
 
            auto key_s_it = dom.getGKey(key);
 
            BOOST_REQUIRE_EQUAL(key_g.get(0),key_s_it.get(0));
            BOOST_REQUIRE_EQUAL(key_g.get(1),key_s_it.get(1));
 
            // Count the point
            count++;
 
            ++dom;
        }
 
        // reduce
        vcl.sum(count);
        vcl.execute();
 
        BOOST_REQUIRE_EQUAL(count,1ul);
        }
    }
}
 
// Test decomposition grid iterator
 
void Test3D_decit(const Box<3,float> & domain, long int k)
{
    size_t k_bck = k;
    {
        Vcluster<> & v_cl = create_vcluster();
 
        if ( v_cl.getProcessingUnits() > 32 )
            return;
 
        long int big_step = k / 30;
        big_step = (big_step == 0)?1:big_step;
        long int small_step = 21;
 
        print_test( "Testing grid iterator from decomposition k<=",k);
 
        // 3D test
        for ( ; k >= 2 ; k-= (k > 2*big_step)?big_step:small_step )
        {
            BOOST_TEST_CHECKPOINT( "Testing grid iterator from decomposition k<=" << k );
 
            // grid size
            size_t sz[3];
            sz[0] = k;
            sz[1] = k;
            sz[2] = k;
 
            // factor
            float factor = pow(create_vcluster().getProcessingUnits()/2.0f,1.0f/3.0f);
 
            // Ghost
            Ghost<3,float> g(0.01 / factor);
 
            // Distributed grid with id decomposition
            grid_dist_id<3, float, Point_test<float>, CartDecomposition<3,float>> g_dist(sz,domain,g);
 
            // check the consistency of the decomposition
            bool val = g_dist.getDecomposition().check_consistency();
            BOOST_REQUIRE_EQUAL(val,true);
 
            // Grid sm
            grid_sm<3,void> info(sz);
 
            auto dom = g_dist.getDomainIterator();
 
            bool match = true;
 
            // create a grid iterator from the decomposition
 
            grid_dist_id_iterator_dec<CartDecomposition<3,float>> it_dec(g_dist.getDecomposition(),g_dist.getGridInfoVoid().getSize());
 
            while (dom.isNext())
            {
                auto key = dom.get();
                auto key_g = g_dist.getGKey(key);
 
                auto key_dec = it_dec.get();
 
                // Check if the two keys match
                match &= (key_dec == key_g);
 
                ++dom;
                ++it_dec;
            }
 
            BOOST_REQUIRE_EQUAL(match,true);
        }
    }
 
    k = k_bck;
 
    {
        Vcluster<> & v_cl = create_vcluster();
 
        if ( v_cl.getProcessingUnits() > 32 )
            return;
 
        long int big_step = k / 30;
        big_step = (big_step == 0)?1:big_step;
        long int small_step = 21;
 
        print_test( "Testing grid iterator from decomposition subset k<=",k);
 
        // 3D test
        for ( ; k >= 2 ; k-= (k > 2*big_step)?big_step:small_step )
        {
            BOOST_TEST_CHECKPOINT( "Testing grid iterator from decomposition k<=" << k );
 
            // grid size
            size_t sz[3];
            sz[0] = k;
            sz[1] = k;
            sz[2] = k;
 
            // factor
            float factor = pow(create_vcluster().getProcessingUnits()/2.0f,1.0f/3.0f);
 
            // Ghost
            Ghost<3,float> g(0.01 / factor);
 
            // Distributed grid with id decomposition
            grid_dist_id<3, float, Point_test<float>, CartDecomposition<3,float>> g_dist(sz,domain,g);
 
            // check the consistency of the decomposition
            bool val = g_dist.getDecomposition().check_consistency();
            BOOST_REQUIRE_EQUAL(val,true);
 
            // Grid sm
            grid_sm<3,void> info(sz);
 
            auto dom = g_dist.getSubDomainIterator({0,0,0},{(long int)sz[0]-2,(long int)sz[1]-2,(long int)sz[2]-2});
 
            bool match = true;
 
            // create a grid iterator from the decomposition
 
            grid_dist_id_iterator_dec<CartDecomposition<3,float>> it_dec(g_dist.getDecomposition(),sz,{0,0,0},{(long int)sz[0]-2,(long int)sz[1]-2,(long int)sz[2]-2});
 
            while (dom.isNext())
            {
                auto key = dom.get();
                auto key_g = g_dist.getGKey(key);
 
                auto key_dec = it_dec.get();
 
                // Check if the two keys match
                match &= (key_dec == key_g);
 
                ++dom;
                ++it_dec;
            }
 
            BOOST_REQUIRE_EQUAL(match,true);
        }
    }
}
 
void Test3D_stencil(const Box<3,float> & domain, long int k)
{
    grid_key_dx<3> star_stencil_3D[7] = {{0,0,0},
                                             {0,0,-1},
                                             {0,0,1},
                                             {0,-1,0},
                                             {0,1,0},
                                             {-1,0,0},
                                             {1,0,0}};
 
    {
        Vcluster<> & v_cl = create_vcluster();
 
        if ( v_cl.getProcessingUnits() > 32 )
            return;
 
        long int big_step = k / 30;
        big_step = (big_step == 0)?1:big_step;
        long int small_step = 21;
 
        print_test( "Testing grid stencil iterator k<=",k);
 
        // 3D test
        for ( ; k >= 2 ; k-= (k > 2*big_step)?big_step:small_step )
        {
            BOOST_TEST_CHECKPOINT( "Testing grid skin iterator from decomposition k<=" << k );
 
            // grid size
            size_t sz[3];
            sz[0] = k;
            sz[1] = k;
            sz[2] = k;
 
            if (k <= 9)
                continue;
 
            Ghost<3,long int> g(1);
 
            // Distributed grid with id decomposition
            grid_dist_id<3, float, aggregate<long int, long int, double>, CartDecomposition<3,float>> g_dist(sz,domain,g);
 
            // fill the grid with values
 
            auto it = g_dist.getDomainGhostIterator();
 
            while (it.isNext())
            {
                auto p = it.get();
                auto gkey = it.getGKey(p);
 
                g_dist.template get<0>(p) = gkey.get(0) + gkey.get(1) + gkey.get(2);
 
                ++it;
            }
 
            g_dist.ghost_get<0>();
 
            auto st_it = g_dist.getDomainIteratorStencil(star_stencil_3D);
 
            bool ret = true;
 
            while (st_it.isNext())
            {
                auto key = st_it.get();
 
                // center point
                auto Cp = st_it.getStencil<0>();
 
                // plus,minus X,Y,Z
                auto mx = st_it.getStencil<1>();
                auto px = st_it.getStencil<2>();
                auto my = st_it.getStencil<3>();
                auto py = st_it.getStencil<4>();
                auto mz = st_it.getStencil<5>();
                auto pz = st_it.getStencil<6>();
 
                size_t sum = 6*g_dist.template get<0>(Cp) -
                             g_dist.template get<0>(mx) -
                             g_dist.template get<0>(px) -
                             g_dist.template get<0>(my) -
                             g_dist.template get<0>(py) -
                             g_dist.template get<0>(mz) -
                             g_dist.template get<0>(pz);
 
                ret &= (sum == 0);
 
                // get the local grid info
 
                grid_sm<3,void> info = g_dist.get_loc_grid(key.getSub()).getGrid();
 
                ret &= info.LinId(key.getKey()) == (long int)Cp.getKey();
 
                ++st_it;
            }
 
            BOOST_REQUIRE_EQUAL(ret,true);
        }
 
    }
}
 
void Test3D_fast_vect(const Box<3,float> & domain, long int k)
{
    grid_key_dx<3> star_stencil_3D[7] = {{0,0,0},
                                             {0,0,-1},
                                             {0,0,1},
                                             {0,-1,0},
                                             {0,1,0},
                                             {-1,0,0},
                                             {1,0,0}};
 
    {
        Vcluster<> & v_cl = create_vcluster();
 
        if ( v_cl.getProcessingUnits() > 32 )
            return;
 
        long int big_step = k / 30;
        big_step = (big_step == 0)?1:big_step;
        long int small_step = 21;
 
        print_test( "Testing grid 3D fast stencil k<=",k);
 
        // 3D test
        for ( ; k >= 2 ; k-= (k > 2*big_step)?big_step:small_step )
        {
            BOOST_TEST_CHECKPOINT( "Testing grid skin iterator from decomposition k<=" << k );
 
            // grid size
            size_t sz[3];
            sz[0] = k;
            sz[1] = k;
            sz[2] = k;
 
            if (k <= 9)
                continue;
 
            Ghost<3,long int> g(1);
 
            // Distributed grid with id decomposition
            grid_dist_id<3, float, aggregate<long int>, CartDecomposition<3,float>> g_dist(sz,domain,g);
 
            // fill the grid with values
 
            auto it = g_dist.getDomainGhostIterator();
 
            while (it.isNext())
            {
                auto p = it.get();
                auto gkey = it.getGKey(p);
 
                g_dist.template get<0>(p) = gkey.get(0)*gkey.get(0) + gkey.get(1)*gkey.get(1) + gkey.get(2)*gkey.get(2);
 
                ++it;
            }
 
            g_dist.ghost_get<0>();
 
            size_t ret = true;
 
            WHILE_M(g_dist,star_stencil_3D)
                auto & gstl = GET_GRID_M(g_dist);
            ITERATE_3D_M(1)
                // center point
                auto Cp = it.getStencil<0>();
 
                // plus,minus X,Y,Z
                auto mx = it.getStencil<1>();
                auto px = it.getStencil<2>();
                auto my = it.getStencil<3>();
                auto py = it.getStencil<4>();
                auto mz = it.getStencil<5>();
                auto pz = it.getStencil<6>();
 
                long int sum = -6*gstl.template get<0>(Cp) +
                             gstl.template get<0>(mx) +
                             gstl.template get<0>(px) +
                             gstl.template get<0>(my) +
                             gstl.template get<0>(py) +
                             gstl.template get<0>(mz) +
                             gstl.template get<0>(pz);
 
                ret &= (sum == 6);
 
            END_LOOP_M(1)
 
            BOOST_REQUIRE_EQUAL(ret,true);
        }
 
    }
}
 
// Test decomposition grid iterator
 
void Test3D_decskinit(const Box<3,float> & domain, long int k)
{
    {
        Vcluster<> & v_cl = create_vcluster();
 
        if ( v_cl.getProcessingUnits() > 32 )
        {return;}
 
        long int big_step = k / 30;
        big_step = (big_step == 0)?1:big_step;
        long int small_step = 21;
 
        print_test( "Testing grid skin iterator from decomposition k<=",k);
 
        // 3D test
        for ( ; k >= 2 ; k-= (k > 2*big_step)?big_step:small_step )
        {
            BOOST_TEST_CHECKPOINT( "Testing grid skin iterator from decomposition k<=" << k );
 
            // grid size
            size_t sz[3];
            sz[0] = k;
            sz[1] = k;
            sz[2] = k;
 
            if (k <= 9)
            {continue;}
 
            // factor
            float factor = pow(create_vcluster().getProcessingUnits()/2.0f,1.0f/3.0f);
 
            // Ghost
            Ghost<3,float> g(0.01 / factor);
 
            // Distributed grid with id decomposition
            grid_dist_id<3, float, aggregate<float>, CartDecomposition<3,float>> g_dist(sz,domain,g);
 
            // Set all the grid to zero
 
            auto it = g_dist.getDomainIterator();
 
            while (it.isNext())
            {
                auto p = it.get();
                auto gp = it.getGKey(p);
 
                g_dist.template get<0>(p) = 0.0;
 
                ++it;
            }
 
            // check the consistency of the decomposition
            bool val = g_dist.getDecomposition().check_consistency();
            BOOST_REQUIRE_EQUAL(val,true);
 
            // Grid sm
            grid_sm<3,void> info(sz);
 
            // create a grid skin iterator from the decomposition
 
            Box<3,size_t> A({3,3,3},{(size_t)k-3,(size_t)k-3,(size_t)k-3});
            Box<3,size_t> B = A;
 
            if (A.isValid() == false)
                continue;
 
            size_t bc[3] = {NON_PERIODIC,NON_PERIODIC,NON_PERIODIC};
            grid_dist_id_iterator_dec_skin<CartDecomposition<3,float>> it_dec(g_dist.getDecomposition(),g_dist.getGridInfoVoid(),A,B,bc);
 
            size_t cnt = 0;
 
            bool tot_good = true;
            while (it_dec.isNext())
            {
                auto key_dec = it_dec.get();
                auto key_dec_loc = it_dec.get_int();
 
                // one of the coordinate has to be or 3 or 8, none of
                // None of the coordinates must be bigger that
 
                bool eight_or_three = false;
                bool good = true;
                for (size_t i = 0; i < 3 ; i++)
                {
                    if (key_dec.get(i) == 3 || key_dec.get(i) == k - 3)
                    {eight_or_three = true;}
 
                    if (key_dec.get(i) > k - 3 || key_dec.get(i) < 3 )
                    {good = false;}
                }
 
                g_dist.template get<0>(key_dec_loc) = 1.0;
 
                tot_good &= (eight_or_three) || good;
 
                cnt++;
                ++it_dec;
            }
 
            create_vcluster().sum(cnt);
            create_vcluster().execute();
 
            BOOST_REQUIRE_EQUAL(cnt,(size_t)((k-5)*(k-5)*(k-5) - (k-7)*(k-7)*(k-7)));
            BOOST_REQUIRE_EQUAL(tot_good,true);
        }
    }
}
 
BOOST_AUTO_TEST_CASE( grid_dist_id_sub_iterator_test_use)
{
    // Domain
    Box<2,float> domain({0.0,0.0},{1.0,1.0});
 
    long int k = 1024*1024*create_vcluster().getProcessingUnits();
    k = std::pow(k, 1/2.);
 
    Test2D_sub(domain,k);
}
 
BOOST_AUTO_TEST_CASE( grid_dist_id_decomposition_iterator )
{
    // Domain
    Box<3,float> domain3({0.0,0.0,0.0},{1.0,1.0,1.0});
 
    size_t k = 128*128*128*create_vcluster().getProcessingUnits();
    k = std::pow(k, 1/3.);
    Test3D_decit(domain3,k);
}
 
BOOST_AUTO_TEST_CASE( grid_dist_id_iterator_stencil )
{
    // Domain
    Box<3,float> domain3({0.0,0.0,0.0},{1.0,1.0,1.0});
 
    size_t k = 128*128*128*create_vcluster().getProcessingUnits();
    k = std::pow(k, 1/3.);
    Test3D_stencil(domain3,k);
}
 
 
BOOST_AUTO_TEST_CASE( grid_dist_it_iterators_skin_test )
{
    // Domain
    Box<3,float> domain3({0.0,0.0,0.0},{1.0,1.0,1.0});
 
    size_t k = 128*128*128*create_vcluster().getProcessingUnits();
    k = std::pow(k, 1/3.);
    Test3D_decskinit(domain3,k);
}
 
BOOST_AUTO_TEST_CASE( grid_dist_it_iterators_3D_fast )
{
    // Domain
    Box<3,float> domain3({0.0,0.0,0.0},{1.0,1.0,1.0});
 
    size_t k = 128*128*128*create_vcluster().getProcessingUnits();
    k = std::pow(k, 1/3.);
    Test3D_fast_vect(domain3,k);
}
 
BOOST_AUTO_TEST_SUITE_END()
 
#endif /* SRC_GRID_ITERATORS_GRID_DIST_ID_ITERATORS_UNIT_TESTS_HPP_ */