grid_dist_amr_unit_tests.cpp

/*
 * grid_dist_amr_dist_unit_tests.cpp
 *
 *  Created on: Sep 21, 2017
 *      Author: i-bird
 */


#define BOOST_TEST_DYN_LINK

#include <boost/test/unit_test.hpp>
#include "grid_dist_amr.hpp"

BOOST_AUTO_TEST_SUITE( grid_dist_amr_test )


template<typename grid_amr>
void Test3D_amr_create_levels(grid_amr & amr_g, Box<3,float> & domain, size_t coars_g, size_t n_lvl)
{
    size_t g_sz[3] = {coars_g,coars_g,coars_g};

    size_t tot_c = (coars_g - 1)*(coars_g - 1)*(coars_g - 1);
    size_t correct_result = 0;
    size_t correct_result_cell = 0;
    size_t fact = 1;

    for (size_t i = 0 ; i < n_lvl ; i++)
    {
        correct_result += coars_g*coars_g*coars_g;
        correct_result_cell += tot_c*fact;
        coars_g = 2*(coars_g - 1) + 1;
        fact *= 8;
    }

    amr_g.initLevels(n_lvl,g_sz);


    for (size_t i = 0 ; i < amr_g.getNLvl() ; i++)
    {
        // Fill the AMR with something

        size_t count = 0;

        auto it = amr_g.getGridIterator(i);

        while (it.isNext())
        {
            auto key = it.get_dist();
            auto akey = amr_g.getAMRKey(i,key);

            amr_g.template insert<0>(akey) = 3.0;

            amr_g.template insert<1>(akey)[0] = 3.0;
            amr_g.template insert<1>(akey)[1] = 3.0;
            amr_g.template insert<1>(akey)[2] = 3.0;

            amr_g.template insert<2>(akey)[0] = 3;
            amr_g.template insert<2>(akey)[1] = 3;
            amr_g.template insert<2>(akey)[2] = 3;

            count++;

            ++it;
        }
    }

    // Iterate across all the levels initialized
    auto it = amr_g.getDomainIterator();

    size_t count = 0;

    while (it.isNext())
    {
        count++;

        ++it;
    }

    Vcluster<> & v_cl = create_vcluster();

    v_cl.sum(count);
    v_cl.execute();

    BOOST_REQUIRE_EQUAL(count,correct_result);

    auto itc = amr_g.getDomainIteratorCells();

    size_t count_c = 0;

    while (itc.isNext())
    {
        count_c++;

        ++itc;
    }

    v_cl.sum(count_c);
    v_cl.execute();

    auto it_level = amr_g.getDomainIteratorCells(3);

    while (it_level.isNext())
    {
        auto key = it_level.get();

        amr_g.template get<0>(3,key);

        ++it_level;
    }

    BOOST_REQUIRE_EQUAL(count_c,correct_result_cell);
}



template<unsigned int dim>
inline bool gr_is_inside(const grid_key_dx<dim> & key, const size_t (& sz)[dim])
{
    for (size_t i = 0 ; i < dim ; i++)
    {
        if (key.get(i) >= (long int)sz[i] || key.get(i) < 0)
        {
            return false;
        }
    }

    return true;
}

template <typename grid>
void Test3D_amr_child_parent_get_no_periodic(grid & amr_g, Box<3,float> & domain, size_t coars_g, size_t n_lvl)
{
    const int x = 0;
    const int y = 1;
    const int z = 2;

    size_t g_sz[3] = {coars_g,coars_g,coars_g};

    size_t tot = coars_g*coars_g*coars_g;
    size_t correct_result = 0;
    size_t fact = 1;

    for (size_t i = 0 ; i <  n_lvl ; i++)
    {
        correct_result += tot*fact;
        fact *= 8;
    }

    amr_g.initLevels(n_lvl,g_sz);


    for (size_t i = 0 ; i < amr_g.getNLvl() ; i++)
    {
        // Fill the AMR with something

        size_t count = 0;

        auto it = amr_g.getGridIterator(i);

        while (it.isNext())
        {
            auto key = it.get_dist();
            auto akey = amr_g.getAMRKey(i,key);

            amr_g.template insert<0>(akey) = 3.0;

            count++;

            ++it;
        }
    }


    std::string test = amr_g.getSpacing(0).toString();

    // Iterate across all the levels initialized
    auto it = amr_g.getDomainIterator();

    while (it.isNext())
    {
        auto key = it.get();
        auto gkey = it.getGKey();

        amr_g.template insert<0>(key) = gkey.get(0);
        amr_g.template insert<1>(key) = gkey.get(1);
        amr_g.template insert<2>(key) = gkey.get(2);
        amr_g.template insert<3>(key)[0] = gkey.get(0);
        amr_g.template insert<3>(key)[1] = gkey.get(1);
        amr_g.template insert<3>(key)[2] = gkey.get(2);
        amr_g.template insert<3>(key)[3] = gkey.get(0);

        ++it;
    }

    amr_g.template ghost_get<0,1,2,3>();

    // now we check that move space work

    auto it2 = amr_g.getDomainIterator();

    bool match = true;
    while (it2.isNext())
    {
        auto key = it2.get();
        auto gkey = it2.getGKey();

        auto key_px = key.moveSpace(x,1);
        auto key_gpx = amr_g.getGKey(key_px);

        auto key_mx = key.moveSpace(x,-1);
        auto key_gmx = amr_g.getGKey(key_mx);

        auto key_py = key.moveSpace(y,1);
        auto key_gpy = amr_g.getGKey(key_py);

        auto key_my = key.moveSpace(y,-1);
        auto key_gmy = amr_g.getGKey(key_my);

        auto key_pz = key.moveSpace(z,1);
        auto key_gpz = amr_g.getGKey(key_pz);

        auto key_mz = key.moveSpace(z,-1);
        auto key_gmz = amr_g.getGKey(key_mz);

        if (gr_is_inside(key_gpx,amr_g.getGridInfoVoid(it2.getLvl()).getSize()) == true)
        {
            match &= amr_g.template get<0>(key_px) == gkey.get(0) + 1;
            match &= amr_g.template get<1>(key_px) == gkey.get(1);
            match &= amr_g.template get<2>(key_px) == gkey.get(2);

            match &= amr_g.template get<3>(key_px)[0] == gkey.get(0) + 1;
            match &= amr_g.template get<3>(key_px)[1] == gkey.get(1);
            match &= amr_g.template get<3>(key_px)[2] == gkey.get(2);
            match &= amr_g.template get<3>(key_px)[3] == gkey.get(0) + 1;
        }

        if (gr_is_inside(key_gmx,amr_g.getGridInfoVoid(it2.getLvl()).getSize()) == true)
        {
            match &= amr_g.template get<0>(key_mx) == gkey.get(0) - 1;
            match &= amr_g.template get<1>(key_mx) == gkey.get(1);
            match &= amr_g.template get<2>(key_mx) == gkey.get(2);

            match &= amr_g.template get<3>(key_mx)[0] == gkey.get(0) - 1;
            match &= amr_g.template get<3>(key_mx)[1] == gkey.get(1);
            match &= amr_g.template get<3>(key_mx)[2] == gkey.get(2);
            match &= amr_g.template get<3>(key_mx)[3] == gkey.get(0) - 1;
        }

        if (gr_is_inside(key_gpy,amr_g.getGridInfoVoid(it2.getLvl()).getSize()) == true)
        {
            match &= amr_g.template get<0>(key_py) == gkey.get(0);
            match &= amr_g.template get<1>(key_py) == gkey.get(1) + 1;
            match &= amr_g.template get<2>(key_py) == gkey.get(2);

            match &= amr_g.template get<3>(key_py)[0] == gkey.get(0);
            match &= amr_g.template get<3>(key_py)[1] == gkey.get(1) + 1;
            match &= amr_g.template get<3>(key_py)[2] == gkey.get(2);
            match &= amr_g.template get<3>(key_py)[3] == gkey.get(0);
        }

        if (gr_is_inside(key_gmy,amr_g.getGridInfoVoid(it2.getLvl()).getSize()) == true)
        {
            match &= amr_g.template get<0>(key_my) == gkey.get(0);
            match &= amr_g.template get<1>(key_my) == gkey.get(1) - 1;
            match &= amr_g.template get<2>(key_my) == gkey.get(2);

            match &= amr_g.template get<3>(key_my)[0] == gkey.get(0);
            match &= amr_g.template get<3>(key_my)[1] == gkey.get(1) - 1;
            match &= amr_g.template get<3>(key_my)[2] == gkey.get(2);
            match &= amr_g.template get<3>(key_my)[3] == gkey.get(0);
        }

        if (gr_is_inside(key_gpz,amr_g.getGridInfoVoid(it2.getLvl()).getSize()) == true)
        {
            match &= amr_g.template get<0>(key_pz) == gkey.get(0);
            match &= amr_g.template get<1>(key_pz) == gkey.get(1);
            match &= amr_g.template get<2>(key_pz) == gkey.get(2) + 1;

            match &= amr_g.template get<3>(key_pz)[0] == gkey.get(0);
            match &= amr_g.template get<3>(key_pz)[1] == gkey.get(1);
            match &= amr_g.template get<3>(key_pz)[2] == gkey.get(2) + 1;
            match &= amr_g.template get<3>(key_pz)[3] == gkey.get(0);
        }

        if (gr_is_inside(key_gmz,amr_g.getGridInfoVoid(it2.getLvl()).getSize()) == true)
        {
            match &= amr_g.template get<0>(key_mz) == gkey.get(0);
            match &= amr_g.template get<1>(key_mz) == gkey.get(1);
            match &= amr_g.template get<2>(key_mz) == gkey.get(2) - 1;

            match &= amr_g.template get<3>(key_mz)[0] == gkey.get(0);
            match &= amr_g.template get<3>(key_mz)[1] == gkey.get(1);
            match &= amr_g.template get<3>(key_mz)[2] == gkey.get(2) - 1;
            match &= amr_g.template get<3>(key_mz)[3] == gkey.get(0);
        }


        // Test to go to all the levels down

        size_t lvl = it2.getLvl();

        if (lvl < amr_g.getNLvl() - 1)
        {
            auto key_l1 = key;
            amr_g.moveLvlDw(key_l1);
            auto key_gl1 = amr_g.getGKey(key_l1);

            for (size_t s = 0 ; s < 3 ; s++)
            {
                match &= key_gl1.get(s) >> 1 == gkey.get(s);
                match &= amr_g.template get<0>(key_l1) == key_gl1.get(0);
                match &= amr_g.template get<1>(key_l1) == key_gl1.get(1);
                match &= amr_g.template get<2>(key_l1) == key_gl1.get(2);
            }
        }

        if (lvl != 0)
        {
            auto key_l1 = key;
            amr_g.moveLvlUp(key_l1);
            auto key_gl1 = amr_g.getGKey(key_l1);

            for (size_t s = 0 ; s < 3 ; s++)
            {
                match &= gkey.get(s) >> 1 == key_gl1.get(s);

                match &= amr_g.template get<0>(key_l1) == key_gl1.get(0);
                match &= amr_g.template get<1>(key_l1) == key_gl1.get(1);
                match &= amr_g.template get<2>(key_l1) == key_gl1.get(2);
            }
        }

        ++it2;
    }

    BOOST_REQUIRE_EQUAL(match,true);
}


template <typename grid>
void Test3D_amr_child_parent_get_periodic(grid & amr_g, Box<3,float> & domain, size_t coars_g, size_t n_lvl)
{
    const int x = 0;
    const int y = 1;
    const int z = 2;

    size_t g_sz[3] = {coars_g,coars_g,coars_g};

    size_t tot = coars_g*coars_g*coars_g;
    size_t correct_result = 0;
    size_t fact = 1;

    for (size_t i = 0 ; i <  n_lvl ; i++)
    {
        correct_result += tot*fact;
        fact *= 8;
    }

    amr_g.initLevels(n_lvl,g_sz);


    for (size_t i = 0 ; i < amr_g.getNLvl() ; i++)
    {
        // Fill the AMR with something

        size_t count = 0;

        auto it = amr_g.getGridIterator(i);

        while (it.isNext())
        {
            auto key = it.get_dist();
            auto akey = amr_g.getAMRKey(i,key);

            amr_g.template insert<0>(akey) = 3.0;

            count++;

            ++it;
        }
    }


    std::string test = amr_g.getSpacing(0).toString();

    // Iterate across all the levels initialized
    auto it = amr_g.getDomainIterator();

    while (it.isNext())
    {
        auto key = it.get();
        auto gkey = it.getGKey();

        amr_g.template insert<0>(key) = gkey.get(0);
        amr_g.template insert<1>(key) = gkey.get(1);
        amr_g.template insert<2>(key) = gkey.get(2);

        ++it;
    }

    amr_g.template ghost_get<0,1,2>();

    // now we check that move space work

    auto it2 = amr_g.getDomainIterator();

    bool match = true;
    while (it2.isNext())
    {
        auto key = it2.get();
        auto gkey = it2.getGKey();

        auto key_px = key.moveSpace(x,1);
        auto key_mx = key.moveSpace(x,-1);
        auto key_py = key.moveSpace(y,1);
        auto key_my = key.moveSpace(y,-1);
        auto key_pz = key.moveSpace(z,1);
        auto key_mz = key.moveSpace(z,-1);

        match &= amr_g.template get<0>(key_px) == openfpm::math::positive_modulo(gkey.get(0) + 1,amr_g.getGridInfoVoid(it2.getLvl()).size(0));
        match &= amr_g.template get<1>(key_px) == gkey.get(1);
        match &= amr_g.template get<2>(key_px) == gkey.get(2);

        match &= amr_g.template get<0>(key_mx) == openfpm::math::positive_modulo(gkey.get(0) - 1,amr_g.getGridInfoVoid(it2.getLvl()).size(0));
        match &= amr_g.template get<1>(key_mx) == gkey.get(1);
        match &= amr_g.template get<2>(key_mx) == gkey.get(2);

        match &= amr_g.template get<0>(key_py) == gkey.get(0);
        match &= amr_g.template get<1>(key_py) == openfpm::math::positive_modulo(gkey.get(1) + 1,amr_g.getGridInfoVoid(it2.getLvl()).size(1));
        match &= amr_g.template get<2>(key_py) == gkey.get(2);

        match &= amr_g.template get<0>(key_my) == gkey.get(0);
        match &= amr_g.template get<1>(key_my) == openfpm::math::positive_modulo(gkey.get(1) - 1,amr_g.getGridInfoVoid(it2.getLvl()).size(1));
        match &= amr_g.template get<2>(key_my) == gkey.get(2);

        match &= amr_g.template get<0>(key_pz) == gkey.get(0);
        match &= amr_g.template get<1>(key_pz) == gkey.get(1);
        match &= amr_g.template get<2>(key_pz) == openfpm::math::positive_modulo(gkey.get(2) + 1,amr_g.getGridInfoVoid(it2.getLvl()).size(2));

        match &= amr_g.template get<0>(key_mz) == gkey.get(0);
        match &= amr_g.template get<1>(key_mz) == gkey.get(1);
        match &= amr_g.template get<2>(key_mz) == openfpm::math::positive_modulo(gkey.get(2) - 1,amr_g.getGridInfoVoid(it2.getLvl()).size(2));

        // Test to go to all the levels down

        size_t lvl = it2.getLvl();

        if (lvl < amr_g.getNLvl() - 1)
        {
            auto key_l1 = key;
            amr_g.moveLvlDw(key_l1);
            auto key_gl1 = amr_g.getGKey(key_l1);

            for (size_t s = 0 ; s < 3 ; s++)
            {
                match &= key_gl1.get(s) >> 1 == gkey.get(s);
                match &= amr_g.template get<0>(key_l1) == key_gl1.get(0);
                match &= amr_g.template get<1>(key_l1) == key_gl1.get(1);
                match &= amr_g.template get<2>(key_l1) == key_gl1.get(2);
            }
        }

        if (lvl != 0)
        {
            auto key_l1 = key;
            amr_g.moveLvlUp(key_l1);
            auto key_gl1 = amr_g.getGKey(key_l1);

            for (size_t s = 0 ; s < 3 ; s++)
            {
                match &= gkey.get(s) >> 1 == key_gl1.get(s);

                match &= amr_g.template get<0>(key_l1) == key_gl1.get(0);
                match &= amr_g.template get<1>(key_l1) == key_gl1.get(1);
                match &= amr_g.template get<2>(key_l1) == key_gl1.get(2);
            }
        }

        ++it2;
    }

    BOOST_REQUIRE_EQUAL(match,true);
}

template <typename grid>
void Test3D_amr_ghost_it(grid & amr_g, Box<3,float> & domain, size_t coars_g, size_t n_lvl)
{
    size_t g_sz[3] = {coars_g,coars_g,coars_g};

    size_t tot = coars_g*coars_g*coars_g;
    size_t correct_result = 0;
    size_t fact = 1;

    for (size_t i = 0 ; i <  n_lvl ; i++)
    {
        correct_result += tot*fact;
        fact *= 8;
    }

    amr_g.initLevels(n_lvl,g_sz);


    for (size_t i = 0 ; i < amr_g.getNLvl() ; i++)
    {
        // Fill the AMR with something

        size_t count = 0;

        auto it = amr_g.getGridGhostIterator(i);

        while (it.isNext())
        {
            auto key = it.get_dist();
            auto gkey = it.get();
            auto akey = amr_g.getAMRKey(i,key);

            amr_g.template insert<0>(akey) = gkey.get(0);
            amr_g.template insert<1>(akey) = gkey.get(1);
            amr_g.template insert<2>(akey) = gkey.get(2);

            if (gkey.get(0) == -1 || gkey.get(0) == (long int)amr_g.getGridInfoVoid(i).size(0) ||
                gkey.get(1) == -1 || gkey.get(1) == (long int)amr_g.getGridInfoVoid(i).size(1) ||
                gkey.get(2) == -1 || gkey.get(2) == (long int)amr_g.getGridInfoVoid(i).size(2))
            {count++;}

            ++it;
        }

        size_t tot = (amr_g.getGridInfoVoid(i).size(0) + 2)*
                     (amr_g.getGridInfoVoid(i).size(1) + 2)*
                     (amr_g.getGridInfoVoid(i).size(2) + 2) - amr_g.getGridInfoVoid(i).size();

        auto & v_cl = create_vcluster();

        if (v_cl.size() == 1)
        {
            v_cl.sum(count);
            v_cl.execute();

            BOOST_REQUIRE_EQUAL(tot,count);
        }

        bool match = true;
        auto it2 = amr_g.getDomainIterator(i);

        while (it2.isNext())
        {
            auto key = it2.get();

            // move -x

            auto key_m1 = key.move(0,-1);
            auto key_gm1 = it2.getGKey(key_m1);
            match &= amr_g.template get<0>(i,key_m1) == key_gm1.get(0);

            // move +x

            auto key_p1 = key.move(0,1);
            auto key_gp1 = it2.getGKey(key_p1);
            match &= amr_g.template get<0>(i,key_p1) == key_gp1.get(0);

            // move -y

            key_m1 = key.move(1,-1);
            key_gm1 = it2.getGKey(key_m1);
            match &= amr_g.template get<1>(i,key_m1) == key_gm1.get(1);

            // move +y

            key_p1 = key.move(1,1);
            key_gp1 = it2.getGKey(key_p1);
            match &= amr_g.template get<1>(i,key_p1) == key_gp1.get(1);

            // move -z

            key_m1 = key.move(2,-1);
            key_gm1 = it2.getGKey(key_m1);
            match &= amr_g.template get<2>(i,key_m1) == key_gm1.get(2);

            // move +z

            key_p1 = key.move(2,1);
            key_gp1 = it2.getGKey(key_p1);
            match &= amr_g.template get<2>(i,key_p1) == key_gp1.get(2);

            ++it2;
        }

        BOOST_REQUIRE_EQUAL(match,true);
    }
}



template <typename grid>
void Test3D_amr_domain_ghost_it(grid & amr_g, Box<3,float> & domain, size_t coars_g, size_t n_lvl)
{
    size_t g_sz[3] = {coars_g,coars_g,coars_g};

    size_t tot = coars_g*coars_g*coars_g;
    size_t correct_result = 0;
    size_t fact = 1;

    for (size_t i = 0 ; i <  n_lvl ; i++)
    {
        correct_result += tot*fact;
        fact *= 8;
    }

    amr_g.initLevels(n_lvl,g_sz);

    size_t total_all_level = 0;


    for (size_t i = 0 ; i < amr_g.getNLvl() ; i++)
    {
        // Fill the AMR with something

        size_t count = 0;

        auto it = amr_g.getGridGhostIterator(i);

        while (it.isNext())
        {
            auto key = it.get_dist();
            auto gkey = it.get();
            auto akey = amr_g.getAMRKey(i,key);

            amr_g.template insert<0>(akey) = gkey.get(0);
            amr_g.template insert<1>(akey) = gkey.get(1);
            amr_g.template insert<2>(akey) = gkey.get(2);

            count++;

            ++it;
        }

        size_t tot = (amr_g.getGridInfoVoid(i).size(0) + 2)*
                     (amr_g.getGridInfoVoid(i).size(1) + 2)*
                     (amr_g.getGridInfoVoid(i).size(2) + 2);

        auto & v_cl = create_vcluster();

        if (v_cl.size() == 1)
        {
            v_cl.sum(count);
            v_cl.execute();

            BOOST_REQUIRE_EQUAL(tot,count);
        }

        size_t amr_cnt = 0;
        bool match = true;
        auto it2 = amr_g.getDomainGhostIterator(i);

        while (it2.isNext())
        {
            auto key = it2.get();
            auto key_g = it2.getGKey(key);
            match &= amr_g.template get<0>(i,key) == key_g.get(0);

            total_all_level++;
            amr_cnt++;

            ++it2;
        }

        BOOST_REQUIRE_EQUAL(amr_cnt,count);
        BOOST_REQUIRE_EQUAL(match,true);
    }

    // test the total iterator

    size_t gtot_count = 0;
    auto tot_it = amr_g.getDomainGhostIterator();

    while (tot_it.isNext())
    {
        gtot_count++;

        ++tot_it;
    }

    BOOST_REQUIRE_EQUAL(gtot_count,total_all_level);
}

template<typename grid_amr>
void Test3D_ghost_put(grid_amr & g_dist_amr, long int k)
{
    size_t sz[3] = {(size_t)k,(size_t)k,(size_t)k};

    g_dist_amr.initLevels(4,sz);

    // Grid sm
    grid_sm<3,void> info(sz);

    size_t count = 0;

    for (size_t i = 0 ; i < g_dist_amr.getNLvl() ; i++)
    {
        auto dom = g_dist_amr.getGridIterator(i);

        while (dom.isNext())
        {
            auto key = dom.get_dist();

            g_dist_amr.template insert<0>(i,key) = -6.0;

            // Count the points
            count++;

            ++dom;
        }
    }

    // Set to zero the full grid

    {
    auto dom = g_dist_amr.getDomainIterator();

    while (dom.isNext())
    {
        auto key = dom.get();

        g_dist_amr.template insert<0>(key.moveSpace(0,1)) += 1.0;
        g_dist_amr.template insert<0>(key.moveSpace(0,-1)) += 1.0;
        g_dist_amr.template insert<0>(key.moveSpace(1,1)) += 1.0;
        g_dist_amr.template insert<0>(key.moveSpace(1,-1)) += 1.0;
        g_dist_amr.template insert<0>(key.moveSpace(2,1)) += 1.0;
        g_dist_amr.template insert<0>(key.moveSpace(2,-1)) += 1.0;

        ++dom;
    }
    }

    bool correct = true;

    // Domain + Ghost iterator
    auto dom_gi = g_dist_amr.getDomainIterator();

    while (dom_gi.isNext())
    {
        auto key = dom_gi.get();

        correct &= (g_dist_amr.template get<0>(key) == 0);

        ++dom_gi;
    }

    g_dist_amr.template ghost_put<add_,0>();

    if (count != 0)
    {BOOST_REQUIRE_EQUAL(correct, false);}

    // sync the ghosts
    g_dist_amr.template ghost_get<0>();

    correct = true;

    // Domain + Ghost iterator
    auto dom_gi2 = g_dist_amr.getDomainIterator();

    while (dom_gi2.isNext())
    {
        auto key = dom_gi2.get();

        correct &= (g_dist_amr.template get<0>(key) == 0);

        ++dom_gi2;
    }

    BOOST_REQUIRE_EQUAL(correct, true);
}




BOOST_AUTO_TEST_CASE( grid_dist_amr_get_child_test_nop )
{
    // Domain
    Box<3,float> domain3({0.0,0.0,0.0},{1.0,1.0,1.0});

    long int k = 16*16*16*create_vcluster().getProcessingUnits();
    k = std::pow(k, 1/3.);

    Ghost<3,long int> g(1);
    grid_dist_amr<3,float,aggregate<long int,long int,long int, long int[4]>> amr_g(domain3,g);

    Test3D_amr_child_parent_get_no_periodic(amr_g,domain3,k,4);
}

BOOST_AUTO_TEST_CASE( grid_dist_amr_get_child_test_p )
{
    // Domain
    Box<3,float> domain3({0.0,0.0,0.0},{1.0,1.0,1.0});

    long int k = 16*16*16*create_vcluster().getProcessingUnits();
    k = std::pow(k, 1/3.);

    periodicity<3> bc = {PERIODIC,PERIODIC,PERIODIC};

    Ghost<3,long int> g(1);
    grid_dist_amr<3,float,aggregate<long int,long int,long int>> amr_g(domain3,g,bc);

    Test3D_amr_child_parent_get_periodic(amr_g,domain3,k,4);
}

BOOST_AUTO_TEST_CASE( grid_dist_amr_test )
{
    // Domain
    Box<3,float> domain3({0.0,0.0,0.0},{1.0,1.0,1.0});

    long int k = 16*16*16*create_vcluster().getProcessingUnits();
    k = std::pow(k, 1/3.);

    Ghost<3,long int> g(0);
    grid_dist_amr<3,float,aggregate<float,float[3],int[3]>> amr_g(domain3,g);

    Test3D_amr_create_levels(amr_g,domain3,k,4);

    sgrid_dist_amr<3,float,aggregate<float,float[3],int[3]>> amr_g2(domain3,g);

    Test3D_amr_create_levels(amr_g2,domain3,k,4);
}

BOOST_AUTO_TEST_CASE( grid_dist_amr_ghost_it_test )
{
    // Domain
    Box<3,float> domain3({0.0,0.0,0.0},{1.0,1.0,1.0});

    long int k = 16*16*16*create_vcluster().getProcessingUnits();
    k = std::pow(k, 1/3.);

    Ghost<3,long int> g(1);
    grid_dist_amr<3,float,aggregate<long int,long int,long int>> amr_g(domain3,g);

    Test3D_amr_ghost_it(amr_g,domain3,k,4);

    sgrid_dist_amr<3,float,aggregate<long int,long int,long int>> amr_g2(domain3,g);

    Test3D_amr_ghost_it(amr_g2,domain3,k,4);

    for (size_t i = 0 ; i < amr_g2.getNLvl() ; i++)
    {BOOST_REQUIRE(amr_g2.size_inserted(i) != 0ul);}

    amr_g2.clear();

    for (size_t i = 0 ; i < amr_g2.getNLvl() ; i++)
    {BOOST_REQUIRE_EQUAL(amr_g2.size_inserted(i),0ul);}
}

BOOST_AUTO_TEST_CASE( grid_dist_amr_domain_ghost_it_test )
{
    // Domain
    Box<3,float> domain3({0.0,0.0,0.0},{1.0,1.0,1.0});

    long int k = 16*16*16*create_vcluster().getProcessingUnits();
    k = std::pow(k, 1/3.);

    Ghost<3,long int> g(1);
    grid_dist_amr<3,float,aggregate<long int,long int,long int>> amr_g(domain3,g);

    Test3D_amr_domain_ghost_it(amr_g,domain3,k,4);

    sgrid_dist_amr<3,float,aggregate<long int,long int,long int>> amr_g2(domain3,g);

    Test3D_amr_domain_ghost_it(amr_g2,domain3,k,4);

    for (size_t i = 0 ; i < amr_g2.getNLvl() ; i++)
    {BOOST_REQUIRE(amr_g2.size_inserted(i) != 0ul);}

    amr_g2.clear();

    for (size_t i = 0 ; i < amr_g2.getNLvl() ; i++)
    {BOOST_REQUIRE_EQUAL(amr_g2.size_inserted(i),0ul);}
}

BOOST_AUTO_TEST_CASE( grid_dist_amr_get_child_test_low_res )
{
    // Domain
    Box<3,float> domain3({0.0,0.0,0.0},{1.0,1.0,1.0});

    long int k = 2;

    Ghost<3,long int> g(1);
    grid_dist_amr<3,float,aggregate<long int,long int,long int,long int[4]>> amr_g(domain3,g);

    Test3D_amr_child_parent_get_no_periodic(amr_g,domain3,k,4);

    sgrid_dist_amr<3,float,aggregate<long int,long int,long int, long int [4]>> amr_g2(domain3,g);

    Test3D_amr_child_parent_get_no_periodic(amr_g2,domain3,k,4);
}

BOOST_AUTO_TEST_CASE( grid_dist_amr_test_background_value )
{
    // Domain
    Box<3,float> domain3({0.0,0.0,0.0},{1.0,1.0,1.0});

    Ghost<3,long int> g(1);

    sgrid_dist_amr<3,float,aggregate<long int,long int,long int>> amr_g2(domain3,g);

    size_t g_sz[3] = {4,4,4};

    amr_g2.initLevels(4,g_sz);

    aggregate<long int,long int,long int> bck;
    bck.get<0>() = -57;
    bck.get<1>() = -90;
    bck.get<2>() = -123;

    amr_g2.setBackgroundValue(bck);

    // Get a non existent point to check that
    // the background value work

    grid_dist_key_dx<3> key(0,grid_key_dx<3>({0,0,0}));
    long int bck0 = amr_g2.get<0>(2,key);
    BOOST_REQUIRE_EQUAL(bck0,-57);
    long int bck1 = amr_g2.get<1>(2,key);
    BOOST_REQUIRE_EQUAL(bck1,-90);
    long int bck2 = amr_g2.get<2>(2,key);
    BOOST_REQUIRE_EQUAL(bck2,-123);

    // Now we insert that point and we check the subsequent point
    amr_g2.insert<0>(2,key) = 5;

    grid_dist_key_dx<3> key2(0,grid_key_dx<3>({1,0,0}));
    bck0 = amr_g2.get<0>(2,key2);
    BOOST_REQUIRE_EQUAL(bck0,-57);
    bck1 = amr_g2.get<1>(2,key2);
    BOOST_REQUIRE_EQUAL(bck1,-90);
    bck2 = amr_g2.get<2>(2,key2);
    BOOST_REQUIRE_EQUAL(bck2,-123);

    auto & g_dist_lvl2 = amr_g2.getDistGrid(2);
    g_dist_lvl2.get_loc_grid(0).internal_clear_cache();

    bck0 = amr_g2.get<0>(2,key2);
    BOOST_REQUIRE_EQUAL(bck0,-57);
    bck1 = amr_g2.get<1>(2,key2);
    BOOST_REQUIRE_EQUAL(bck1,-90);
    bck2 = amr_g2.get<2>(2,key2);
    BOOST_REQUIRE_EQUAL(bck2,-123);

}

BOOST_AUTO_TEST_CASE( grid_dist_amr_get_domain_ghost_check )
{
    // Test grid periodic

    Box<3,float> domain({0.0,0.0,0.0},{1.0,1.0,1.0});

    Vcluster<> & v_cl = create_vcluster();

    if ( v_cl.getProcessingUnits() > 32 )
    {return;}

    long int k = 13;

    BOOST_TEST_CHECKPOINT( "Testing grid periodic k<=" << k );

    // Ghost
    Ghost<3,long int> g(1);

    // periodicity
    periodicity<3> pr = {{PERIODIC,PERIODIC,PERIODIC}};

    // Distributed grid with id decomposition
    grid_dist_amr<3, float, aggregate<long int>> g_dist(domain,g,pr);

    Test3D_ghost_put(g_dist,k);

    // Distributed grid with id decomposition
    sgrid_dist_amr<3, float, aggregate<long int>> sg_dist(domain,g,pr);

    Test3D_ghost_put(sg_dist,k);
}

BOOST_AUTO_TEST_CASE( grid_dist_amr_ghost_put_create )
{
    // Test grid periodic

    Box<3,float> domain({0.0,0.0,0.0},{1.0,1.0,1.0});

    Vcluster<> & v_cl = create_vcluster();

    if ( v_cl.getProcessingUnits() > 32 )
    {return;}

    long int k = 13;

    BOOST_TEST_CHECKPOINT( "Testing grid periodic k<=" << k );

    // Ghost
    Ghost<3,long int> g(1);

    // periodicity
    periodicity<3> pr = {{PERIODIC,PERIODIC,PERIODIC}};

    // Distributed grid with id decomposition
    grid_dist_amr<3, float, aggregate<long int>> g_dist(domain,g,pr);

    Test3D_ghost_put(g_dist,k);

    // Distributed grid with id decomposition
    sgrid_dist_amr<3, float, aggregate<long int>> sg_dist(domain,g,pr);

    Test3D_ghost_put(sg_dist,k);
}

BOOST_AUTO_TEST_SUITE_END()