grid_dist_id_unit_test_ext_dom.hpp

/*
 * grid_dist_id_unit_test_ext_dom.hpp
 *
 *  Created on: Feb 24, 2016
 *      Author: i-bird
 */
#include "Decomposition/CartDecomposition_ext.hpp"
#include "Grid/grid_dist_id.hpp"
 
extern void print_test_v(std::string test, size_t sz);
 
// Test duplicated topology
 
void Test3D_extended_grid(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;
 
    Vcluster<> & v_cl = create_vcluster();
 
    if ( v_cl.getProcessingUnits() > 32 )
        return;
 
    print_test_v( "Testing 3D extended grid k<=",k);
 
    // factor
    float factor = pow(create_vcluster().getProcessingUnits()/2.0f,1.0f/3.0f);
 
    // This test in order to work must have at least one ghost
    for ( ; (0.01 / factor) > ((domain.getHigh(0) - domain.getLow(0)) / k) ; k-= (k > 2*big_step)?big_step:small_step )
    {
        BOOST_TEST_CHECKPOINT( "Testing 3D extended grid k=" << k );
 
        // grid size
        size_t sz[3];
        sz[0] = k;
        sz[1] = k;
        sz[2] = k;
 
        // Ghost
        Ghost<3,float> g(0.01 / factor);
 
 
        // Distributed grid with id decomposition
        grid_dist_id<3, float, aggregate<size_t[3],size_t>, CartDecomposition<3,float>> g_dist1(sz,domain,g);
 
        // Extend the grid by 2 points
        Box<3,size_t> ext({2,2,2},{2,2,2});
 
        // Ghost size of 1 grid point
        Ghost<3,long int> gp(1);
 
        // another grid perfectly overlapping the previous, extended by 2 points
        grid_dist_id<3, float, aggregate<size_t[3],size_t>, CartDecomposition_ext<3,float>> g_dist2(g_dist1,gp,ext);
 
        // Given an iterator of the grid 1
        auto dom_g1 = g_dist1.getDomainIterator();
        // And a sub-iterator of grid 2 overlapping grid 1
        auto dom_g2 = g_dist2.getSubDomainIterator({0,0,0},{k-1,k-1,k-1});
 
        // the 2 iterator must match
 
        bool check = true;
 
        while (dom_g2.isNext())
        {
            auto key1 = dom_g1.get();
            auto key2 = dom_g2.get();
 
            grid_key_dx<3> g1_k = g_dist1.getGKey(key1);
            grid_key_dx<3> g2_k = g_dist2.getGKey(key2);
 
            check &= (g1_k == g2_k)?true:false;
 
            ++dom_g1;
            ++dom_g2;
        }
 
        BOOST_REQUIRE_EQUAL(check,true);
 
 
        bool ret = g_dist2.getDecomposition().check_consistency();
        BOOST_REQUIRE_EQUAL(ret,true);
 
        // Get domain iterator
 
        grid_sm<3,void> info = g_dist2.getGridInfo();
        auto dom_g3 = g_dist2.getDomainIterator();
 
        check = false;
 
        while (dom_g3.isNext())
        {
            auto key1 = dom_g3.get();
 
            auto keyg = g_dist2.getGKey(key1);
 
            g_dist2.template get<0>(key1)[0] = keyg.get(0);
            g_dist2.template get<0>(key1)[1] = keyg.get(1);
            g_dist2.template get<0>(key1)[2] = keyg.get(2);
 
            g_dist2.template get<1>(key1) = info.LinId(keyg);
 
            ++dom_g3;
        }
 
        g_dist2.ghost_get<0,1>();
 
        auto dom_g4 = g_dist2.getSubDomainIterator({-1,-1,-1},{(long int) sz[0]+2-2, (long int) sz[1]+2-2, (long int) sz[2]+2-2});
 
        check = true;
 
        while (dom_g4.isNext())
        {
            auto key1 = dom_g4.get();
 
            key1 = key1.move(0,1);
            key1 = key1.move(1,1);
            key1 = key1.move(2,1);
 
            auto key2 = g_dist2.getGKey(key1);
 
            check &= g_dist2.template get<0>(key1)[0] == (size_t)key2.get(0);
            check &= g_dist2.template get<0>(key1)[1] == (size_t)key2.get(1);
            check &= g_dist2.template get<0>(key1)[2] == (size_t)key2.get(2);
 
            auto key3 = dom_g4.get();
 
            key3 = key3.move(0,-1);
            key3 = key3.move(1,-1);
            key3 = key3.move(2,-1);
 
            auto key4 = g_dist2.getGKey(key3);
 
            check &= g_dist2.template get<0>(key3)[0] == (size_t)key4.get(0);
            check &= g_dist2.template get<0>(key3)[1] == (size_t)key4.get(1);
            check &= g_dist2.template get<0>(key3)[2] == (size_t)key4.get(2);
 
            ++dom_g4;
        }
 
        BOOST_REQUIRE_EQUAL(check,true);
    }
}