grid_sm_unit_tests.hpp

/*
 * grid_sm_test.hpp
 *
 *  Created on: Dec 14, 2015
 *      Author: i-bird
 */

#ifndef OPENFPM_DATA_SRC_GRID_GRID_SM_UNIT_TESTS_HPP_
#define OPENFPM_DATA_SRC_GRID_GRID_SM_UNIT_TESTS_HPP_

#include "iterators/grid_key_dx_iterator_sub_bc.hpp"
#include "grid_key_dx_iterator_hilbert.hpp"

BOOST_AUTO_TEST_SUITE( grid_sm_test )


BOOST_AUTO_TEST_CASE( grid_sm_linearization )
{
    const grid_key_dx<3> key1(1,2,3);
    const grid_key_dx<3> zero(0,0,0);
    const grid_key_dx<3> seven(7,7,7);

    const comb<3> c({(char)1,(char)0,(char)-1});
    size_t sz[3] = {8,8,8};

    grid_sm<3,int> gs(sz);
    size_t bc[] = {NON_PERIODIC,NON_PERIODIC,NON_PERIODIC};

    long int lin = gs.LinId<CheckExistence>(key1,c.getComb(),bc);
    BOOST_REQUIRE_EQUAL(lin,146);
    lin = gs.LinId<CheckExistence>(zero,c.getComb(),bc);
    BOOST_REQUIRE_EQUAL(lin,-1);
    lin = gs.LinId<CheckExistence>(seven,c.getComb(),bc);
    BOOST_REQUIRE_EQUAL(lin,-1);

    for (size_t i = 0 ; i < 3 ; i++)
        bc[i] = PERIODIC;

    lin = gs.LinId<CheckExistence>(key1,c.getComb(),bc);
    BOOST_REQUIRE_EQUAL(lin,146);
    lin = gs.LinId<CheckExistence>(zero,c.getComb(),bc);
    BOOST_REQUIRE_EQUAL(lin,71);
    lin = gs.LinId<CheckExistence>(seven,c.getComb(),bc);
    BOOST_REQUIRE_EQUAL(lin,62);
}


BOOST_AUTO_TEST_CASE( grid_iterator_sub_p )
{
    const grid_key_dx<3> key1(4,4,4);
    const grid_key_dx<3> key2(-1,-1,-1);
    const grid_key_dx<3> key3(9,9,9);
    size_t sz[3] = {8,8,8};

    grid_sm<3,int> gs(sz);

    grid_key_dx_iterator_sub_bc<3,no_stencil> it(gs,key2,key1,{PERIODIC,PERIODIC,PERIODIC});

    size_t cnt = 0;

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

        for (size_t i = 0 ; i < 3 ; i++)
        {
            BOOST_REQUIRE_EQUAL(key.get(i) >= (long int)0,true);
            BOOST_REQUIRE_EQUAL(key.get(i) < (long int)sz[i],true);
        }

        cnt++;

        ++it;
    }

    BOOST_REQUIRE_EQUAL(cnt,216ul);

    grid_key_dx_iterator_sub_bc<3,no_stencil> it2(gs,key2,key3,{PERIODIC,PERIODIC,PERIODIC});

    cnt = 0;

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

        for (size_t i = 0 ; i < 3 ; i++)
        {
            BOOST_REQUIRE_EQUAL(key.get(i) >= (long int)0,true);
            BOOST_REQUIRE_EQUAL(key.get(i) < (long int)sz[i],true);
        }

        cnt++;

        ++it2;
    }

    BOOST_REQUIRE_EQUAL(cnt,1331ul);

    cnt = 0;

    const grid_key_dx<3> key4(0,-1,0);
    const grid_key_dx<3> key5(2,2,2);

    grid_key_dx_iterator_sub_bc<3,no_stencil> it3(gs,key4,key5,{NON_PERIODIC,PERIODIC,NON_PERIODIC});

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

        for (size_t i = 0 ; i < 3 ; i++)
        {
            BOOST_REQUIRE_EQUAL(key.get(i) >= (long int)0,true);
            BOOST_REQUIRE_EQUAL(key.get(i) < (long int)sz[i],true);
        }

        cnt++;

        ++it3;
    }

    BOOST_REQUIRE_EQUAL(cnt,36ul);

    // bc non periodic with out-of-bound

    grid_key_dx_iterator_sub_bc<3,no_stencil,grid_sm<3,void>,do_not_print_warning_on_adjustment<3,grid_sm<3,void>>> it4(gs,key4,key5,{NON_PERIODIC,NON_PERIODIC,NON_PERIODIC});

    cnt = 0;

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

        for (size_t i = 0 ; i < 3 ; i++)
        {
            BOOST_REQUIRE_EQUAL(key.get(i) >= (long int)0,true);
            BOOST_REQUIRE_EQUAL(key.get(i) < (long int)sz[i],true);
        }

        cnt++;

        ++it4;
    }

    BOOST_REQUIRE_EQUAL(cnt,27ul);

    // case with no key

    const grid_key_dx<3> key6(-1,-1,-1);
    const grid_key_dx<3> key7(-1,-1,8);

    grid_key_dx_iterator_sub_bc<3,no_stencil,grid_sm<3,void>,do_not_print_warning_on_adjustment<3,grid_sm<3,void>>> it5(gs,key6,key7,{NON_PERIODIC,NON_PERIODIC,NON_PERIODIC});

    cnt = 0;

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

        for (size_t i = 0 ; i < 3 ; i++)
        {
            BOOST_REQUIRE_EQUAL(key.get(i) >= 0,true);
            BOOST_REQUIRE_EQUAL(key.get(i) < (long int)sz[i],true);
        }

        cnt++;

        ++it5;
    }

    BOOST_REQUIRE_EQUAL(cnt,0ul);
}

BOOST_AUTO_TEST_CASE( grid_key_dx_iterator_hilbert_test )
{
    // 2D test
    {
        size_t count = 0;

        //An order of a hilberts curve
        int32_t m = 2;

        grid_key_dx<2> start (0,0);

        //Create an iterator
        grid_key_dx_iterator_hilbert<2> h_it(m);

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

            ++h_it;
        }

        //(2^m)^dim
        BOOST_REQUIRE_EQUAL(count, (size_t)16);

        h_it.reset();

        bool val = h_it.get() == start;

        BOOST_REQUIRE_EQUAL(val,true);
    }

    // 3D test
    {
        size_t count = 0;

        //An order of a hilberts curve
        int32_t m = 2;

        grid_key_dx<3> start (0,0,0);

        //Create an iterator
        grid_key_dx_iterator_hilbert<3> h_it(m);

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

            ++h_it;
        }

        //(2^m)^dim
        BOOST_REQUIRE_EQUAL(count, (size_t)64);

        h_it.reset();

        bool val = h_it.get() == start;

        BOOST_REQUIRE_EQUAL(val,true);
    }
}


BOOST_AUTO_TEST_CASE( grid_iterator_sp_test )
{
    size_t sz[3] = {16,16,16};

    grid_cpu<3, Point_test<float> > c3(sz);
    c3.setMemory();

    grid_key_dx<3> start(2,2,2);
    grid_key_dx<3> stop(10,10,10);

    auto info = c3.getGrid();

    grid_key_dx_iterator_sp<3> it(info,info.LinId(start),info.LinId(stop));

    size_t count = 0;

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

        ++it;
    }

    BOOST_REQUIRE_EQUAL(count,2185ul);
}

BOOST_AUTO_TEST_CASE( grid_iterator_test_use)
{
    {
    size_t count = 0;

    // Subdivisions
    size_t div[3] = {16,16,16};

    // grid info
    grid_sm<3,void> g_info(div);

    // Create a grid iterator
    grid_key_dx_iterator<3> g_it(g_info);

    // Iterate on all the elements
    while (g_it.isNext())
    {
        grid_key_dx<3> key = g_it.get();

        // set the grid key to zero without any reason ( to avoid warning compilations )
        key.zero();

        count++;

        ++g_it;
    }

    BOOST_REQUIRE_EQUAL(count, (size_t)16*16*16);
    }

    {
    size_t count = 0;
    // Iterate only on the internal elements

    // Subdivisions
    size_t div[3] = {16,16,16};

    // grid info
    grid_sm<3,void> g_info(div);

    grid_key_dx<3> start(1,1,1);
    grid_key_dx<3> stop(14,14,14);

    // Create a grid iterator (start and stop included)
    grid_key_dx_iterator_sub<3> g_it(g_info,start,stop);

    // Iterate on all the elements
    while (g_it.isNext())
    {
        grid_key_dx<3> key = g_it.get();

        // set the grid key to zero without any reason ( to avoid warning compilations )
        key.zero();

        count++;

        ++g_it;
    }

    BOOST_REQUIRE_EQUAL(count, (size_t)14*14*14);


    // reset the iterator and check that it start from gk_start
    g_it.reset();

    bool val = g_it.get() == start;

    BOOST_REQUIRE_EQUAL(val,true);
    }
}

BOOST_AUTO_TEST_CASE( grid_sub_iterator_test )
{
    // Subdivisions
    size_t count = 0;
    typedef Point_test<float> p;

    size_t div[3] = {16,16,16};

    // grid info
    grid_cpu<3,Point_test<float>> g(div);
    g.setMemory();

    grid_key_dx<3> start(1,1,1);
    grid_key_dx<3> stop(14,14,14);

    // Create a grid iterator (start and stop included)
    auto g_it =  g.getIterator(start,stop);

    // Iterate on all the elements
    while (g_it.isNext())
    {
        grid_key_dx<3> key = g_it.get();

        // set the x value
        g.template get<p::x>(key) = 1.0;

        count++;

        ++g_it;
    }

    BOOST_REQUIRE_EQUAL(count, (size_t)14*14*14);

}

BOOST_AUTO_TEST_SUITE_END()


#endif /* OPENFPM_DATA_SRC_GRID_GRID_SM_UNIT_TESTS_HPP_ */