main_vic_petsc_double.cpp

 
#include "config.h"
 
#ifdef HAVE_PETSC
 
//#define SE_CLASS1
//#define PRINT_STACKTRACE
 
 
#include "interpolation/interpolation.hpp"
#include "Grid/grid_dist_id.hpp"
#include "Vector/vector_dist.hpp"
#include "Matrix/SparseMatrix.hpp"
#include "Vector/Vector.hpp"
#include "FiniteDifference/FDScheme.hpp"
#include "Solvers/petsc_solver.hpp"
#include "interpolation/mp4_kernel.hpp"
#include "Solvers/petsc_solver_AMG_report.hpp"
 
constexpr int x = 0;
constexpr int y = 1;
constexpr int z = 2;
 
// The type of the grids
typedef grid_dist_id<3,double,aggregate<double[3]>> grid_type;
 
// The type of the particles
typedef vector_dist<3,double,aggregate<double[3],double[3],double[3],double[3],double[3]>> particles_type;
 
// radius of the torus
double ringr1 = 1.0;
// radius of the core of the torus
double sigma = 1.0/3.523;
// Reynold number
double tgtre  = 7500.0;
// Noise factor for the ring vorticity on z
double ringnz = 0.01;
 
// Kinematic viscosity
double nu = 1.0/tgtre;
 
// Time step
double dt = 0.025;
 
// All the properties by index
constexpr unsigned int vorticity = 0;
constexpr unsigned int velocity = 0;
constexpr unsigned int p_vel = 1;
constexpr int rhs_part = 2;
constexpr unsigned int old_vort = 3;
constexpr unsigned int old_pos = 4;
 
 
template<typename grid> void calc_and_print_max_div_and_int(grid & g_vort)
{
 
    g_vort.template ghost_get<vorticity>();
    auto it5 = g_vort.getDomainIterator();
 
    double max_vort = 0.0;
 
    double int_vort[3] = {0.0,0.0,0.0};
 
    while (it5.isNext())
    {
        auto key = it5.get();
 
        double tmp;
 
        tmp = 1.0f/g_vort.spacing(x)/2.0f*(g_vort.template get<vorticity>(key.move(x,1))[x] - g_vort.template get<vorticity>(key.move(x,-1))[x] ) +
                             1.0f/g_vort.spacing(y)/2.0f*(g_vort.template get<vorticity>(key.move(y,1))[y] - g_vort.template get<vorticity>(key.move(y,-1))[y] ) +
                             1.0f/g_vort.spacing(z)/2.0f*(g_vort.template get<vorticity>(key.move(z,1))[z] - g_vort.template get<vorticity>(key.move(z,-1))[z] );
 
        int_vort[x] += g_vort.template get<vorticity>(key)[x];
        int_vort[y] += g_vort.template get<vorticity>(key)[y];
        int_vort[z] += g_vort.template get<vorticity>(key)[z];
 
        if (tmp > max_vort)
            max_vort = tmp;
 
        ++it5;
    }
 
    Vcluster & v_cl = create_vcluster();
    v_cl.max(max_vort);
    v_cl.sum(int_vort[0]);
    v_cl.sum(int_vort[1]);
    v_cl.sum(int_vort[2]);
    v_cl.execute();
 
    if (v_cl.getProcessUnitID() == 0)
    {std::cout << "Max div for vorticity " << max_vort << "   Integral: " << int_vort[0] << "  " << int_vort[1] << "   " << int_vort[2] << std::endl;}
 
}
 
 
/*
 * gr is the grid where we are initializing the vortex ring
 * domain is the simulation domain
 *
 */
void init_ring(grid_type & gr, const Box<3,double> & domain)
{
    // To add some noise to the vortex ring we create two random
    // vector
    constexpr int nk = 32;
 
    double ak[nk];
    double bk[nk];
 
    for (size_t i = 0 ; i < nk ; i++)
    {
         ak[i] = rand()/RAND_MAX;
         bk[i] = rand()/RAND_MAX;
    }
 
    // We calculate the circuitation gamma
    double gamma = nu * tgtre;
    double rinv2 = 1.0f/(sigma*sigma);
    double max_vorticity = gamma*rinv2/M_PI;
 
    // We go through the grid to initialize the vortex
    auto it = gr.getDomainIterator();
 
    while (it.isNext())
    {
        auto key_d = it.get();
        auto key = it.getGKey(key_d);
 
        double tx = (key.get(x)-2)*gr.spacing(x) + domain.getLow(x);
        double ty = (key.get(y)-2)*gr.spacing(y) + domain.getLow(y);
        double tz = (key.get(z)-2)*gr.spacing(z) + domain.getLow(z);
        double theta1 = atan2((ty-2.5f),(tz-2.5f));
 
 
 
        double noise = 0.0f;
 //       for (int kk=1 ; kk < nk; kk++)
 //         noise = noise + sin(kk*(theta1+2.0f*M_PI*ak[kk])) + cos(kk*(theta1+2.0f*M_PI*bk[kk]));
 
        double rad1r  = sqrt((ty-2.5f)*(ty-2.5f) + (tz-2.5f)*(tz-2.5f)) - ringr1*(1.0f + ringnz * noise);
        double rad1t = tx - 1.0f;
        double rad1sq = rad1r*rad1r + rad1t*rad1t;
        double radstr = -exp(-rad1sq*rinv2)*rinv2*gamma/M_PI;
        gr.template get<vorticity>(key_d)[x] = 0.0f;
        gr.template get<vorticity>(key_d)[y] = -radstr * cos(theta1);
        gr.template get<vorticity>(key_d)[z] = radstr * sin(theta1);
 
 
        ++it;
    }
}
 
 
 
// Specification of the poisson equation for the helmotz-hodge projection
// 3D (dims = 3). The field is a scalar value (nvar = 1), bournary are periodic
// type of the the space is double. Final grid that will store \phi, the result (grid_dist_id<.....>)
// The other indicate which kind of Matrix to use to construct the linear system and
// which kind of vector to construct for the right hand side. Here we use a PETSC Sparse Matrix
// and PETSC vector. NORMAL_GRID indicate that is a standard grid (non-staggered)
struct poisson_nn_helm
{
        static const unsigned int dims = 3;
        static const unsigned int nvar = 1;
        static const bool boundary[];
        typedef double stype;
        typedef grid_dist_id<3,double,aggregate<double>> b_grid;
        typedef SparseMatrix<double,int,PETSC_BASE> SparseMatrix_type;
        typedef Vector<double,PETSC_BASE> Vector_type;
        static const int grid_type = NORMAL_GRID;
};
 
const bool poisson_nn_helm::boundary[] = {PERIODIC,PERIODIC,PERIODIC};
 
 
 
/*
 * gr vorticity grid where we apply the correction
 * domain simulation domain
 *
 */
void helmotz_hodge_projection(grid_type & gr, const Box<3,double> & domain, petsc_solver<double> & solver, petsc_solver<double>::return_type & x_ , bool init)
{
 
 
    // Convenient constant
    constexpr unsigned int phi = 0;
 
    // We define a field phi_f
    typedef Field<phi,poisson_nn_helm> phi_f;
 
    // We assemble the poisson equation doing the
    // poisson of the Laplacian of phi using Laplacian
    // central scheme (where the both derivative use central scheme, not
    // forward composed backward like usually)
    typedef Lap<phi_f,poisson_nn_helm,CENTRAL_SYM> poisson;
 
 
 
    // ghost get
    gr.template ghost_get<vorticity>();
 
    // ghost size of the psi function
    Ghost<3,long int> g(2);
 
    // Here we create a distributed grid to store the result of the helmotz projection
    grid_dist_id<3,double,aggregate<double>> psi(gr.getDecomposition(),gr.getGridInfo().getSize(),g);
 
    // Calculate the divergence of the vortex field
    auto it = gr.getDomainIterator();   
 
    while (it.isNext())
    {
        auto key = it.get();
 
        psi.template get<phi>(key) = 1.0f/gr.spacing(x)/2.0f*(gr.template get<vorticity>(key.move(x,1))[x] - gr.template get<vorticity>(key.move(x,-1))[x] ) +
                             1.0f/gr.spacing(y)/2.0f*(gr.template get<vorticity>(key.move(y,1))[y] - gr.template get<vorticity>(key.move(y,-1))[y] ) +
                             1.0f/gr.spacing(z)/2.0f*(gr.template get<vorticity>(key.move(z,1))[z] - gr.template get<vorticity>(key.move(z,-1))[z] );
 
        ++it;
    }
 
 
 
    calc_and_print_max_div_and_int(gr);
 
 
 
    // In order to create a matrix that represent the poisson equation we have to indicate
    // we have to indicate the maximum extension of the stencil and we we need an extra layer
    // of points in case we have to impose particular boundary conditions.
    Ghost<3,long int> stencil_max(2);
 
    // Here we define our Finite difference disctetization scheme object
    FDScheme<poisson_nn_helm> fd(stencil_max, domain, psi);
 
    // impose the poisson equation, using right hand side psi on the full domain (psi.getDomainIterator)
    // the template paramereter instead define which property of phi carry the righ-hand-side
    // in this case phi has only one property, so the property 0 carry the right hand side
    fd.template impose_dit<0>(poisson(),psi,psi.getDomainIterator());
 
 
 
    timer tm_solve;
    if (init == true)
    {
        // Set the conjugate-gradient as method to solve the linear solver
        solver.setSolver(KSPBCGS);
 
        // Set the absolute tolerance to determine that the method is converged
        solver.setAbsTol(0.001);
 
        // Set the maximum number of iterations
        solver.setMaxIter(500);
 
        solver.setPreconditioner(PCHYPRE_BOOMERAMG);
        solver.setPreconditionerAMG_nl(6);
        solver.setPreconditionerAMG_maxit(1);
        solver.setPreconditionerAMG_relax("SOR/Jacobi");
        solver.setPreconditionerAMG_cycleType("V",0,4);
        solver.setPreconditionerAMG_coarsenNodalType(0);
        solver.setPreconditionerAMG_coarsen("HMIS");
 
        tm_solve.start();
 
        // Give to the solver A and b, return x, the solution
        solver.solve(fd.getA(),x_,fd.getB());
 
        tm_solve.stop();
    }
    else
    {
        tm_solve.start();
        solver.solve(x_,fd.getB());
        tm_solve.stop();
    }
 
    // copy the solution x to the grid psi
    fd.template copy<phi>(x_,psi);
 
 
 
    psi.template ghost_get<phi>();
 
    // Correct the vorticity to make it divergence free
 
    auto it2 = gr.getDomainIterator();
 
    while (it2.isNext())
    {
        auto key = it2.get();
 
        gr.template get<vorticity>(key)[x] -= 1.0f/2.0f/psi.spacing(x)*(psi.template get<phi>(key.move(x,1))-psi.template get<phi>(key.move(x,-1)));
        gr.template get<vorticity>(key)[y] -= 1.0f/2.0f/psi.spacing(y)*(psi.template get<phi>(key.move(y,1))-psi.template get<phi>(key.move(y,-1)));
        gr.template get<vorticity>(key)[z] -= 1.0f/2.0f/psi.spacing(z)*(psi.template get<phi>(key.move(z,1))-psi.template get<phi>(key.move(z,-1)));
 
        ++it2;
    }
 
 
    calc_and_print_max_div_and_int(gr);
}
 
 
 
void remesh(particles_type & vd, grid_type & gr,Box<3,double> & domain)
{
    // Remove all particles because we reinitialize in a grid like position
    vd.clear();
 
    // Get a grid iterator
    auto git = vd.getGridIterator(gr.getGridInfo().getSize());
 
    // For each grid point
    while (git.isNext())
    {
        // Get the grid point in global coordinates (key). p is in local coordinates
        auto p = git.get();
        auto key = git.get_dist();
 
        // Add the particle
        vd.add();
 
        // Assign the position to the particle in a grid like way
        vd.getLastPos()[x] = gr.spacing(x)*p.get(x) + domain.getLow(x);
        vd.getLastPos()[y] = gr.spacing(y)*p.get(y) + domain.getLow(y);
        vd.getLastPos()[z] = gr.spacing(z)*p.get(z) + domain.getLow(z);
 
        // Initialize the vorticity
        vd.template getLastProp<vorticity>()[x] = gr.template get<vorticity>(key)[x];
        vd.template getLastProp<vorticity>()[y] = gr.template get<vorticity>(key)[y];
        vd.template getLastProp<vorticity>()[z] = gr.template get<vorticity>(key)[z];
 
        // next grid point
        ++git;
    }
 
    // redistribute the particles
    vd.map();
}
 
 
 
void comp_vel(Box<3,double> & domain, grid_type & g_vort,grid_type & g_vel, petsc_solver<double>::return_type (& phi_s)[3],petsc_solver<double> & solver)
{
 
    // Convenient constant
    constexpr unsigned int phi = 0;
 
    // We define a field phi_f
    typedef Field<phi,poisson_nn_helm> phi_f;
 
    // We assemble the poisson equation doing the
    // poisson of the Laplacian of phi using Laplacian
    // central scheme (where the both derivative use central scheme, not
    // forward composed backward like usually)
    typedef Lap<phi_f,poisson_nn_helm,CENTRAL_SYM> poisson;
 
 
    // Maximum size of the stencil
    Ghost<3,long int> g(2);
 
    // Here we create a distributed grid to store the result
    grid_dist_id<3,double,aggregate<double>> gr_ps(g_vort.getDecomposition(),g_vort.getGridInfo().getSize(),g);
    grid_dist_id<3,double,aggregate<double[3]>> phi_v(g_vort.getDecomposition(),g_vort.getGridInfo().getSize(),g);
 
    // We calculate and print the maximum divergence of the vorticity
    // and the integral of it
    calc_and_print_max_div_and_int(g_vort);
 
    // For each component solve a poisson
    for (size_t i = 0 ; i < 3 ; i++)
    {
 
        // Copy the vorticity component i in gr_ps
        auto it2 = gr_ps.getDomainIterator();
 
        // calculate the velocity from the curl of phi
        while (it2.isNext())
        {
            auto key = it2.get();
 
            // copy
            gr_ps.get<vorticity>(key) = g_vort.template get<vorticity>(key)[i];
 
            ++it2;
        }
 
        // Maximum size of the stencil
        Ghost<3,long int> stencil_max(2);
 
        // Finite difference scheme
        FDScheme<poisson_nn_helm> fd(stencil_max, domain, gr_ps);
 
        // impose the poisson equation using gr_ps = vorticity for the right-hand-side (on the full domain)
        fd.template impose_dit<phi>(poisson(),gr_ps,gr_ps.getDomainIterator());
 
        solver.setAbsTol(0.01);
 
        // Get the vector that represent the right-hand-side
        Vector<double,PETSC_BASE> & b = fd.getB();
 
        timer tm_solve;
        tm_solve.start();
 
        // Give to the solver A and b in this case we are giving
        // an intitial guess phi_s calculated in the previous
        // time step
        solver.solve(phi_s[i],b);
 
        tm_solve.stop();
 
        // Calculate the residual
 
        solError serr;
        serr = solver.get_residual_error(phi_s[i],b);
 
        Vcluster & v_cl = create_vcluster();
        if (v_cl.getProcessUnitID() == 0)
        {std::cout << "Solved component " << i << "  Error: " << serr.err_inf << std::endl;}
 
        // copy the solution to grid
        fd.template copy<phi>(phi_s[i],gr_ps);
 
 
 
        auto it3 = gr_ps.getDomainIterator();
 
        // calculate the velocity from the curl of phi
        while (it3.isNext())
        {
            auto key = it3.get();
 
            phi_v.get<velocity>(key)[i] = gr_ps.get<phi>(key);
 
            ++it3;
        }
 
    }
 
 
    phi_v.ghost_get<phi>();
 
    double inv_dx = 0.5f / g_vort.spacing(0);
    double inv_dy = 0.5f / g_vort.spacing(1);
    double inv_dz = 0.5f / g_vort.spacing(2);
 
    auto it3 = phi_v.getDomainIterator();
 
    // calculate the velocity from the curl of phi
    while (it3.isNext())
    {
        auto key = it3.get();
 
        double phi_xy = (phi_v.get<phi>(key.move(y,1))[x] - phi_v.get<phi>(key.move(y,-1))[x])*inv_dy;
        double phi_xz = (phi_v.get<phi>(key.move(z,1))[x] - phi_v.get<phi>(key.move(z,-1))[x])*inv_dz;
        double phi_yx = (phi_v.get<phi>(key.move(x,1))[y] - phi_v.get<phi>(key.move(x,-1))[y])*inv_dx;
        double phi_yz = (phi_v.get<phi>(key.move(z,1))[y] - phi_v.get<phi>(key.move(z,-1))[y])*inv_dz;
        double phi_zx = (phi_v.get<phi>(key.move(x,1))[z] - phi_v.get<phi>(key.move(x,-1))[z])*inv_dx;
        double phi_zy = (phi_v.get<phi>(key.move(y,1))[z] - phi_v.get<phi>(key.move(y,-1))[z])*inv_dy;
 
        g_vel.template get<velocity>(key)[x] = phi_zy - phi_yz;
        g_vel.template get<velocity>(key)[y] = phi_xz - phi_zx;
        g_vel.template get<velocity>(key)[z] = phi_yx - phi_xy;
 
        ++it3;
    }
 
}
 
 
template<unsigned int prp> void set_zero(grid_type & gr)
{
    auto it = gr.getDomainGhostIterator();
 
    // calculate the velocity from the curl of phi
    while (it.isNext())
    {
        auto key = it.get();
 
        gr.template get<prp>(key)[0] = 0.0;
        gr.template get<prp>(key)[1] = 0.0;
        gr.template get<prp>(key)[2] = 0.0;
 
        ++it;
    }
}
 
 
template<unsigned int prp> void set_zero(particles_type & vd)
{
    auto it = vd.getDomainIterator();
 
    // calculate the velocity from the curl of phi
    while (it.isNext())
    {
        auto key = it.get();
 
        vd.template getProp<prp>(key)[0] = 0.0;
        vd.template getProp<prp>(key)[1] = 0.0;
        vd.template getProp<prp>(key)[2] = 0.0;
 
        ++it;
    }
}
 
 
// Calculate the right hand side of the vorticity formulation
template<typename grid> void calc_rhs(grid & g_vort, grid & g_vel, grid & g_dwp)
{
    // usefull constant
    constexpr int rhs = 0;
 
    // calculate several pre-factors for the stencil finite
    // difference
    double fac1 = 2.0f*nu/(g_vort.spacing(0));
    double fac2 = 2.0f*nu/(g_vort.spacing(1));
    double fac3 = 2.0f*nu/(g_vort.spacing(2));
 
    double fac4 = 0.5f/(g_vort.spacing(0));
    double fac5 = 0.5f/(g_vort.spacing(1));
    double fac6 = 0.5f/(g_vort.spacing(2));
 
    auto it = g_dwp.getDomainIterator();
 
    g_vort.template ghost_get<vorticity>();
 
    while (it.isNext())
    {
        auto key = it.get();
 
        g_dwp.template get<rhs>(key)[x] = /*fac1*(g_vort.template get<vorticity>(key.move(x,1))[x]+g_vort.template get<vorticity>(key.move(x,-1))[x])+
                                          fac2*(g_vort.template get<vorticity>(key.move(y,1))[x]+g_vort.template get<vorticity>(key.move(y,-1))[x])+
                                          fac3*(g_vort.template get<vorticity>(key.move(z,1))[x]+g_vort.template get<vorticity>(key.move(z,-1))[x])-
                                          2.0f*(fac1+fac2+fac3)*g_vort.template get<vorticity>(key)[x]+*/
                                          fac4*g_vort.template get<vorticity>(key)[x]*
                                          (g_vel.template get<velocity>(key.move(x,1))[x] - g_vel.template get<velocity>(key.move(x,-1))[x])+
                                          fac5*g_vort.template get<vorticity>(key)[y]*
                                          (g_vel.template get<velocity>(key.move(y,1))[x] - g_vel.template get<velocity>(key.move(y,-1))[x])+
                                          fac6*g_vort.template get<vorticity>(key)[z]*
                                          (g_vel.template get<velocity>(key.move(z,1))[x] - g_vel.template get<velocity>(key.move(z,-1))[x]);
 
        g_dwp.template get<rhs>(key)[y] = /*fac1*(g_vort.template get<vorticity>(key.move(x,1))[y]+g_vort.template get<vorticity>(key.move(x,-1))[y])+
                                          fac2*(g_vort.template get<vorticity>(key.move(y,1))[y]+g_vort.template get<vorticity>(key.move(y,-1))[y])+
                                          fac3*(g_vort.template get<vorticity>(key.move(z,1))[y]+g_vort.template get<vorticity>(key.move(z,-1))[y])-
                                          2.0f*(fac1+fac2+fac3)*g_vort.template get<vorticity>(key)[y]+*/
                                          fac4*g_vort.template get<vorticity>(key)[x]*
                                          (g_vel.template get<velocity>(key.move(x,1))[y] - g_vel.template get<velocity>(key.move(x,-1))[y])+
                                          fac5*g_vort.template get<vorticity>(key)[y]*
                                          (g_vel.template get<velocity>(key.move(y,1))[y] - g_vel.template get<velocity>(key.move(y,-1))[y])+
                                          fac6*g_vort.template get<vorticity>(key)[z]*
                                          (g_vel.template get<velocity>(key.move(z,1))[y] - g_vel.template get<velocity>(key.move(z,-1))[y]);
 
 
        g_dwp.template get<rhs>(key)[z] = /*fac1*(g_vort.template get<vorticity>(key.move(x,1))[z]+g_vort.template get<vorticity>(key.move(x,-1))[z])+
                                          fac2*(g_vort.template get<vorticity>(key.move(y,1))[z]+g_vort.template get<vorticity>(key.move(y,-1))[z])+
                                          fac3*(g_vort.template get<vorticity>(key.move(z,1))[z]+g_vort.template get<vorticity>(key.move(z,-1))[z])-
                                          2.0f*(fac1+fac2+fac3)*g_vort.template get<vorticity>(key)[z]+*/
                                          fac4*g_vort.template get<vorticity>(key)[x]*
                                          (g_vel.template get<velocity>(key.move(x,1))[z] - g_vel.template get<velocity>(key.move(x,-1))[z])+
                                          fac5*g_vort.template get<vorticity>(key)[y]*
                                          (g_vel.template get<velocity>(key.move(y,1))[z] - g_vel.template get<velocity>(key.move(y,-1))[z])+
                                          fac6*g_vort.template get<vorticity>(key)[z]*
                                          (g_vel.template get<velocity>(key.move(z,1))[z] - g_vel.template get<velocity>(key.move(z,-1))[z]);
 
        ++it;
    }
}
 
 
 
void rk_step1(particles_type & particles)
{
    auto it = particles.getDomainIterator();
 
    while (it.isNext())
    {
        auto key = it.get();
 
        // Save the old vorticity
        particles.getProp<old_vort>(key)[x] = particles.getProp<vorticity>(key)[x];
        particles.getProp<old_vort>(key)[y] = particles.getProp<vorticity>(key)[y];
        particles.getProp<old_vort>(key)[z] = particles.getProp<vorticity>(key)[z];
 
        particles.getProp<vorticity>(key)[x] = particles.getProp<vorticity>(key)[x] + 0.5f * dt * particles.getProp<rhs_part>(key)[x];
        particles.getProp<vorticity>(key)[y] = particles.getProp<vorticity>(key)[y] + 0.5f * dt * particles.getProp<rhs_part>(key)[y];
        particles.getProp<vorticity>(key)[z] = particles.getProp<vorticity>(key)[z] + 0.5f * dt * particles.getProp<rhs_part>(key)[z];
 
        ++it;
    }
 
    auto it2 = particles.getDomainIterator();
 
    while (it2.isNext())
    {
        auto key = it2.get();
 
        // Save the old position
        particles.getProp<old_pos>(key)[x] = particles.getPos(key)[x];
        particles.getProp<old_pos>(key)[y] = particles.getPos(key)[y];
        particles.getProp<old_pos>(key)[z] = particles.getPos(key)[z];
 
        particles.getPos(key)[x] = particles.getPos(key)[x] + 0.5f * dt * particles.getProp<p_vel>(key)[x];
        particles.getPos(key)[y] = particles.getPos(key)[y] + 0.5f * dt * particles.getProp<p_vel>(key)[y];
        particles.getPos(key)[z] = particles.getPos(key)[z] + 0.5f * dt * particles.getProp<p_vel>(key)[z];
 
        ++it2;
    }
 
    particles.map();
}
 
 
 
void rk_step2(particles_type & particles)
{
    auto it = particles.getDomainIterator();
 
    while (it.isNext())
    {
        auto key = it.get();
 
        particles.getProp<vorticity>(key)[x] = particles.getProp<old_vort>(key)[x] + dt * particles.getProp<rhs_part>(key)[x];
        particles.getProp<vorticity>(key)[y] = particles.getProp<old_vort>(key)[y] + dt * particles.getProp<rhs_part>(key)[y];
        particles.getProp<vorticity>(key)[z] = particles.getProp<old_vort>(key)[z] + dt * particles.getProp<rhs_part>(key)[z];
 
        ++it;
    }
 
    auto it2 = particles.getDomainIterator();
 
    while (it2.isNext())
    {
        auto key = it2.get();
 
        particles.getPos(key)[x] = particles.getProp<old_pos>(key)[x] + dt * particles.getProp<p_vel>(key)[x];
        particles.getPos(key)[y] = particles.getProp<old_pos>(key)[y] + dt * particles.getProp<p_vel>(key)[y];
        particles.getPos(key)[z] = particles.getProp<old_pos>(key)[z] + dt * particles.getProp<p_vel>(key)[z];
 
        ++it2;
    }
 
    particles.map();
}
 
 
 
 
template<typename grid, typename vector> void do_step(vector & particles,
                                                      grid & g_vort,
                                                      grid & g_vel,
                                                      grid & g_dvort,
                                                      Box<3,double> & domain,
                                                      interpolate<particles_type,grid_type,mp4_kernel<double>> & inte,
                                                      petsc_solver<double>::return_type (& phi_s)[3],
                                                      petsc_solver<double> & solver)
{
    constexpr int rhs = 0;
 
 
    set_zero<vorticity>(g_vort);
    inte.template p2m<vorticity,vorticity>(particles,g_vort);
 
    g_vort.template ghost_put<add_,vorticity>();
 
 
 
    // Calculate velocity from vorticity
    comp_vel(domain,g_vort,g_vel,phi_s,solver);
    calc_rhs(g_vort,g_vel,g_dvort);
 
 
 
    g_dvort.template ghost_get<rhs>();
    g_vel.template ghost_get<velocity>();
    set_zero<rhs_part>(particles);
    set_zero<p_vel>(particles);
    inte.template m2p<rhs,rhs_part>(g_dvort,particles);
    inte.template m2p<velocity,p_vel>(g_vel,particles);
 
}
 
template<typename vector, typename grid> void check_point_and_save(vector & particles,
                                                                   grid & g_vort,
                                                                   grid & g_vel,
                                                                   grid & g_dvort,
                                                                   size_t i)
{
    Vcluster & v_cl = create_vcluster();
 
    if (v_cl.getProcessingUnits() < 24)
    {
        particles.write("part_out_" + std::to_string(i),VTK_WRITER | FORMAT_BINARY);
        g_vort.template ghost_get<vorticity>();
        g_vel.template ghost_get<velocity>();
        g_vel.write("grid_velocity_" + std::to_string(i), VTK_WRITER | FORMAT_BINARY);
        g_vort.write("grid_vorticity_" + std::to_string(i), VTK_WRITER | FORMAT_BINARY);
    }
 
    // In order to reduce the size of the saved data we apply a threshold.
    // We only save particles with vorticity higher than 0.1
    vector_dist<3,double,aggregate<double>> part_save(particles.getDecomposition(),0);
 
    auto it_s = particles.getDomainIterator();
 
    while (it_s.isNext())
    {
        auto p = it_s.get();
 
        double vort_magn = sqrt(particles.template getProp<vorticity>(p)[0] * particles.template getProp<vorticity>(p)[0] +
                               particles.template getProp<vorticity>(p)[1] * particles.template getProp<vorticity>(p)[1] +
                               particles.template getProp<vorticity>(p)[2] * particles.template getProp<vorticity>(p)[2]);
 
        if (vort_magn < 0.1)
        {
            ++it_s;
            continue;
        }
 
        part_save.add();
 
        part_save.getLastPos()[0] = particles.getPos(p)[0];
        part_save.getLastPos()[1] = particles.getPos(p)[1];
        part_save.getLastPos()[2] = particles.getPos(p)[2];
 
        part_save.template getLastProp<0>() = vort_magn;
 
        ++it_s;
    }
 
    part_save.map();
 
    // Save and HDF5 file for checkpoint restart
    particles.save("check_point");
}
 
int main(int argc, char* argv[])
{
    // Initialize
    openfpm_init(&argc,&argv);
    {
    // Domain, a rectangle
    Box<3,double> domain({0.0,0.0,0.0},{22.0,5.57,5.57});
 
    // Ghost (Not important in this case but required)
    Ghost<3,long int> g(2);
 
    // Grid points on x=128 y=64 z=64
    long int sz[] = {512,64,64};
    size_t szu[] = {(size_t)sz[0],(size_t)sz[1],(size_t)sz[2]};
 
    periodicity<3> bc = {{PERIODIC,PERIODIC,PERIODIC}};
 
    grid_type g_vort(szu,domain,g,bc);
    grid_type g_vel(g_vort.getDecomposition(),szu,g);
    grid_type g_dvort(g_vort.getDecomposition(),szu,g);
    particles_type particles(g_vort.getDecomposition(),0);
 
    // It store the solution to compute velocity
    // It is used as initial guess every time we call the solver
    Vector<double,PETSC_BASE> phi_s[3];
    Vector<double,PETSC_BASE> x_;
 
    // Parallel object
    Vcluster & v_cl = create_vcluster();
 
    // print out the spacing of the grid
    if (v_cl.getProcessUnitID() == 0)
    {std::cout << "SPACING " << g_vort.spacing(0) << " " << g_vort.spacing(1) << " " << g_vort.spacing(2) << std::endl;}
 
    // initialize the ring step 1
    init_ring(g_vort,domain);
 
    x_.resize(g_vort.size(),g_vort.getLocalDomainSize());
    x_.setZero();
 
    // Create a PETSC solver to get the solution x
    petsc_solver<double> solver;
 
    // Do the helmotz projection step 2
    helmotz_hodge_projection(g_vort,domain,solver,x_,true);
 
    // initialize the particle on a mesh step 3
    remesh(particles,g_vort,domain);
 
    // Get the total number of particles
    size_t tot_part = particles.size_local();
    v_cl.sum(tot_part);
    v_cl.execute();
 
    // Now we set the size of phi_s
    phi_s[0].resize(g_vort.size(),g_vort.getLocalDomainSize());
    phi_s[1].resize(g_vort.size(),g_vort.getLocalDomainSize());
    phi_s[2].resize(g_vort.size(),g_vort.getLocalDomainSize());
 
    // And we initially set it to zero
    phi_s[0].setZero();
    phi_s[1].setZero();
    phi_s[2].setZero();
 
    // We create the interpolation object outside the loop cycles
    // to avoid to recreate it at every cycle. Internally this object
    // create some data-structure to optimize the conversion particle
    // position to sub-domain. If there are no re-balancing it is safe
    // to reuse-it
    interpolate<particles_type,grid_type,mp4_kernel<double>> inte(particles,g_vort);
 
    // With more than 24 core we rely on the HDF5 checkpoint restart file
    if (v_cl.getProcessingUnits() < 24)
    {g_vort.write("grid_vorticity_init", VTK_WRITER | FORMAT_BINARY);}
 
 
    // Before entering the loop we check if we want to restart from
    // a previous simulation
    size_t i = 0;
 
    // if we have an argument
    if (argc > 1)
    {
        // take that argument
        std::string restart(argv[1]);
 
        // convert it into number
        i = std::stoi(restart);
 
        // load the file
        particles.load("check_point_" + std::to_string(i));
 
        // Print to inform that we are restarting from a
        // particular position
        if (v_cl.getProcessUnitID() == 0)
        {std::cout << "Restarting from " << i << std::endl;}
    }
 
    // Time Integration
    for ( ; i < 10001 ; i++)
    {
        // do step 4-5-6-7
        do_step(particles,g_vort,g_vel,g_dvort,domain,inte,phi_s,solver);
 
        // do step 8
        rk_step1(particles);
 
        // do step 9-10-11-12
        do_step(particles,g_vort,g_vel,g_dvort,domain,inte,phi_s,solver);
 
        // do step 13
        rk_step2(particles);
 
        // so step 14
        set_zero<vorticity>(g_vort);
        inte.template p2m<vorticity,vorticity>(particles,g_vort);
        g_vort.template ghost_put<add_,vorticity>();
 
        // helmotz-hodge projection
        helmotz_hodge_projection(g_vort,domain,solver,x_,false);
 
        remesh(particles,g_vort,domain);
 
        // print the step number
        if (v_cl.getProcessUnitID() == 0)
        {std::cout << "Step " << i << std::endl;}
 
        // every 100 steps write the output
        if (i % 100 == 0)       {check_point_and_save(particles,g_vort,g_vel,g_dvort,i);}
 
    }
    }
 
    openfpm_finalize();
}
 
 
#else
 
int main(int argc, char* argv[])
{
        return 0;
}
 
#endif