main.cpp

 
#include "Vector/vector_dist.hpp"
 
int main(int argc, char* argv[])
{
 
    // initialize the library
    openfpm_init(&argc,&argv);
 
    // Here we define our domain a 2D box with internals from 0 to 1.0 for x and y
    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.01);
    
    // the scalar is the element at position 0 in the aggregate
    constexpr int scalar = 0;
 
    // the vector is the element at position 1 in the aggregate
    constexpr int vector = 1;
 
    // the tensor is the element at position 2 in the aggregate
    constexpr int point = 2;
 
    // A list1
    constexpr int list = 3;
 
    // A listA
    constexpr int listA = 4;
 
    // A list of list
    constexpr int listlist = 5;
 
 
 
    // The custom structure
    struct A
    {
        float p1;
        int p2;
 
        A() {};
 
        A(float p1, int p2)
        :p1(p1),p2(p2)
        {}
    };
 
 
 
    vector_dist<2,float, aggregate<float,
                                   float[3],
                                   Point<3,double>,
                                   openfpm::vector<float>,
                                   openfpm::vector<A>,
                                   openfpm::vector<openfpm::vector<float>>> >
    vd(4096,domain,bc,g);
 
 
 
    auto it = vd.getDomainIterator();
 
    while (it.isNext())
    {
        auto p = it.get();
 
        // we define x, assign a random position between 0.0 and 1.0
        vd.getPos(p)[0] = (float)rand() / RAND_MAX;
 
        // we define y, assign a random position between 0.0 and 1.0
        vd.getPos(p)[1] = (float)rand() / RAND_MAX;
 
 
        vd.getProp<scalar>(p) = 1.0;
 
        vd.getProp<vector>(p)[0] = 1.0;
        vd.getProp<vector>(p)[1] = 1.0;
        vd.getProp<vector>(p)[2] = 1.0;
 
        vd.getProp<point>(p).get(0) = 1.0;
        vd.getProp<point>(p).get(1) = 1.0;
        vd.getProp<point>(p).get(2) = 1.0;
 
        size_t n_cp = (float)10.0 * rand()/RAND_MAX;
 
        vd.getProp<listA>(p).resize(n_cp);
 
        for (size_t i = 0 ; i < n_cp ; i++)
        {
            vd.getProp<list>(p).add(i + 10);
            vd.getProp<list>(p).add(i + 20);
            vd.getProp<list>(p).add(i + 30);
 
            vd.getProp<listA>(p).get(i) = A(i+10.0,i+20.0);
        }
 
        vd.getProp<listlist>(p).resize(2);
        vd.getProp<listlist>(p).get(0).resize(2);
        vd.getProp<listlist>(p).get(1).resize(2);
 
        vd.getProp<listlist>(p).get(0).get(0) = 1.0;
        vd.getProp<listlist>(p).get(0).get(1) = 2.0;
        vd.getProp<listlist>(p).get(1).get(0) = 3.0;
        vd.getProp<listlist>(p).get(1).get(1) = 4.0;
 
        // next particle
        ++it;
    }
 
 
 
    // Particles are redistribued across the processors but only the scalar,vector, and point properties
    // are transfert
    vd.map_list<scalar,vector,point,list,listA,listlist>();
    
    // Synchronize the ghost
    vd.ghost_get<scalar,vector,point,listA,listlist>();
 
 
 
    vd.write("particles");
 
 
 
    size_t fg = vd.size_local();
 
    Vcluster<> & v_cl = create_vcluster();
    if (v_cl.getProcessUnitID() == 0)
    {
        for ( ; fg < vd.size_local()+4 ; fg++)
        {
            std::cout << "List of A" << std::endl;
            for (size_t i = 0 ; i < vd.getProp<listA>(fg).size() ; i++)
                std::cout << "Element: " << i << "   p1=" << vd.getProp<listA>(fg).get(i).p1 << "   p2=" << vd.getProp<listA>(fg).get(i).p2 << std::endl;
 
            std::cout << "List of list" << std::endl;
            for (size_t i = 0 ; i < vd.getProp<listlist>(fg).size() ; i++)
            {
                for (size_t j = 0 ; j < vd.getProp<listlist>(fg).get(i).size() ; j++)
                    std::cout << "Element: " << i << "  " << j << "   " << vd.getProp<listlist>(fg).get(i).get(j) << std::endl;
            }
        }
    }
 
 
 
    openfpm_finalize();
 
 
}