main.cpp

#include "Vector/vector_dist.hpp"
#include "data_type/aggregate.hpp"
#include "Decomposition/CartDecomposition.hpp"
#include "VCluster/VCluster.hpp"
 
#define POS_ 0
 
 
struct my_particle
{
    double x[2];
 
    double prop0;
 
    long int prop1;
};
 
 
 
void serial_to_parallel(std::vector<my_particle> & parts,
                        vector_dist<2,double,aggregate<double,long int>> & pparts)
{
    auto & v_cl = create_vcluster();
    pparts.clear();
 
    if (v_cl.getProcessUnitID() == 0)
    {
        for (size_t i = 0 ; i < parts.size() ; i++)
        {
            pparts.add();
 
            pparts.getLastPos()[0] = parts[i].x[0];
            pparts.getLastPos()[1] = parts[i].x[1];
 
            pparts.getLastProp<0>() = parts[i].prop0;
            pparts.getLastProp<1>() = parts[i].prop1;
        }
    }
 
    pparts.map<Error>();
    pparts.addComputationCosts();
    pparts.getDecomposition().decompose();
    pparts.map<Error>();
}
 
 
 
void parallel_to_serial(std::vector<my_particle> & parts,
                        vector_dist<2,double,aggregate<double,long int>> & pparts)
{
    auto & v_cl = create_vcluster();
 
    // here we collect on the processor 0
 
    auto & pos = pparts.getPosVector();
    auto & prp = pparts.getPropVector();
 
    std::remove_reference<decltype(pos)>::type pos_collect;
    std::remove_reference<decltype(prp)>::type prp_collect;
 
    // we collecto everything on processor 0 on pos_collect and prp_collect
    v_cl.SGather(pos,pos_collect,0);
    v_cl.SGather(prp,prp_collect,0);
 
    if (v_cl.getProcessUnitID() == 0)
    {
        parts.clear();
 
        for (size_t i = 0 ; i < pos_collect.size() ; i++)
        {
            struct my_particle p;
 
            p.x[0] = pos_collect.get<POS_>(i)[0];
            p.x[1] = pos_collect.get<POS_>(i)[1];
 
            p.prop0 = prp_collect.get<0>(i);
            p.prop1 = prp_collect.get<1>(i);
 
            parts.push_back(p);
        }
    }
}
 
 
int main(int argc, char* argv[])
{
 
    openfpm_init(&argc,&argv);
    Vcluster<> & v_cl = create_vcluster();
    
 
 
    std::vector<my_particle> parts;
 
    // id of the processor calling this function
    long int proc_id = v_cl.getProcessUnitID();
 
    if (proc_id == 0)
    {
        // We create 100 particles randomly between (0,0) and (2.0,3.0) serially
 
        for (size_t i = 0 ; i < 100 ; i++)
        {
            my_particle p;
 
            p.x[0] = 2.0*(double)rand()/RAND_MAX;
            p.x[1] = 3.0*(double)rand()/RAND_MAX;
            p.prop0 = 0;
            p.prop1 = 0;
            parts.push_back(p);
        }
    }
 
 
 
    Box<2,double> domain({0.0,0.0},{2.0,3.0});
 
    Ghost<2,double> gs(0.02);
    size_t bc[2] = {PERIODIC,PERIODIC};
 
    vector_dist<2,double,aggregate<double,long int>> pparts(0,domain,bc,gs);
 
 
    // We do 100 iteration
    for (size_t i = 0 ; i < 100 ; i++)
    {
 
        // here we convert from serial to parallel moving the data from
        // the serial part to pparts
 
        serial_to_parallel(parts,pparts);
 
        // Now we can use pparts to
 
        auto it = pparts.getDomainIterator();
 
        while (it.isNext())
        {
            auto key = it.get();
 
            pparts.getPos(key)[0] += 0.01;
            pparts.getPos(key)[1] += 0.01;
 
            pparts.getProp<0>(key) = i*i;
            pparts.getProp<1>(key) = i;
 
            ++it;
        }
 
        pparts.write_frame("output",i);
 
 
 
        parallel_to_serial(parts,pparts);
 
        // id of the processor calling this function
        long int proc_id = v_cl.getProcessUnitID();
 
        if (proc_id == 0)
        {
            // Here we are serial with parts updates
 
            for (size_t i = 0 ; i < parts.size() ; i++)
            {
                parts[i].x[0] += 0.01;
                parts[i].x[1] += 0.01;
 
                parts[i].prop0 = i*i;
                parts[i].prop1 = i;
            }
        }
 
    }
 
 
    openfpm_finalize();
 
}