se_class3_vector_unit_tests.hpp

/*
 * se_class3_vector_unit_tests.hpp
 *
 *  Created on: Feb 12, 2017
 *      Author: i-bird
 */
 
#ifndef SRC_VECTOR_SE_CLASS3_VECTOR_UNIT_TESTS_HPP_
#define SRC_VECTOR_SE_CLASS3_VECTOR_UNIT_TESTS_HPP_
 
#ifdef SE_CLASS3
 
BOOST_AUTO_TEST_SUITE( vector_dist_class3 )
 
BOOST_AUTO_TEST_CASE( vector_dist_class3_check )
{
    Box<2,float> domain({0.0,0.0},{1.0,1.0});
 
    // Here we define the boundary conditions of our problem
    size_t bc[2]={PERIODIC,PERIODIC};
 
    // extended boundary around the domain, and the processor domain
    Ghost<2,float> g(0.05);
 
    vector_dist<2,float,aggregate<float,float[3],openfpm::vector<double>>> vd(4096,domain,bc,g);
 
    bool error = false;
 
    {
    auto it = vd.getDomainIterator();
    try
    {
        while (it.isNext())
        {
            auto p = it.get();
 
            // Read something not initialized ERROR
            Point<2,float> a = vd.getPosRead(p);
 
            // Suppress compiler error
            a.get(0) = 0;
 
            ++it;
        }
    }
    catch (std::exception & e)
    {
        error = true;
    }
    }
 
    BOOST_REQUIRE_EQUAL(error,true);
    error = false;
 
    // Initialize
 
    {
    auto it = vd.getDomainIterator();
 
    while (it.isNext())
    {
        auto p = it.get();
 
        // Read something not initialized ERROR
        vd.getPosWrite(p)[0] = (double)rand()/RAND_MAX;
        vd.getPosWrite(p)[1] = (double)rand()/RAND_MAX;
 
        ++it;
    }
 
    }
 
    {
    auto it = vd.getDomainIterator();
    try
    {
        while (it.isNext())
        {
            auto p = it.get();
 
            // Now has bee initialized so not error should be reported
            Point<2,float> a = vd.getPosRead(p);
 
            // Suppress compiler error
            a.get(0) = 0;
 
            ++it;
        }
    }
    catch (std::exception & e)
    {
        error = true;
    }
    }
 
    BOOST_REQUIRE_EQUAL(error,false);
    error = false;
 
    // we redistribute the particle
 
    vd.map();
 
    try
    {
        // Error we are getting the cell list from ghost out of sync in position
        vd.getCellList(0.05);
    }
    catch (std::exception & e)
    {
        error = true;
    }
 
    BOOST_REQUIRE_EQUAL(error,true);
    error = false;
 
    try
    {
        // Error we are getting the cell list from ghost out of sync in position
        vd.getVerlet(0.1);
    }
    catch (std::exception & e)
    {
        error = true;
    }
 
    BOOST_REQUIRE_EQUAL(error,true);
    error = false;
 
    try
    {
        // Error we are getting the cell list from ghost out of sync in position
        vd.getCellListSym(0.05);
    }
    catch (std::exception & e)
    {
        error = true;
    }
 
    BOOST_REQUIRE_EQUAL(error,true);
    error = false;
 
    vd.ghost_get<0>();
 
    try
    {
        // OK
        vd.getCellList(0.05);
    }
    catch (std::exception & e)
    {
        error = true;
    }
 
    BOOST_REQUIRE_EQUAL(error,false);
    error = false;
 
    // We make dirty a ghost particle
    vd.template getPropWrite<0>(vd.size_local()) = 0.5;
 
    try
    {
        // Error we are destroying information
        vd.ghost_get<0>();
    }
    catch (std::exception & e)
    {
        error = true;
    }
 
    BOOST_REQUIRE_EQUAL(error,true);
    error = false;
 
    // We make dirty a ghost particle
    vd.template getPropWrite<0>(vd.size_local()) = 0.5;
 
    try
    {
        // Also error we are also destroying information
        vd.ghost_get<1>();
    }
    catch (std::exception & e)
    {
        error = true;
    }
 
    BOOST_REQUIRE_EQUAL(error,true);
    error = false;
 
    // We make dirty a ghost particle
    vd.template getPropWrite<0>(vd.size_local()) = 0.5;
 
    try
    {
        // OK we are not destroying information
        vd.ghost_get<1>(KEEP_PROPERTIES);
    }
    catch (std::exception & e)
    {
        error = true;
    }
 
    BOOST_REQUIRE_EQUAL(error,false);
    error = false;
 
    // We make dirty a ghost particle
    vd.template getPropWrite<0>(vd.size_local()) = 0.5;
 
    try
    {
        // Error we are destroying information
        vd.ghost_get<0>(KEEP_PROPERTIES);
    }
    catch (std::exception & e)
    {
        error = true;
    }
 
    BOOST_REQUIRE_EQUAL(error,true);
    error = false;
 
    try
    {
        // error property 0 has never been initialized
        vd.ghost_put<add_,0>();
    }
    catch (std::exception & e)
    {
        error = true;
    }
 
    BOOST_REQUIRE_EQUAL(error,true);
    error = false;
 
    {
    auto it = vd.getDomainIterator();
    try
    {
        while (it.isNext())
        {
            auto p = it.get();
 
            vd.getPropWrite<0>(p) = 2.0;
 
            ++it;
        }
 
        // OK Property 0 has been initialized
        vd.ghost_put<add_,0>();
    }
    catch (std::exception & e)
    {
        error = true;
    }
    }
 
    BOOST_REQUIRE_EQUAL(error,false);
    error = false;
 
    try
    {
        // OK we are not destroying information
        vd.ghost_get<0>();
    }
    catch (std::exception & e)
    {
        error = true;
    }
 
    BOOST_REQUIRE_EQUAL(error,false);
    error = false;
 
    try
    {
        // Error we are getting the cell list from ghost out of sync in position
        vd.getCellList(0.05);
    }
    catch (std::exception & e)
    {
        error = true;
    }
 
    BOOST_REQUIRE_EQUAL(error,false);
    error = false;
 
    BOOST_REQUIRE_EQUAL(vd.get_se_class3().isGhostSync<1>(),NOTSYNC);
 
    vd.ghost_put<add_,0>();
    vd.ghost_get<1>();
 
    auto NN = vd.getCellList(0.05);
 
    BOOST_REQUIRE_EQUAL(vd.get_se_class3().isGhostSync<1>(),SYNC);
 
 
    auto it = vd.getDomainIterator();
 
    while (it.isNext())
    {
        auto p = it.get();
 
        // we set property 1
        vd.getPropWrite<1>(p)[0] = 1.0;
        vd.getPropWrite<1>(p)[1] = 1.0;
        vd.getPropWrite<1>(p)[2] = 1.0;
 
        ++it;
    }
 
    BOOST_REQUIRE_EQUAL(vd.get_se_class3().isGhostSync<1>(),NOTSYNC);
 
    {
    auto it = vd.getDomainIterator();
    try
    {
        while (it.isNext())
        {
            auto p = it.get();
 
            Point<2,float> xp = vd.getPosRead(p);
 
            auto NNp = NN.template getNNIterator<NO_CHECK>(NN.getCell(xp));
 
            while (NNp.isNext())
            {
                auto q = NNp.get();
 
                // Error ghost is not initialized
                Point<3,float> xq = vd.template getPropRead<1>(q);
 
                xq.get(0) = 0.0;
 
                ++NNp;
            }
 
            ++it;
        }
    }
    catch (std::exception & e)
    {
        error = true;
    }
    }
 
    BOOST_REQUIRE_EQUAL(error,true);
    error = false;
 
    vd.ghost_get<1>();
 
    {
    auto it = vd.getDomainIterator();
 
    while (it.isNext())
    {
        auto p = it.get();
 
        // we set property 1
        vd.getPropWrite<1>(p)[0] = 1.0;
        vd.getPropWrite<1>(p)[1] = 1.0;
        vd.getPropWrite<1>(p)[2] = 1.0;
 
        ++it;
    }
    }
 
    BOOST_REQUIRE_EQUAL(vd.get_se_class3().isGhostSync<1>(),NOTSYNC);
 
    {
    auto it = vd.getDomainIterator();
    try
    {
        while (it.isNext())
        {
            auto p = it.get();
 
            Point<2,float> xp = vd.getPosRead(p);
 
            auto NNp = NN.template getNNIterator<NO_CHECK>(NN.getCell(xp));
 
            while (NNp.isNext())
            {
                auto q = NNp.get();
 
                // Error ghost is not initialized
                Point<3,float> xq = vd.template getPropRead<1>(q);
 
                xq.get(0) = 0.0;
 
                ++NNp;
            }
 
            ++it;
        }
    }
    catch (std::exception & e)
    {
        error = true;
    }
    }
 
    BOOST_REQUIRE_EQUAL(error,true);
    error = false;
 
    vd.ghost_get<1>();
 
    {
    auto it = vd.getDomainIterator();
    try
    {
        while (it.isNext())
        {
            auto p = it.get();
 
            Point<2,float> xp = vd.getPosRead(p);
 
            auto NNp = NN.template getNNIterator<NO_CHECK>(NN.getCell(xp));
 
            while (NNp.isNext())
            {
                auto q = NNp.get();
 
                // Error we forgot ghost_get
                Point<3,float> xq = vd.template getPropRead<1>(q);
 
                xq.get(0) = 0.0;
 
                ++NNp;
            }
 
            ++it;
        }
    }
    catch (std::exception & e)
    {
        error = true;
    }
    }
 
    BOOST_REQUIRE_EQUAL(error,false);
}
 
 
 
 
 
BOOST_AUTO_TEST_CASE( vector_dist_class3_check_add )
{
    Box<2,float> domain({0.0,0.0},{1.0,1.0});
 
    // Here we define the boundary conditions of our problem
    size_t bc[2]={PERIODIC,PERIODIC};
 
    // extended boundary around the domain, and the processor domain
    Ghost<2,float> g(0.05);
 
    vector_dist<2,float,aggregate<float,float[3],openfpm::vector<double>>> vd(0,domain,bc,g);
 
    bool error = false;
 
    // Initialize
 
    {
    for (size_t i = 0 ; i < 1200 ; i++)
    {
        vd.add();
 
        // Read something not initialized ERROR
        vd.getLastPos()[0] = (double)rand()/RAND_MAX;
        vd.getLastPos()[1] = (double)rand()/RAND_MAX;
    }
    }
 
    {
    auto it = vd.getDomainIterator();
    try
    {
        while (it.isNext())
        {
            auto p = it.get();
 
            // Now has bee initialized so not error should be reported
            Point<2,float> a = vd.getPosRead(p);
 
            //Suppress warnings
            a.get(0) = 0.0;
 
            ++it;
        }
    }
    catch (std::exception & e)
    {
        error = true;
    }
    }
 
    BOOST_REQUIRE_EQUAL(error,true);
    error = false;
 
    vd.map();
 
    {
    auto it = vd.getDomainIterator();
    try
    {
        while (it.isNext())
        {
            auto p = it.get();
 
            // Now has bee initialized so not error should be reported
            float a = vd.getPropRead<0>(p);
 
            // Suppress warnings
            a = 0;
            a++;
 
            ++it;
        }
    }
    catch (std::exception & e)
    {
        error = true;
    }
    }
 
    BOOST_REQUIRE_EQUAL(error,true);
}
 
#if defined(CHECKFOR_POSNAN) && defined(CHECKFOR_PROPNAN) && defined(CHECKFOR_POSINF) && defined(CHECKFOR_PROPINF)
 
 
BOOST_AUTO_TEST_CASE( vector_dist_class3_check_nan_inf )
{
    Box<2,float> domain({0.0,0.0},{1.0,1.0});
 
    // Here we define the boundary conditions of our problem
    size_t bc[2]={PERIODIC,PERIODIC};
 
    // extended boundary around the domain, and the processor domain
    Ghost<2,float> g(0.05);
 
    vector_dist<2,float,aggregate<float,float[3],openfpm::vector<double>>> vd(0,domain,bc,g);
 
    bool error = false;
 
    // Initialize
 
    {
    for (size_t i = 0 ; i < 1200 ; i++)
    {
        vd.add();
 
        // Read something not initialized ERROR
        vd.getLastPos()[0] = 0.0/0.0;
        vd.getLastPos()[1] = 0.0/0.0;
    }
    }
 
    {
    try
    {
        vd.getPosRead(0);
    }
    catch (std::exception & e)
    {
        error = true;
    }
    }
 
    BOOST_REQUIRE_EQUAL(error,true);
    error = false;
 
    vector_dist<2,float,aggregate<float,float[3],openfpm::vector<double>>> vd2(0,domain,bc,g);
 
    {
    for (size_t i = 0 ; i < 1200 ; i++)
    {
        vd2.add();
 
        // Read something not initialized ERROR
        vd2.getLastPos()[0] = 5.0/0.0;
        vd2.getLastPos()[1] = 5.0/0.0;
    }
    }
 
    {
    try
    {
        vd2.getLastPosRead();
    }
    catch (std::exception & e)
    {
        error = true;
    }
    }
 
    BOOST_REQUIRE_EQUAL(error,true);
}
 
#endif
 
BOOST_AUTO_TEST_SUITE_END()
 
#endif
 
#endif /* SRC_VECTOR_SE_CLASS3_VECTOR_UNIT_TESTS_HPP_ */