grid_dist_id_unit_test_unb_ghost.hpp

/*
 * grid_dist_id_unit_test_unb_ghost.hpp
 *
 *  Created on: Jul 11, 2016
 *      Author: i-bird
 */
 
void Test3D_unb_ghost(const Box<3,float> & domain, long int k)
{
    long int big_step = k / 30;
    big_step = (big_step == 0)?1:big_step;
    long int small_step = 21;
 
    if (create_vcluster().getProcessingUnits() > 48)
        return;
 
    print_test_v( "Testing 3D grid unbound ghost k<=",k);
 
    // 3D test
    for ( ; k >= 2 ; k-= (k > 2*big_step)?big_step:small_step )
    {
        BOOST_TEST_CHECKPOINT( "Testing 3D grid k=" << k );
 
        // grid size
        size_t sz[3];
        sz[0] = k;
        sz[1] = k;
        sz[2] = k;
 
        // Ghost
        Ghost<3,float> g(0.49);
 
        // Distributed grid with id decomposition
        grid_dist_id<3, float, aggregate<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);
 
        // get the domain iterator
        size_t count = 0;
 
        auto dom = g_dist.getDomainIterator();
 
        while (dom.isNext())
        {
            auto key = dom.get();
            auto key_g = g_dist.getGKey(key);
 
            g_dist.template get<0>(key) = info.LinId(key_g);
 
            // Count the point
            count++;
 
            ++dom;
        }
 
        // Get the virtual cluster machine
        Vcluster<> & vcl = g_dist.getVC();
 
        // reduce
        vcl.sum(count);
        vcl.execute();
 
        // Check
        BOOST_REQUIRE_EQUAL(count,(size_t)k*k*k);
 
        bool match = true;
 
        auto dom2 = g_dist.getDomainIterator();
 
        // check that the grid store the correct information
        while (dom2.isNext())
        {
            auto key = dom2.get();
            auto key_g = g_dist.getGKey(key);
 
            match &= (g_dist.template get<0>(key) == info.LinId(key_g))?true:false;
 
            ++dom2;
        }
 
        BOOST_REQUIRE_EQUAL(match,true);
 
 
        g_dist.template ghost_get<0>();
 
        // check that the communication is correctly completed
 
        auto domg = g_dist.getDomainGhostIterator();
 
        // check that the grid with the ghost past store the correct information
        while (domg.isNext())
        {
            auto key = domg.get();
            auto key_g = g_dist.getGKey(key);
 
            // In this case the boundary condition are non periodic
            if (g_dist.isInside(key_g))
            {
                match &= (g_dist.template get<0>(key) == info.LinId(key_g))?true:false;
            }
 
            ++domg;
        }
 
        BOOST_REQUIRE_EQUAL(match,true);
 
    }
}
 
 
// Test grid periodic
void Test3D_unb_ghost_periodic(const Box<3,float> & domain, long int k)
{
    Vcluster<> & v_cl = create_vcluster();
 
    if ( v_cl.getProcessingUnits() > 24 )
        return;
 
    long int big_step = k / 30;
    big_step = (big_step == 0)?1:big_step;
    long int small_step = 21;
 
    print_test_v( "Testing grid periodic unbound ghost k<=",k);
 
    // 3D test
    for ( ; k >= 2 ; k-= (k > 2*big_step)?big_step:small_step )
    {
        BOOST_TEST_CHECKPOINT( "Testing grid unbound ghost periodic k<=" << k );
 
        // grid size
        size_t sz[3];
        sz[0] = k;
        sz[1] = k;
        sz[2] = k;
 
        // Ghost
        Ghost<3,float> g(0.491);
 
        // periodicity
        periodicity<3> pr = {{PERIODIC,PERIODIC,PERIODIC}};
 
        // Distributed grid with id decomposition
        grid_dist_id<3, float, aggregate<long int>, CartDecomposition<3,float>> g_dist(sz,domain,g,pr);
 
        // 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);
 
        size_t count = 0;
 
        // Set to zero the full grid
 
        auto dom1 = g_dist.getDomainGhostIterator();
 
        while (dom1.isNext())
        {
            auto key = dom1.get();
 
            g_dist.template get<0>(key) = -1;
 
            ++dom1;
        }
 
        auto dom = g_dist.getDomainIterator();
 
        while (dom.isNext())
        {
            auto key = dom.get();
            auto key_g = g_dist.getGKey(key);
 
            g_dist.template get<0>(key) = info.LinId(key_g);
 
            // Count the points
            count++;
 
            ++dom;
        }
 
        // Get the virtual cluster machine
        Vcluster<> & vcl = g_dist.getVC();
 
        // reduce
        vcl.sum(count);
        vcl.execute();
 
        // Check
        BOOST_REQUIRE_EQUAL(count,(size_t)k*k*k);
 
        // sync the ghosts
        g_dist.ghost_get<0>();
 
        bool match = true;
 
        // Domain + Ghost iterator
        auto dom_gi = g_dist.getDomainGhostIterator();
 
        size_t out_cnt = 0;
 
        while (dom_gi.isNext())
        {
            bool out_p = false;
 
            auto key = dom_gi.get();
            auto key_g = g_dist.getGKey(key);
 
            // Return the boxes containing the grids
            auto & gb = dom_gi.getGBoxes();
 
            // transform the key to be periodic
            for (size_t i = 0 ; i < 3 ; i++)
            {
                if (key_g.get(i) < 0)
                {key_g.set_d(i,key_g.get(i) + k);out_p = true;}
                else if (key_g.get(i) >= k)
                {key_g.set_d(i,key_g.get(i) - k);out_p = true;}
            }
 
            if (g_dist.template get<0>(key) != -1 && out_p == true)
                out_cnt++;
 
            // The last points can be invalid because of rounding off problems
            bool can_invalid = false;
            if (key.getKey().get(0) == 0 || key.getKey().get(1) == 0 || key.getKey().get(2) == 0)
                can_invalid = true;
            else if (key.getKey().get(0) == gb.get(key.getSub()).GDbox.getHigh(0) ||
                     key.getKey().get(1) == gb.get(key.getSub()).GDbox.getHigh(1) ||
                     key.getKey().get(2) == gb.get(key.getSub()).GDbox.getHigh(2))
                can_invalid = true;
 
            if (can_invalid == true)
            {
                if ( g_dist.template get<0>(key) != -1 && info.LinId(key_g) != g_dist.template get<0>(key) )
                    match &= false;
            }
            else
            {
                if (info.LinId(key_g) != g_dist.template get<0>(key) )
                    match &= false;
            }
 
            ++dom_gi;
        }
 
        BOOST_REQUIRE_EQUAL(match, true);
        if (k > 83)
        {
            vcl.sum(out_cnt);
            vcl.execute();
            BOOST_REQUIRE(out_cnt != 0ul);
        }
    }
}