main.cpp

 
#include "util/cuda_launch.hpp"
#include "Grid/grid_dist_id.hpp"
#include "data_type/aggregate.hpp"
#include "timer.hpp"
 
constexpr int U = 0;
constexpr int V = 1;
 
constexpr int U_next = 2;
constexpr int V_next = 3;
 
constexpr int x = 0;
constexpr int y = 1;
constexpr int z = 2;
 
void init(sgrid_dist_soa<3,double,aggregate<double,double,double,double> > & grid, Box<3,double> & domain)
{
    for (int i = 0 ; i < 10 ; i++)
    {
        timer t;
        t.start();
 
        auto it = grid.getGridIterator();
 
        while (it.isNext())
        {
            // Get the local grid key
            auto key = it.get_dist();
 
            // Old values U and V
            grid.template insert<U>(key) = 1.0;
 
            ++it;
        }
 
        t.stop();
        std::cout << "Time populate: " << t.getwct() << std::endl;
 
        grid.clear();
 
                timer t2;
                t2.start();
 
                auto it2 = grid.getGridIterator();
 
                while (it2.isNext())
                {
                        // Get the local grid key
                        auto key = it2.get_dist();
 
                        // Old values U and V
                        grid.template insert<U>(key) = 5.0;
         
                        ++it2;
                }
 
        t2.stop();
                std::cout << "Time populate: " << t2.getwct() << std::endl;
 
    }
}
 
 
int main(int argc, char* argv[])
{
    openfpm_init(&argc,&argv);
 
    // domain
    Box<3,double> domain({0.0,0.0,0.0},{2.5,2.5,2.5});
    
    // grid size
        size_t sz[3] = {256,256,256};
 
    // Define periodicity of the grid
    periodicity<3> bc = {PERIODIC,PERIODIC,PERIODIC};
    
    // Ghost in grid unit
    Ghost<3,long int> g(1);
    
    // deltaT
    double deltaT = 0.25;
 
    // Diffusion constant for specie U
    double du = 2*1e-5;
 
    // Diffusion constant for specie V
    double dv = 1*1e-5;
 
    // Number of timesteps
#ifdef TEST_RUN
    size_t timeSteps = 200;
#else
        size_t timeSteps = 5000;
#endif
 
    // K and F (Physical constant in the equation)
    double K = 0.053;
    double F = 0.014;
 
 
    sgrid_dist_soa<3, double, aggregate<double,double,double,double>> grid(sz,domain,g,bc);
 
 
    // spacing of the grid on x and y
    double spacing[3] = {grid.spacing(0),grid.spacing(1),grid.spacing(2)};
 
    init(grid,domain);
 
    // sync the ghost
    size_t count = 0;
    grid.template ghost_get<U,V>();
 
    // because we assume that spacing[x] == spacing[y] we use formula 2
    // and we calculate the prefactor of Eq 2
    double uFactor = deltaT * du/(spacing[x]*spacing[x]);
    double vFactor = deltaT * dv/(spacing[x]*spacing[x]);
 
    timer tot_sim;
    tot_sim.start();
 
    auto & v_cl = create_vcluster();
    
    tot_sim.stop();
    std::cout << "Total simulation: " << tot_sim.getwct() << std::endl;
 
    grid.write("final");
 
 
 
    openfpm_finalize();
 
 
}