vector_dist_HDF5_chckpnt_restart_test.cpp

/*
 * vector_dist_HDF5_save.hpp
 *
 *  Created on: Jun 12, 2016
 *      Author: Yaroslav Zaluzhnyi
 */
#define BOOST_TEST_DYN_LINK
#include <boost/test/unit_test.hpp>
 
#include "Vector/vector_dist.hpp"
#include "Packer_Unpacker/Pack_selector.hpp"
#include "Packer_Unpacker/Packer.hpp"
#include "Packer_Unpacker/Unpacker.hpp"
#include "Vector/performance/vector_dist_performance_util.hpp"
#include "NN/CellList/CellList_util.hpp"
 
#include "hdf5.h"
 
BOOST_AUTO_TEST_SUITE( vd_hdf5_chckpnt_rstrt_test )
 
// Dimensionality
const size_t dim = 3;
 
BOOST_AUTO_TEST_CASE( vector_dist_hdf5_save_test )
{
    Box<dim,float> box;
 
    for (size_t i = 0; i < dim; i++)
    {
        box.setLow(i,0.0);
        box.setHigh(i,1.0);
    }
 
    // Boundary conditions
    size_t bc[dim];
 
    const size_t Ng = 32;
 
    // we create a Grid iterator
    size_t sz[dim] = {Ng,Ng,Ng};
 
    for (size_t i = 0; i < dim; i++)
    {bc[i] = NON_PERIODIC;}
 
    // ghost
    Ghost<dim,float> ghost(1.0/(Ng-2));
 
    vector_dist<dim,float, aggregate<float[dim]> > vd(0,box,bc,ghost);
 
    // Put particles
 
    auto it = vd.getGridIterator(sz);
 
    while (it.isNext())
    {
        vd.add();
 
        auto key = it.get();
 
        vd.getLastPos()[0] = key.get(0) * it.getSpacing(0);
        vd.getLastPos()[1] = key.get(1) * it.getSpacing(1);
        vd.getLastPos()[2] = key.get(2) * it.getSpacing(2);
 
        ++it;
    }
 
    vd.map();
 
    // Put forces
 
    auto it2 = vd.getDomainIterator();
 
    while (it2.isNext())
    {
        auto key = it2.get();
 
        //Put the forces
        for (size_t i = 0; i < dim; i++)
            vd.template getProp<0>(key)[i] = 0.51234 + vd.getPos(key)[0] + vd.getPos(key)[1]+ vd.getPos(key)[2];
 
        ++it2;
    }
 
    // Save the vector
    vd.save("vector_dist" + std::to_string(create_vcluster().size()) + ".h5");
 
    vector_dist<dim,float, aggregate<float[dim]> > vd2(0,box,bc,ghost);
 
    vd2.load("vector_dist" + std::to_string(create_vcluster().size())  + ".h5");
 
    // Check that vd and vd2 match
 
    auto it3 = vd.getDomainIterator();
 
    BOOST_REQUIRE_EQUAL(vd.size_local(),vd2.size_local());
 
    bool check = true;
    while (it3.isNext())
    {
        auto p = it3.get();
 
        Point<3,float> p1 = vd.getPos(p);
        Point<3,float> p2 = vd2.getPos(p);
 
        check &= (p1 == p2);
 
        check &= (vd.template getProp<0>(p)[0] == vd2.template getProp<0>(p)[0]);
        check &= (vd.template getProp<0>(p)[1] == vd2.template getProp<0>(p)[1]);
        check &= (vd.template getProp<0>(p)[2] == vd2.template getProp<0>(p)[2]);
 
        ++it3;
    }
 
    BOOST_REQUIRE_EQUAL(check,true);
}
 
 
 
BOOST_AUTO_TEST_CASE( vector_dist_hdf5_load_test )
{
#ifndef SE_CLASS3
 
    Vcluster<> & v_cl = create_vcluster();
 
    Box<dim,float> box;
 
    for (size_t i = 0; i < dim; i++)
    {
        box.setLow(i,0.0);
        box.setHigh(i,1.0);
    }
 
    // Boundary conditions
    size_t bc[dim];
 
    for (size_t i = 0; i < dim; i++)
        bc[i] = NON_PERIODIC;
 
 
    const size_t Ng = 32;
 
    // ghost
    Ghost<dim,float> ghost(1.0/(Ng-2));
 
    vector_dist<dim,float, aggregate<float[dim]> > vd(0,box,bc,ghost);
 
    // Load the vector
    vd.load("test_data/vector_dist_24.h5");
 
 
    // Check total number of particles
    size_t n_part = vd.size_local();
    v_cl.sum(n_part);
    v_cl.execute();
 
    BOOST_REQUIRE_EQUAL(n_part,Ng*Ng*Ng);
 
    // Check properties
 
    auto it2 = vd.getDomainIterator();
 
    while (it2.isNext())
    {
        auto key = it2.get();
 
        // Check the properties
        for (size_t i = 0; i < dim; i++)
            BOOST_REQUIRE_EQUAL(vd.template getProp<0>(key)[i],(float)(0.51234 + vd.getPos(key)[0] + vd.getPos(key)[1]+ vd.getPos(key)[2]));
 
        ++it2;
    }
 
#endif
}
 
BOOST_AUTO_TEST_SUITE_END()