CellListIterator_test.hpp

/*
 * CellListIterator_test.hpp
 *
 *  Created on: May 7, 2016
 *      Author: Yaroslav Zaluzhnyi
 */

#ifndef OPENFPM_DATA_SRC_NN_CELLLIST_CELLLISTITERATOR_TEST_HPP_
#define OPENFPM_DATA_SRC_NN_CELLLIST_CELLLISTITERATOR_TEST_HPP_

#include "NN/CellList/CellListIterator.hpp"
#include "NN/CellList/ParticleIt_Cells.hpp"
#include "NN/CellList/ParticleItCRS_Cells.hpp"

#ifdef OPENFPM_PDATA
#include "VCluster/VCluster.hpp"
#endif


template<unsigned int dim, typename CellList> void FillCellList(size_t k, CellList & NN)
{
    float pos[dim];

    //Fill with particles
    for (size_t i = 0; i < k; i++)
    {
        for (size_t j = 0; j < dim; j++)
        {
            pos[j] = rand()/double(RAND_MAX);
        }
        NN.add(pos,i);
    }
}

#include "CellListFast_gen.hpp"

BOOST_AUTO_TEST_SUITE( celllist_gen_and_iterator_tests )

BOOST_AUTO_TEST_CASE( celllist_lin_and_iterator_test )
{

    const size_t dim = 3;

    size_t div[dim] = {4,5,6};

    //Number of particles
    size_t k = 300;


    Box<dim,float> box;

    for (size_t i = 0; i < dim; i++)
    {
        box.setLow(i,0.0);
        box.setHigh(i,1.0);
    }

    // Initialize a cell list
    CellList_gen<dim,float,Process_keys_lin> NN;

    NN.Initialize(box,div,1);
    NN.set_gm(k*0.9);

    float pos[dim];

    //Fill with particles
    for (size_t i = 0; i < k*0.9; i++)
    {
        for (size_t j = 0; j < dim; j++)
        {
            pos[j] = rand()/double(RAND_MAX);
        }
        NN.add(pos,i);
    }

    //Test the iterator
    auto it_cl = NN.getIterator();

    size_t count = 0;

    while (it_cl.isNext())
    {
        auto p_key = it_cl.get();

        BOOST_REQUIRE(p_key < NN.get_gm());

        count++;
        ++it_cl;
    }

    BOOST_REQUIRE_EQUAL(count,NN.get_gm());
}

BOOST_AUTO_TEST_CASE( celllist_hilb_and_iterator_test )
{
#ifdef OPENFPM_PDATA

    auto & v_cl = create_vcluster();

    std::string c2 = std::string("openfpm_data/test_data/NN_hilb_keys");

#else

    std::string c2 = std::string("test_data/NN_hilb_keys");

#endif


    const size_t dim = 3;

    size_t div[dim] = {4,5,6};

    //Number of particles
    size_t k = 300;


    Box<dim,float> box;

    for (size_t i = 0; i < dim; i++)
    {
        box.setLow(i,0.0);
        box.setHigh(i,1.0);
    }

    // Initialize a cell list
    CellList_gen<dim,float,Process_keys_hilb> NN;

    NN.Initialize(box,div,1);
    NN.set_gm(k*0.9);

    FillCellList<dim>((size_t)k*0.9,NN);


    //Test the iterator
    auto it_cl = NN.getIterator();

    size_t count = 0;

    while (it_cl.isNext())
    {
        auto p_key = it_cl.get();

        BOOST_REQUIRE(p_key < NN.get_gm());

        count++;
        ++it_cl;
    }

    BOOST_REQUIRE_EQUAL(count,NN.get_gm());

    // Load previous results and check equality

    openfpm::vector<size_t> keys_old;

    keys_old.load(c2);

    for (size_t i = 0; i < keys_old.size(); i++)
    {
        size_t a1 = keys_old.get(i);
        size_t a2 = NN.getCellSFC().getKeys().get(i);

        BOOST_REQUIRE_EQUAL(a1,a2);
    }

    size_t s1 = keys_old.size();
    size_t s2 = NN.getCellSFC().getKeys().size();

    BOOST_REQUIRE_EQUAL(s1,s2);
}

BOOST_AUTO_TEST_CASE( ParticleItCRS_Cells_iterator )
{

    const size_t dim = 3;

    size_t div[dim] = {4,5,6};
    size_t div_p[dim] = {6,7,8};

    grid_sm<3,void> gs(div_p);

    //Number of particles
    size_t k = 300;


    Box<dim,float> box;

    for (size_t i = 0; i < dim; i++)
    {
        box.setLow(i,0.0);
        box.setHigh(i,1.0);
    }

    // Initialize a cell list
    CellList<dim,float,Mem_fast<>,shift<dim,float>> NN;

    NN.Initialize(box,div,1);

    FillCellList<dim>(k,NN);

    float pos[dim];

    grid_key_dx<3> start(0,0,0);
    grid_key_dx<3> stop(div[2]-1+2*NN.getPadding(2),div[1]-1+2*NN.getPadding(1),div[0]-1+2*NN.getPadding(0));

    openfpm::vector<size_t> dom;
    openfpm::vector<subsub_lin<dim>> anom;

    // No anomalous cells + all domain cells
    grid_key_dx_iterator_sub<dim> it(gs,start,stop);

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

        dom.add(gs.LinId(key));

        ++it;
    }

    typedef openfpm::vector<Point<3,float>> vector_type;

    //Test the iterator
    ParticleItCRS_Cells<dim,CellList<dim,float,Mem_fast<>,shift<dim,float>,vector_type>,vector_type> it_cl(NN,dom,anom,NN.getNNc_sym());

    size_t count = 0;

    while (it_cl.isNext())
    {
        count++;
        ++it_cl;
    }

    BOOST_REQUIRE_EQUAL(count,k);


    NN.clear();

    grid_key_dx<3> start2(1,1,1);
    grid_key_dx<3> stop2(div[2]-2+2*NN.getPadding(2),div[1]-2+2*NN.getPadding(1),div[0]-2+2*NN.getPadding(0));

    //Fill with particles
    for (size_t i = 0; i < k; i++)
    {
        pos[0] = 0.999*rand()/double(RAND_MAX) + 0.0001;
        pos[1] = 0.999*rand()/double(RAND_MAX) + 0.0001;
        pos[2] = 0.999*rand()/double(RAND_MAX) + 0.0001;

        NN.add(pos,i);
    }

    dom.clear();

    bool alternate = false;

    // No anomalous cells + all domain cells
    grid_key_dx_iterator_sub<dim> it2(gs,start,stop);

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

        if (alternate == false)
        {
            dom.add(gs.LinId(key));
            alternate = true;
        }
        else
        {
            anom.add();
            anom.last().subsub = gs.LinId(key);
            alternate = false;
        }

        ++it2;
    }

    typedef openfpm::vector<Point<dim,float>> vector_type;

    ParticleItCRS_Cells<dim,CellList<dim,float,Mem_fast<>,shift<dim,float>,vector_type>,vector_type> it_cl2(NN,dom,anom,NN.getNNc_sym());

    count = 0;

    while (it_cl2.isNext())
    {
        count++;
        ++it_cl2;
    }

    BOOST_REQUIRE_EQUAL(count,k);
}

BOOST_AUTO_TEST_CASE( ParticleIt_Cells_NN_iterator )
{

    const size_t dim = 3;

    size_t div[dim] = {4,5,6};
    size_t div_p[dim] = {6,7,8};

    grid_sm<3,void> gs2(div);
    grid_sm<3,void> gs(div_p);


    Box<dim,float> box;

    for (size_t i = 0; i < dim; i++)
    {
        box.setLow(i,0.0);
        box.setHigh(i,1.0);
    }

    // Initialize a cell list
    CellList<dim,float,Mem_fast<>,shift<dim,float>> NN;

    NN.Initialize(box,div,1);

    grid_key_dx_iterator<3> it(gs2);

    float spacing[dim];
    float middle[dim];
    for (size_t i = 0 ; i < dim ; i++)
    {
        spacing[i] = box.getHigh(i) / div[i];
        middle[i] = spacing[i]/2;
    }

    size_t cnt = 0;

    //Fill with particles
    openfpm::vector<Point<dim,float>> vp;
    while (it.isNext())
    {
        auto key = it.get();

        Point<3,float> p;

        p.get(0) = key.get(0)*spacing[0] + middle[0];
        p.get(1) = key.get(1)*spacing[1] + middle[1];
        p.get(2) = key.get(2)*spacing[2] + middle[2];

        vp.add(p);

        NN.add(p,cnt);
        cnt++;

        ++it;
    }

    grid_key_dx<3> start2(2,2,2);
    grid_key_dx<3> stop2(div[2]-3+2*NN.getPadding(2),div[1]-3+2*NN.getPadding(1),div[0]-3+2*NN.getPadding(0));

    openfpm::vector<size_t> dom;
    openfpm::vector<subsub_lin<dim>> anom;

    // No anomalous cells + all domain cells
    grid_key_dx_iterator_sub<dim> it2(gs,start2,stop2);

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

        if (alternate == false)
        {
            dom.add(gs.LinId(key));
            alternate = true;
        }
        else
        {
            anom.add();
            anom.last().subsub = gs.LinId(key);

            for(size_t j = 0 ; j < openfpm::math::pow(3,dim)/2+1 ; j++)
            {anom.last().NN_subsub.add(NN.getNNc_sym()[j]);}

            alternate = false;
        }

        ++it2;
    }

    typedef openfpm::vector<Point<dim,float>> vector_type;

    //Test the iterator
    ParticleItCRS_Cells<dim,CellList<dim,float,Mem_fast<>,shift<dim,float>,vector_type>,vector_type> it_cl(NN,dom,anom,NN.getNNc_sym());

    size_t count = 0;

    while (it_cl.isNext())
    {
        auto NN_it = it_cl.getNNIteratorCSR(vp);

        size_t size_NN = 0;

        while (NN_it.isNext())
        {
            size_NN++;

            ++NN_it;
        }

        BOOST_REQUIRE_EQUAL(size_NN,14ul);

        count++;
        ++it_cl;
    }

    BOOST_REQUIRE_EQUAL(count,(div[0]-2)*(div[1]-2)*(div[2]-2));
}

BOOST_AUTO_TEST_CASE( ParticleIt_Cells_iterator )
{

    const size_t dim = 3;

    size_t div[dim] = {4,5,6};
    size_t div_p[dim] = {6,7,8};

    grid_sm<3,void> gs(div_p);

    //Number of particles
    size_t k = 300;


    Box<dim,float> box;

    for (size_t i = 0; i < dim; i++)
    {
        box.setLow(i,0.0);
        box.setHigh(i,1.0);
    }

    // Initialize a cell list
    CellList<dim,float,Mem_fast<>,shift<dim,float>> NN;

    NN.Initialize(box,div,1);

    FillCellList<dim>(k,NN);

    grid_key_dx<3> start(0,0,0);
    grid_key_dx<3> stop(div[2]-1+2*NN.getPadding(2),div[1]-1+2*NN.getPadding(1),div[0]-1+2*NN.getPadding(0));


    // No anomalous cells + all domain cells
    grid_key_dx_iterator_sub<dim> it(gs,start,stop);

    openfpm::vector<size_t> dom;

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

        dom.add(gs.LinId(key));

        ++it;
    }

    //Test the iterator
    ParticleIt_Cells<dim,CellList<dim,float,Mem_fast<>,shift<dim,float>>> it_cl(NN,dom,290);

    size_t count = 0;

    while (it_cl.isNext())
    {
        auto i = it_cl.get();

        count++;
        ++it_cl;
    }

    BOOST_REQUIRE_EQUAL(count,290ul);
}

BOOST_AUTO_TEST_SUITE_END()

#endif /* OPENFPM_DATA_SRC_NN_CELLLIST_CELLLISTITERATOR_TEST_HPP_ */