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();

}