p2p_distr_mpi.hpp

#ifndef P2P_DISTR_MPI_HPP
#define P2P_DISTR_MPI_HPP

#include <mpi.h>

#include <vector>
#include <memory>
#include <cassert>

#include <type_traits>
#include <omp.h>
#include <algorithm>

#include "scope_timer.hpp"
#include "particles_utils.hpp"
#include "p2p_tree.hpp"
#include "lock_free_bool_array.hpp"

template <class partsize_t, class real_number>
class p2p_distr_mpi {
protected:
    static const int MaxNbRhs = 100;

    enum MpiTag{
        TAG_NB_PARTICLES,
        TAG_POSITION_PARTICLES,
        TAG_RESULT_PARTICLES,
    };

    struct NeighborDescriptor{
        partsize_t nbParticlesToExchange;
        int destProc;
        int nbLevelsToExchange;
        bool isRecv;
        bool positionsReceived;

        std::unique_ptr<real_number[]> toRecvAndMerge;
        std::unique_ptr<real_number[]> toCompute;
        std::unique_ptr<real_number[]> toData;
        std::unique_ptr<real_number[]> results;
    };

    enum Action{
        NOTHING_TODO,
        RECV_PARTICLES,
        COMPUTE_PARTICLES,
        CHECK_PARTICLES,
        RELEASE_BUFFER_PARTICLES,
        MERGE_PARTICLES,

        RECV_MOVE_NB_LOW,
        RECV_MOVE_NB_UP,
        RECV_MOVE_LOW,
        RECV_MOVE_UP
    };

    MPI_Comm current_com;

    int my_rank;
    int nb_processes;
    int nb_processes_involved;

    const std::pair<int,int> current_partition_interval;
    const int current_partition_size;
    const std::array<size_t,3> field_grid_dim;

    std::unique_ptr<int[]> partition_interval_size_per_proc;
    std::unique_ptr<int[]> partition_interval_offset_per_proc;

    std::unique_ptr<partsize_t[]> current_offset_particles_for_partition;

    std::vector<std::pair<Action,int>> whatNext;
    std::vector<MPI_Request> mpiRequests;
    std::vector<NeighborDescriptor> neigDescriptors;

    std::array<real_number,3> spatial_box_width;
    std::array<real_number,3> spatial_box_offset;

    const real_number cutoff_radius_compute;
    const int nb_cells_factor;
    const real_number cutoff_radius;
    std::array<long int,3> nb_cell_levels;

    template <class DataType, int sizeElement>
    static void permute_copy(const partsize_t offsetIdx, const partsize_t nbElements,
                             const std::pair<long int,partsize_t> permutation[],
                             DataType data[], std::vector<unsigned char>* buffer){
        buffer->resize(nbElements*sizeof(DataType)*sizeElement);
        DataType* dataBuffer = reinterpret_cast<DataType*>(buffer->data());

        // Permute
        for(partsize_t idxPart = 0 ; idxPart < nbElements ; ++idxPart){
            const partsize_t srcData = permutation[idxPart].second;
            const partsize_t destData = idxPart;
            for(int idxVal = 0 ; idxVal < sizeElement ; ++idxVal){
                dataBuffer[destData*sizeElement + idxVal]
                        = data[srcData*sizeElement + idxVal];
            }
        }

        // Copy back
        for(partsize_t idxPart = 0 ; idxPart < nbElements ; ++idxPart){
            const partsize_t srcData = idxPart;
            const partsize_t destData = idxPart+offsetIdx;
            for(int idxVal = 0 ; idxVal < sizeElement ; ++idxVal){
                data[destData*sizeElement + idxVal]
                        = dataBuffer[srcData*sizeElement + idxVal];
            }
        }
    }

    static int foundGridFactor(const real_number in_cutoff_radius, const std::array<real_number,3>& in_spatial_box_width){
        int idx_factor = 1;
        while(in_cutoff_radius <= in_spatial_box_width[IDX_Z]/real_number(idx_factor+1)){
            idx_factor += 1;
        }
        return idx_factor;
    }

public:
    ////////////////////////////////////////////////////////////////////////////

    p2p_distr_mpi(MPI_Comm in_current_com,
                     const std::pair<int,int>& in_current_partitions,
                     const std::array<size_t,3>& in_field_grid_dim,
                     const std::array<real_number,3>& in_spatial_box_width,
                     const std::array<real_number,3>& in_spatial_box_offset,
                     const real_number in_cutoff_radius)
        : current_com(in_current_com),
            my_rank(-1), nb_processes(-1),nb_processes_involved(-1),
            current_partition_interval(in_current_partitions),
            current_partition_size(current_partition_interval.second-current_partition_interval.first),
            field_grid_dim(in_field_grid_dim),
            spatial_box_width(in_spatial_box_width), spatial_box_offset(in_spatial_box_offset),
            cutoff_radius_compute(in_cutoff_radius),
            nb_cells_factor(foundGridFactor(in_cutoff_radius, in_spatial_box_width)),
            cutoff_radius(in_spatial_box_width[IDX_Z]/real_number(nb_cells_factor)){

        AssertMpi(MPI_Comm_rank(current_com, &my_rank));
        AssertMpi(MPI_Comm_size(current_com, &nb_processes));

        partition_interval_size_per_proc.reset(new int[nb_processes]);
        AssertMpi( MPI_Allgather( const_cast<int*>(&current_partition_size), 1, MPI_INT,
                                  partition_interval_size_per_proc.get(), 1, MPI_INT,
                                  current_com) );
        assert(partition_interval_size_per_proc[my_rank] == current_partition_size);

        partition_interval_offset_per_proc.reset(new int[nb_processes+1]);
        partition_interval_offset_per_proc[0] = 0;
        for(int idxProc = 0 ; idxProc < nb_processes ; ++idxProc){
            partition_interval_offset_per_proc[idxProc+1] = partition_interval_offset_per_proc[idxProc] + partition_interval_size_per_proc[idxProc];
        }

        current_offset_particles_for_partition.reset(new partsize_t[current_partition_size+1]);

        nb_processes_involved = nb_processes;
        while(nb_processes_involved != 0 && partition_interval_size_per_proc[nb_processes_involved-1] == 0){
            nb_processes_involved -= 1;
        }
        assert(nb_processes_involved != 0);
        for(int idx_proc_involved = 0 ; idx_proc_involved < nb_processes_involved ; ++idx_proc_involved){
            assert(partition_interval_size_per_proc[idx_proc_involved] != 0);
        }

        assert(int(field_grid_dim[IDX_Z]) == partition_interval_offset_per_proc[nb_processes_involved]);

        nb_cell_levels[IDX_X] = nb_cells_factor;
        nb_cell_levels[IDX_Y] = nb_cells_factor;
        nb_cell_levels[IDX_Z] = nb_cells_factor;
    }

    virtual ~p2p_distr_mpi(){}

    ////////////////////////////////////////////////////////////////////////////

    int getGridFactor() const{
        return nb_cells_factor;
    }

    real_number getGridCutoff() const{
        return cutoff_radius;
    }

    long int get_cell_coord_x_from_index(const long int index) const{
        return index % nb_cell_levels[IDX_X];
    }

    long int get_cell_coord_y_from_index(const long int index) const{
        return (index % (nb_cell_levels[IDX_X]*nb_cell_levels[IDX_Y]))
                / nb_cell_levels[IDX_X];
    }

    long int get_cell_coord_z_from_index(const long int index) const{
        return index / (nb_cell_levels[IDX_X]*nb_cell_levels[IDX_Y]);
    }

    long int first_cell_level_proc(const int dest_proc) const{
        const real_number field_section_width_z = spatial_box_width[IDX_Z]/real_number(field_grid_dim[IDX_Z]);
        return static_cast<long int>((field_section_width_z*real_number(partition_interval_offset_per_proc[dest_proc]))/cutoff_radius);
    }

    long int last_cell_level_proc(const int dest_proc) const{
        const real_number field_section_width_z = spatial_box_width[IDX_Z]/real_number(field_grid_dim[IDX_Z]);
        return static_cast<long int>((field_section_width_z*real_number(partition_interval_offset_per_proc[dest_proc+1])
                                     - std::numeric_limits<real_number>::epsilon())/cutoff_radius);
    }

    real_number apply_pbc(real_number pos, IDXS_3D dim) const{
        while( pos < spatial_box_offset[dim] ){
            pos += spatial_box_width[dim];
        }
        while( spatial_box_width[dim]+spatial_box_offset[dim] <= pos){
            pos -= spatial_box_width[dim];
        }
        return pos;
    }

    std::array<long int,3> get_cell_coordinate(const real_number pos_x, const real_number pos_y,
                                               const real_number pos_z) const {
        const real_number diff_x = apply_pbc(pos_x,IDX_X) - spatial_box_offset[IDX_X];
        const real_number diff_y = apply_pbc(pos_y,IDX_Y) - spatial_box_offset[IDX_Y];
        const real_number diff_z = apply_pbc(pos_z,IDX_Z) - spatial_box_offset[IDX_Z];
        std::array<long int,3> coord;
        coord[IDX_X] = static_cast<long int>(diff_x/cutoff_radius);
        coord[IDX_Y] = static_cast<long int>(diff_y/cutoff_radius);
        coord[IDX_Z] = static_cast<long int>(diff_z/cutoff_radius);
        return coord;
    }

    long int get_cell_idx(const real_number pos_x, const real_number pos_y,
                          const real_number pos_z) const {
        std::array<long int,3> coord = get_cell_coordinate(pos_x, pos_y, pos_z);
        return ((coord[IDX_Z]*nb_cell_levels[IDX_Y])+coord[IDX_Y])*nb_cell_levels[IDX_X]+coord[IDX_X];
    }

    real_number compute_distance_r2(const real_number x1, const real_number y1, const real_number z1,
                                    const real_number x2, const real_number y2, const real_number z2,
                                    const real_number xshift_coef, const real_number yshift_coef, const real_number zshift_coef) const {
        real_number diff_x = std::abs(apply_pbc(x1,IDX_X)-apply_pbc(x2,IDX_X)+xshift_coef*spatial_box_width[IDX_X]);
        assert(diff_x <= 2*cutoff_radius);

        real_number diff_y = std::abs(apply_pbc(y1,IDX_X)-apply_pbc(y2,IDX_X)+yshift_coef*spatial_box_width[IDX_Y]);
        assert(diff_y <= 2*cutoff_radius);

        real_number diff_z = std::abs(apply_pbc(z1,IDX_X)-apply_pbc(z2,IDX_X)+zshift_coef*spatial_box_width[IDX_Z]);
        assert(diff_z <= 2*cutoff_radius);

        return (diff_x*diff_x) + (diff_y*diff_y) + (diff_z*diff_z);
    }

    template <class computer_class, int size_particle_positions, int size_particle_data, int size_particle_rhs>
    void compute_distr(computer_class& in_computer,
                       const partsize_t current_my_nb_particles_per_partition[],
                       real_number particles_positions[],
                       real_number particles_data[],
                       real_number particles_current_rhs[],
                       partsize_t inout_index_particles[]){
        TIMEZONE("compute_distr");

        // Some processes might not be involved
        if(nb_processes_involved <= my_rank){
            return;
        }

        const long int my_top_z_cell_level = last_cell_level_proc(my_rank);
        const long int my_down_z_cell_level = first_cell_level_proc(my_rank);
        const long int my_nb_cell_levels = 1+my_top_z_cell_level-my_down_z_cell_level;

        current_offset_particles_for_partition[0] = 0;
        partsize_t myTotalNbParticles = 0;
        for(int idxPartition = 0 ; idxPartition < current_partition_size ; ++idxPartition){
            myTotalNbParticles += current_my_nb_particles_per_partition[idxPartition];
            current_offset_particles_for_partition[idxPartition+1] = current_offset_particles_for_partition[idxPartition] + current_my_nb_particles_per_partition[idxPartition];
        }

        // Compute box idx for each particle
        std::unique_ptr<long int[]> particles_coord(new long int[current_offset_particles_for_partition[current_partition_size]]);

        {
            for(int idxPartition = 0 ; idxPartition < current_partition_size ; ++idxPartition){
                #pragma omp parallel for schedule(static)
                for(partsize_t idxPart = current_offset_particles_for_partition[idxPartition] ; idxPart < current_offset_particles_for_partition[idxPartition+1] ; ++idxPart ){
                    particles_coord[idxPart] = get_cell_idx(particles_positions[(idxPart)*size_particle_positions + IDX_X],
                                                                              particles_positions[(idxPart)*size_particle_positions + IDX_Y],
                                                                              particles_positions[(idxPart)*size_particle_positions + IDX_Z]);
                    assert(my_down_z_cell_level <= get_cell_coord_z_from_index(particles_coord[idxPart]));
                    if(!(get_cell_coord_z_from_index(particles_coord[idxPart]) <= my_top_z_cell_level)){// TODO
                        printf("Coord index %ld - %ld (tree index %ld)\n", idxPart, inout_index_particles[idxPart],particles_coord[idxPart]);
                        printf(">> Box index %ld - %ld - %ld\n", get_cell_coord_x_from_index(particles_coord[idxPart]),
                               get_cell_coord_y_from_index(particles_coord[idxPart]),
                               get_cell_coord_z_from_index(particles_coord[idxPart]));
                        printf(">> idxPartition %d\n", idxPartition);
                        printf(">> my_top_z_cell_level %ld\n", my_top_z_cell_level);
                        printf(">> position %e %e %e\n", particles_positions[(idxPart)*size_particle_positions + IDX_X],
                                particles_positions[(idxPart)*size_particle_positions + IDX_Y],
                                particles_positions[(idxPart)*size_particle_positions + IDX_Z]);
                    }
                    assert(get_cell_coord_z_from_index(particles_coord[idxPart]) <= my_top_z_cell_level);
                }
            }

            std::vector<std::pair<long int,partsize_t>> part_to_sort;

            // Sort each partition in cells
            for(int idxPartition = 0 ; idxPartition < current_partition_size ; ++idxPartition){
                part_to_sort.clear();

                for(partsize_t idxPart = current_offset_particles_for_partition[idxPartition] ; idxPart < current_offset_particles_for_partition[idxPartition+1] ; ++idxPart ){
                    part_to_sort.emplace_back();
                    part_to_sort.back().first = particles_coord[idxPart];
                    part_to_sort.back().second = idxPart;
                }

                assert(part_to_sort.size() == (current_my_nb_particles_per_partition[idxPartition]));

                std::sort(part_to_sort.begin(), part_to_sort.end(),
                          [](const std::pair<long int,partsize_t>& p1,
                             const std::pair<long int,partsize_t>& p2){
                    return p1.first < p2.first;
                });

//                for(partsize_t idxPart = 1 ; idxPart < (long int)part_to_sort.size() ; ++idxPart){// TODO
//                    assert(part_to_sort[idxPart-1].first <= part_to_sort[idxPart].first);
//                }

                // Permute array using buffer
                std::vector<unsigned char> buffer;
                permute_copy<real_number, size_particle_positions>(current_offset_particles_for_partition[idxPartition],
                                                                   current_my_nb_particles_per_partition[idxPartition],
                                                                   part_to_sort.data(), particles_positions, &buffer);
                permute_copy<real_number, size_particle_data>(current_offset_particles_for_partition[idxPartition],
                                                             current_my_nb_particles_per_partition[idxPartition],
                                                             part_to_sort.data(), particles_data, &buffer);
                permute_copy<real_number, size_particle_rhs>(current_offset_particles_for_partition[idxPartition],
                                                             current_my_nb_particles_per_partition[idxPartition],
                                                             part_to_sort.data(), particles_current_rhs, &buffer);
                permute_copy<partsize_t, 1>(current_offset_particles_for_partition[idxPartition],
                                            current_my_nb_particles_per_partition[idxPartition],
                                            part_to_sort.data(), inout_index_particles, &buffer);
                permute_copy<long int, 1>(current_offset_particles_for_partition[idxPartition],
                                            current_my_nb_particles_per_partition[idxPartition],
                                            part_to_sort.data(), particles_coord.get(), &buffer);
            }
        }

        // Build the tree
        p2p_tree<std::vector<std::pair<partsize_t,partsize_t>>> my_tree(nb_cell_levels);

        for(int idxPartition = 0 ; idxPartition < current_partition_size ; ++idxPartition){
            long int current_cell_idx = -1;
            partsize_t current_nb_particles_in_cell = 0;
            partsize_t current_cell_offset = 0;

            for(partsize_t idx_part = current_offset_particles_for_partition[idxPartition] ;
                            idx_part != current_offset_particles_for_partition[idxPartition+1]; ++idx_part){
                if(particles_coord[idx_part] != current_cell_idx){
                    if(current_nb_particles_in_cell){
                        my_tree.getCell(current_cell_idx).emplace_back(current_cell_offset,current_nb_particles_in_cell);
                    }
                    current_cell_idx = particles_coord[idx_part];
                    current_nb_particles_in_cell = 1;
                    current_cell_offset = idx_part;
//                    if(inout_index_particles[idx_part] == 547){// TODO
//                        printf("idxPartition %d\n", idxPartition);
//                        printf(">> Coord index %ld - %ld (tree index %ld)\n", idx_part, inout_index_particles[idx_part],particles_coord[idx_part]);
//                        printf(">> Box index %ld - %ld - %ld\n", get_cell_coord_x_from_index(particles_coord[idx_part]),
//                               get_cell_coord_y_from_index(particles_coord[idx_part]),
//                               get_cell_coord_z_from_index(particles_coord[idx_part]));
//                        printf(">> current_cell_offset %ld current_nb_particles_in_cell %ld\n", current_cell_offset, current_nb_particles_in_cell);
//                        printf(">> Position %e %e %e\n", particles_positions[idx_part*size_particle_positions + IDX_X],
//                                particles_positions[idx_part*size_particle_positions + IDX_Y],
//                                particles_positions[idx_part*size_particle_positions + IDX_Z]);
//                    }
//                    if(inout_index_particles[idx_part] == 356){// TODO
//                        printf("idxPartition %d\n", idxPartition);
//                        printf(">> Coord index %ld - %ld (tree index %ld)\n", idx_part, inout_index_particles[idx_part],particles_coord[idx_part]);
//                        printf(">> Box index %ld - %ld - %ld\n", get_cell_coord_x_from_index(particles_coord[idx_part]),
//                               get_cell_coord_y_from_index(particles_coord[idx_part]),
//                               get_cell_coord_z_from_index(particles_coord[idx_part]));
//                        printf(">> current_cell_offset %ld current_nb_particles_in_cell %ld\n", current_cell_offset, current_nb_particles_in_cell);
//                        printf(">> Position %e %e %e\n", particles_positions[idx_part*size_particle_positions + IDX_X],
//                                particles_positions[idx_part*size_particle_positions + IDX_Y],
//                                particles_positions[idx_part*size_particle_positions + IDX_Z]);
//                    }
                }
                else{
                    current_nb_particles_in_cell += 1;
                }
            }
            if(current_nb_particles_in_cell){
                my_tree.getCell(current_cell_idx).emplace_back(current_cell_offset,current_nb_particles_in_cell);

            }
        }

//        printf("[%d] go from cutoff level %ld to %ld\n",
//               my_rank, my_down_z_cell_level, my_top_z_cell_level); // TODO remove
//        fflush(stdout); // TODO

        // Offset per cell layers
        long int previous_index = 0;
        std::unique_ptr<partsize_t[]> particles_offset_layers(new partsize_t[my_nb_cell_levels+1]());
        for(int idxPartition = 0 ; idxPartition < current_partition_size ; ++idxPartition){
            for(partsize_t idx_part = current_offset_particles_for_partition[idxPartition] ;
                            idx_part != current_offset_particles_for_partition[idxPartition+1]; ++idx_part){
                const long int part_box_z_index = get_cell_coord_z_from_index(particles_coord[idx_part]);
                assert(my_down_z_cell_level <= part_box_z_index);
                assert(part_box_z_index <= my_top_z_cell_level);
                particles_offset_layers[part_box_z_index+1-my_down_z_cell_level] += 1;
                assert(previous_index <= part_box_z_index);
                previous_index = part_box_z_index;
            }
        }
        for(long int idx_layer = 0 ; idx_layer < my_nb_cell_levels ; ++idx_layer){
//            printf("[%d] nb particles in cutoff level %ld are %ld\n",
//                   my_rank, idx_layer, particles_offset_layers[idx_layer+1]); // TODO remove
//            fflush(stdout); // TODO
            particles_offset_layers[idx_layer+1] += particles_offset_layers[idx_layer];
        }

        // Reset vectors
        assert(whatNext.size() == 0);
        assert(mpiRequests.size() == 0);
        neigDescriptors.clear();

        // Find process with at least one neighbor
        {
            std::cout << my_rank << ">>  my_top_z_cell_level " << my_top_z_cell_level << std::endl;
            std::cout << my_rank << ">>  my_down_z_cell_level " << my_down_z_cell_level << std::endl;
            std::cout.flush();// TODO

            int dest_proc = (my_rank+1)%nb_processes_involved;
            while(dest_proc != my_rank
                  && (my_top_z_cell_level == first_cell_level_proc(dest_proc)
                      || (my_top_z_cell_level+1)%nb_cell_levels[IDX_Z] == first_cell_level_proc(dest_proc))){
                // Find if we have to send 1 or 2 cell levels
                int nb_levels_to_send = 1;
                if(my_nb_cell_levels > 1 // I have more than one level
                        && (my_top_z_cell_level-1+2)%nb_cell_levels[IDX_Z] <= last_cell_level_proc(dest_proc)){
                    nb_levels_to_send += 1;
                }

                std::cout << my_rank << " dest_proc " << dest_proc << std::endl;
                std::cout << my_rank << ">> first_cell_level_proc(dest_proc) " << first_cell_level_proc(dest_proc) << std::endl;
                std::cout << my_rank << ">> last_cell_level_proc(dest_proc) " << last_cell_level_proc(dest_proc) << std::endl;
                std::cout.flush();// TODO

                NeighborDescriptor descriptor;
                descriptor.destProc = dest_proc;
                descriptor.nbLevelsToExchange = nb_levels_to_send;
                descriptor.nbParticlesToExchange = particles_offset_layers[my_nb_cell_levels] - particles_offset_layers[my_nb_cell_levels-nb_levels_to_send];
                descriptor.isRecv = false;
                descriptor.positionsReceived = false;

                std::cout << my_rank << " SEND" << std::endl;
                std::cout << ">> descriptor.destProc " << descriptor.destProc << std::endl;
                std::cout << ">> descriptor.nbLevelsToExchange " << descriptor.nbLevelsToExchange << std::endl;
                std::cout << ">> descriptor.nbParticlesToExchange " << descriptor.nbParticlesToExchange << std::endl;
                std::cout << ">> descriptor.isRecv " << descriptor.isRecv << std::endl;
                std::cout << ">> neigDescriptors.size() " << neigDescriptors.size() << std::endl;
                std::cout.flush();// TODO

                neigDescriptors.emplace_back(std::move(descriptor));

                dest_proc = (dest_proc+1)%nb_processes_involved;
            }
            std::cout << my_rank << " NO dest_proc " << dest_proc << std::endl;
            std::cout << my_rank << " NO first_cell_level_proc(dest_proc) " << first_cell_level_proc(dest_proc) << std::endl;
            std::cout.flush();// TODO

            int src_proc = (my_rank-1+nb_processes_involved)%nb_processes_involved;
            while(src_proc != my_rank
                  && (last_cell_level_proc(src_proc) == my_down_z_cell_level
                      || (last_cell_level_proc(src_proc)+1)%nb_cell_levels[IDX_Z] == my_down_z_cell_level)){
                // Find if we have to send 1 or 2 cell levels
                int nb_levels_to_recv = 1;
                if(my_nb_cell_levels > 1 // I have more than one level
                        && first_cell_level_proc(src_proc) <= (my_down_z_cell_level-1+2)%nb_cell_levels[IDX_Z]){
                    nb_levels_to_recv += 1;
                }

                std::cout << my_rank << " src_proc " << src_proc << std::endl;
                std::cout << my_rank << " first_cell_level_proc(src_proc) " << first_cell_level_proc(src_proc) << std::endl;
                std::cout.flush();// TODO

                NeighborDescriptor descriptor;
                descriptor.destProc = src_proc;
                descriptor.nbLevelsToExchange = nb_levels_to_recv;
                descriptor.nbParticlesToExchange = -1;
                descriptor.isRecv = true;
                descriptor.positionsReceived = false;

                neigDescriptors.emplace_back(std::move(descriptor));

                std::cout << my_rank << "] RECV" << std::endl;
                std::cout << ">> descriptor.destProc " << descriptor.destProc << std::endl;
                std::cout << ">> descriptor.nbLevelsToExchange " << descriptor.nbLevelsToExchange << std::endl;
                std::cout << ">> descriptor.nbParticlesToExchange " << descriptor.nbParticlesToExchange << std::endl;
                std::cout << ">> descriptor.nbParticlesToExchange " << descriptor.nbParticlesToExchange << std::endl;
                std::cout << ">> descriptor.isRecv " << descriptor.isRecv << std::endl;
                std::cout << ">> neigDescriptors.size() " << neigDescriptors.size() << std::endl;
                std::cout.flush();// TODO

                src_proc = (src_proc-1+nb_processes_involved)%nb_processes_involved;
            }
            std::cout << my_rank << " NO src_proc " << src_proc << std::endl;
            std::cout << my_rank << " NO first_cell_level_proc(src_proc) " << first_cell_level_proc(src_proc) << std::endl;
            std::cout.flush();// TODO
        }

        //////////////////////////////////////////////////////////////////////
        /// Exchange the number of particles in each partition
        /// Could involve only here but I do not think it will be a problem
        //////////////////////////////////////////////////////////////////////

        assert(whatNext.size() == 0);
        assert(mpiRequests.size() == 0);


        for(int idxDescr = 0 ; idxDescr < int(neigDescriptors.size()) ; ++idxDescr){
            NeighborDescriptor& descriptor = neigDescriptors[idxDescr];

            if(descriptor.isRecv == false){
                whatNext.emplace_back(std::pair<Action,int>{NOTHING_TODO, -1});
                mpiRequests.emplace_back();
                AssertMpi(MPI_Isend(const_cast<partsize_t*>(&descriptor.nbParticlesToExchange),
                                    1, particles_utils::GetMpiType(partsize_t()),
                                    descriptor.destProc, TAG_NB_PARTICLES,
                                    current_com, &mpiRequests.back()));

                if(descriptor.nbParticlesToExchange){
//                    std::cout << my_rank << "] SEND_PARTICLES" << std::endl;
//                    std::cout << "descriptor.nbParticlesToExchange " << descriptor.nbParticlesToExchange << std::endl;
//                    std::cout << "descriptor.destProc " << descriptor.destProc << std::endl;
//                    std::cout << "idxDescr " << idxDescr << std::endl;
//                    std::cout << "send from part " << particles_offset_layers[my_nb_cell_levels-descriptor.nbLevelsToExchange] << std::endl;

                    whatNext.emplace_back(std::pair<Action,int>{NOTHING_TODO, -1});
                    mpiRequests.emplace_back();
                    assert(descriptor.nbParticlesToExchange*size_particle_positions < std::numeric_limits<int>::max());
                    AssertMpi(MPI_Isend(const_cast<real_number*>(&particles_positions[particles_offset_layers[my_nb_cell_levels-descriptor.nbLevelsToExchange]*size_particle_positions]),
                              int(descriptor.nbParticlesToExchange*size_particle_positions), particles_utils::GetMpiType(real_number()),
                              descriptor.destProc, TAG_POSITION_PARTICLES,
                              current_com, &mpiRequests.back()));

                    whatNext.emplace_back(std::pair<Action,int>{NOTHING_TODO, -1});
                    mpiRequests.emplace_back();
                    assert(descriptor.nbParticlesToExchange*size_particle_data < std::numeric_limits<int>::max());
                    AssertMpi(MPI_Isend(const_cast<real_number*>(&particles_data[particles_offset_layers[my_nb_cell_levels-descriptor.nbLevelsToExchange]*size_particle_data]),
                              int(descriptor.nbParticlesToExchange*size_particle_data), particles_utils::GetMpiType(real_number()),
                              descriptor.destProc, TAG_POSITION_PARTICLES,
                              current_com, &mpiRequests.back()));

                    assert(descriptor.toRecvAndMerge == nullptr);
                    descriptor.toRecvAndMerge.reset(new real_number[descriptor.nbParticlesToExchange*size_particle_rhs]);
                    whatNext.emplace_back(std::pair<Action,int>{MERGE_PARTICLES, idxDescr});
                    mpiRequests.emplace_back();
                    assert(descriptor.nbParticlesToExchange*size_particle_rhs < std::numeric_limits<int>::max());
                    AssertMpi(MPI_Irecv(descriptor.toRecvAndMerge.get(), int(descriptor.nbParticlesToExchange*size_particle_rhs),
                                        particles_utils::GetMpiType(real_number()), descriptor.destProc, TAG_RESULT_PARTICLES,
                                        current_com, &mpiRequests.back()));
                }
            }
            else{
//                std::cout << "RECV_PARTICLES " << RECV_PARTICLES << std::endl;
//                std::cout << "idxDescr " << idxDescr << std::endl;
                whatNext.emplace_back(std::pair<Action,int>{RECV_PARTICLES, idxDescr});
                mpiRequests.emplace_back();
                AssertMpi(MPI_Irecv(&descriptor.nbParticlesToExchange,
                      1, particles_utils::GetMpiType(partsize_t()), descriptor.destProc, TAG_NB_PARTICLES,
                      current_com, &mpiRequests.back()));
            }
        }

        lock_free_bool_array cells_locker(512);

        TIMEZONE_OMP_INIT_PREPARALLEL(omp_get_max_threads())
        #pragma omp parallel default(shared)
        {
            #pragma omp master
            {
                while(mpiRequests.size()){
                    TIMEZONE("wait-loop");
                    assert(mpiRequests.size() == whatNext.size());

                    int idxDone = int(mpiRequests.size());
                    {
                        TIMEZONE("wait");
                        AssertMpi(MPI_Waitany(int(mpiRequests.size()), mpiRequests.data(), &idxDone, MPI_STATUSES_IGNORE));
                    }
                    const std::pair<Action, int> releasedAction = whatNext[idxDone];
                    std::swap(mpiRequests[idxDone], mpiRequests[mpiRequests.size()-1]);
                    std::swap(whatNext[idxDone], whatNext[mpiRequests.size()-1]);
                    mpiRequests.pop_back();
                    whatNext.pop_back();

                    //////////////////////////////////////////////////////////////////////
                    /// Data to exchange particles
                    //////////////////////////////////////////////////////////////////////
                    if(releasedAction.first == RECV_PARTICLES){
                        TIMEZONE("post-recv-particles");
                        NeighborDescriptor& descriptor = neigDescriptors[releasedAction.second];
                        assert(descriptor.isRecv);
                        const int destProc = descriptor.destProc;
                        const partsize_t NbParticlesToReceive = descriptor.nbParticlesToExchange;
                        assert(NbParticlesToReceive != -1);
                        assert(descriptor.toCompute == nullptr);

//                        std::cout << my_rank << "] RECV_PARTICLES" << std::endl;
//                        std::cout << "descriptor.nbParticlesToExchange " << descriptor.nbParticlesToExchange << std::endl;
//                        std::cout << "descriptor.destProc " << descriptor.destProc << std::endl;
//                        std::cout << "releasedAction.second " << releasedAction.second << std::endl;

                        if(NbParticlesToReceive){
//                            std::cout << "MPI_Irecv " << std::endl;
                            descriptor.toCompute.reset(new real_number[NbParticlesToReceive*size_particle_positions]);
                            whatNext.emplace_back(std::pair<Action,int>{CHECK_PARTICLES, releasedAction.second});
                            mpiRequests.emplace_back();
                            assert(NbParticlesToReceive*size_particle_positions < std::numeric_limits<int>::max());
                            AssertMpi(MPI_Irecv(descriptor.toCompute.get(), int(NbParticlesToReceive*size_particle_positions),
                                                particles_utils::GetMpiType(real_number()), destProc, TAG_POSITION_PARTICLES,
                                                current_com, &mpiRequests.back()));


                            descriptor.toData.reset(new real_number[NbParticlesToReceive*size_particle_data]);
                            whatNext.emplace_back(std::pair<Action,int>{COMPUTE_PARTICLES, releasedAction.second});
                            mpiRequests.emplace_back();
                            assert(NbParticlesToReceive*size_particle_data < std::numeric_limits<int>::max());
                            AssertMpi(MPI_Irecv(descriptor.toData.get(), int(NbParticlesToReceive*size_particle_data),
                                                particles_utils::GetMpiType(real_number()), destProc, TAG_POSITION_PARTICLES,
                                                current_com, &mpiRequests.back()));
                        }
                    }

                    //////////////////////////////////////////////////////////////////////
                    /// Computation
                    //////////////////////////////////////////////////////////////////////
                    if(releasedAction.first == COMPUTE_PARTICLES){
                        TIMEZONE("compute-particles");
                        NeighborDescriptor& descriptor = neigDescriptors[releasedAction.second];
                        assert(descriptor.isRecv);
                        const partsize_t NbParticlesToReceive = descriptor.nbParticlesToExchange;

                        assert(descriptor.toCompute != nullptr);
                        assert(descriptor.toData != nullptr);
                        assert(descriptor.positionsReceived == true);
                        descriptor.results.reset(new real_number[NbParticlesToReceive*size_particle_rhs]);
                        in_computer.template init_result_array<size_particle_rhs>(descriptor.results.get(), NbParticlesToReceive);

                        // Compute
                        partsize_t idxPart = 0;
                        while(idxPart != NbParticlesToReceive){
                            const long int current_cell_idx = get_cell_idx(descriptor.toCompute[idxPart*size_particle_positions + IDX_X],
                                                                           descriptor.toCompute[idxPart*size_particle_positions + IDX_Y],
                                                                           descriptor.toCompute[idxPart*size_particle_positions + IDX_Z]);
                            partsize_t nb_parts_in_cell = 1;
                            while(idxPart+nb_parts_in_cell != NbParticlesToReceive
                                  && current_cell_idx == get_cell_idx(descriptor.toCompute[(idxPart+nb_parts_in_cell)*size_particle_positions + IDX_X],
                                                                     descriptor.toCompute[(idxPart+nb_parts_in_cell)*size_particle_positions + IDX_Y],
                                                                     descriptor.toCompute[(idxPart+nb_parts_in_cell)*size_particle_positions + IDX_Z])){
                                nb_parts_in_cell += 1;
                            }

                            #pragma omp task default(shared) firstprivate(idxPart, nb_parts_in_cell, current_cell_idx)
                            {
                                const std::vector<std::pair<partsize_t,partsize_t>>* neighbors[27];
                                long int neighbors_indexes[27];
                                std::array<real_number,3> shift[27];
                                const int nbNeighbors = my_tree.getNeighbors(current_cell_idx, neighbors, neighbors_indexes, shift, true);

//                            for(int idx_test = 0 ; idx_test < nb_parts_in_cell ; ++idx_test){ // TODO
//                                real_number totest[3] = {8.570442e-01, 7.173084e-02, 8.279754e-03};
//                                if(int(descriptor.toCompute[(idxPart+idx_test)*size_particle_positions + IDX_X]*1000) == int(totest[0]*1000)
//                                        && int(descriptor.toCompute[(idxPart+idx_test)*size_particle_positions + IDX_Y]*1000) == int(totest[1]*1000)
//                                        && int(descriptor.toCompute[(idxPart+idx_test)*size_particle_positions + IDX_Z]*1000) == int(totest[2]*1000)){
//                                    printf("Found a pos %ld\n", idxPart+idx_test);
//                                    printf("pos %e %e %e\n",
//                                           descriptor.toCompute[(idxPart+idx_test)*size_particle_positions + IDX_X],
//                                            descriptor.toCompute[(idxPart+idx_test)*size_particle_positions + IDX_Y],
//                                            descriptor.toCompute[(idxPart+idx_test)*size_particle_positions + IDX_Z]);
//                                }
//                            }

                                // with other interval
                                for(size_t idx_neighbor = 0 ; idx_neighbor < nbNeighbors ; ++idx_neighbor){
                                    cells_locker.lock(neighbors_indexes[idx_neighbor]);

                                    for(size_t idx_2 = 0 ; idx_2 < (*neighbors[idx_neighbor]).size() ; ++idx_2){
                                        for(partsize_t idx_p1 = 0 ; idx_p1 < nb_parts_in_cell ; ++idx_p1){
                                            for(partsize_t idx_p2 = 0 ; idx_p2 < (*neighbors[idx_neighbor])[idx_2].second ; ++idx_p2){
                                                const real_number dist_r2 = compute_distance_r2(descriptor.toCompute[(idxPart+idx_p1)*size_particle_positions + IDX_X],
                                                                                                descriptor.toCompute[(idxPart+idx_p1)*size_particle_positions + IDX_Y],
                                                                                                descriptor.toCompute[(idxPart+idx_p1)*size_particle_positions + IDX_Z],
                                                                                                particles_positions[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_positions + IDX_X],
                                                                                                particles_positions[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_positions + IDX_Y],
                                                                                                particles_positions[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_positions + IDX_Z],
                                                                                                shift[idx_neighbor][IDX_X], shift[idx_neighbor][IDX_Y], shift[idx_neighbor][IDX_Z]);
                                                if(dist_r2 < cutoff_radius_compute*cutoff_radius_compute){
                                                    in_computer.template compute_interaction<size_particle_positions,size_particle_data, size_particle_rhs>(
                                                                        &descriptor.toCompute[(idxPart+idx_p1)*size_particle_positions],
                                                                        &descriptor.toData[(idxPart+idx_p1)*size_particle_data],
                                                                        &descriptor.results[(idxPart+idx_p1)*size_particle_rhs],
                                                                        &particles_positions[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_positions],
                                                                        &particles_data[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_data],
                                                                        &particles_current_rhs[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_rhs],
                                                                        dist_r2, shift[idx_neighbor][IDX_X], shift[idx_neighbor][IDX_Y], shift[idx_neighbor][IDX_Z]);
                                                }

    //                                            if(inout_index_particles[(*neighbors[idx_neighbor])[idx_2].first+idx_p2] == 356){// TODO
    //                                                printf("test interaction between :\n");
    //                                                printf("index %ld (%ld) pos %e %e %e\n",
    //                                                       (idxPart+idx_p1), -1L,
    //                                                       descriptor.toCompute[(idxPart+idx_p1)*size_particle_positions + IDX_X],
    //                                                       descriptor.toCompute[(idxPart+idx_p1)*size_particle_positions + IDX_Y],
    //                                                       descriptor.toCompute[(idxPart+idx_p1)*size_particle_positions + IDX_Z]);
    //                                                printf("index %ld (%ld) pos %e %e %e\n",
    //                                                       ((*neighbors[idx_neighbor])[idx_2].first+idx_p2),
    //                                                       inout_index_particles[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)],
    //                                                       particles_positions[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_positions + IDX_X],
    //                                                       particles_positions[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_positions + IDX_Y],
    //                                                       particles_positions[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_positions + IDX_Z]);
    //                                                printf("Radius = %e (%e)\n", sqrt(dist_r2), dist_r2);
    //                                            }
                                            }
                                        }
                                    }

                                    cells_locker.unlock(neighbors_indexes[idx_neighbor]);
                                }
                            }

                            idxPart += nb_parts_in_cell;
                        }

                        #pragma omp taskwait

                        // Send back
                        const int destProc = descriptor.destProc;
                        whatNext.emplace_back(std::pair<Action,int>{RELEASE_BUFFER_PARTICLES, releasedAction.second});
                        mpiRequests.emplace_back();
                        assert(NbParticlesToReceive*size_particle_rhs < std::numeric_limits<int>::max());
                        AssertMpi(MPI_Isend(descriptor.results.get(), int(NbParticlesToReceive*size_particle_rhs),
                                            particles_utils::GetMpiType(real_number()), destProc, TAG_RESULT_PARTICLES,
                                            current_com, &mpiRequests.back()));
                    }
                    //////////////////////////////////////////////////////////////////////
                    /// Computation
                    //////////////////////////////////////////////////////////////////////
                    if(releasedAction.first == CHECK_PARTICLES){
                        NeighborDescriptor& descriptor = neigDescriptors[releasedAction.second];
                        assert(descriptor.toCompute != nullptr);
                        assert(descriptor.isRecv);
                        descriptor.positionsReceived = true;
                    }
                    //////////////////////////////////////////////////////////////////////
                    /// Computation
                    //////////////////////////////////////////////////////////////////////
                    if(releasedAction.first == RELEASE_BUFFER_PARTICLES){
                        NeighborDescriptor& descriptor = neigDescriptors[releasedAction.second];
                        assert(descriptor.toCompute != nullptr);
                        assert(descriptor.isRecv);
                        descriptor.toCompute.release();
                    }
                    //////////////////////////////////////////////////////////////////////
                    /// Merge
                    //////////////////////////////////////////////////////////////////////
                    if(releasedAction.first == MERGE_PARTICLES){
                        TIMEZONE("merge");
                        NeighborDescriptor& descriptor = neigDescriptors[releasedAction.second];
                        assert(descriptor.isRecv == false);
                        assert(descriptor.toRecvAndMerge != nullptr);
                        in_computer.template reduce_particles_rhs<size_particle_rhs>(&particles_current_rhs[particles_offset_layers[my_nb_cell_levels-descriptor.nbLevelsToExchange]*size_particle_rhs],
                                descriptor.toRecvAndMerge.get(), descriptor.nbParticlesToExchange);
                        descriptor.toRecvAndMerge.release();
                    }
                }
            }
        }

        assert(whatNext.size() == 0);
        assert(mpiRequests.size() == 0);

        // Compute self data
        for(const auto& iter_cell : my_tree){
            TIMEZONE("proceed-leaf");
            const long int currenct_cell_idx = iter_cell.first;
            const std::vector<std::pair<partsize_t,partsize_t>>* intervals_ptr = &iter_cell.second;

#pragma omp task default(shared) firstprivate(currenct_cell_idx, intervals_ptr)
            {
                const std::vector<std::pair<partsize_t,partsize_t>>& intervals = (*intervals_ptr);

                cells_locker.lock(currenct_cell_idx);

                for(size_t idx_1 = 0 ; idx_1 < intervals.size() ; ++idx_1){
                    // self interval
                    for(partsize_t idx_p1 = 0 ; idx_p1 < intervals[idx_1].second ; ++idx_p1){
    //                    if(((inout_index_particles[(intervals[idx_1].first+idx_p1)] == 356))){// TODO
    //                        printf("box %ld:\n", iter_cell.first);
    //                        printf("intervals.size() %lu:\n", intervals.size());
    //                        printf("intervals[idx_1].second %ld:\n", intervals[idx_1].second);
    //                        printf("index %ld (%ld) pos %e %e %e\n",
    //                               (intervals[idx_1].first+idx_p1), inout_index_particles[(intervals[idx_1].first+idx_p1)],
    //                               particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_X],
    //                               particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_Y],
    //                               particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_Z]);
    //                    }
    //                    if(((inout_index_particles[(intervals[idx_1].first+idx_p1)] == 547))){// TODO
    //                        printf("box %ld:\n", iter_cell.first);
    //                        printf("intervals.size() %lu:\n", intervals.size());
    //                        printf("intervals[idx_1].second %ld:\n", intervals[idx_1].second);
    //                        printf("index %ld (%ld) pos %e %e %e\n",
    //                               (intervals[idx_1].first+idx_p1), inout_index_particles[(intervals[idx_1].first+idx_p1)],
    //                               particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_X],
    //                               particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_Y],
    //                               particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_Z]);
    //                    }


                        for(partsize_t idx_p2 = idx_p1+1 ; idx_p2 < intervals[idx_1].second ; ++idx_p2){
                            const real_number dist_r2 = compute_distance_r2(particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_X],
                                                                            particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_Y],
                                                                            particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_Z],
                                                                            particles_positions[(intervals[idx_1].first+idx_p2)*size_particle_positions + IDX_X],
                                                                            particles_positions[(intervals[idx_1].first+idx_p2)*size_particle_positions + IDX_Y],
                                                                            particles_positions[(intervals[idx_1].first+idx_p2)*size_particle_positions + IDX_Z],
                                                                            0, 0, 0);
                            if(dist_r2 < cutoff_radius_compute*cutoff_radius_compute){
                                in_computer.template compute_interaction<size_particle_positions,size_particle_data,size_particle_rhs>(
                                                    &particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions],
                                                    &particles_data[(intervals[idx_1].first+idx_p1)*size_particle_data],
                                                    &particles_current_rhs[(intervals[idx_1].first+idx_p1)*size_particle_rhs],
                                                    &particles_positions[(intervals[idx_1].first+idx_p2)*size_particle_positions],
                                                    &particles_data[(intervals[idx_1].first+idx_p2)*size_particle_data],
                                                    &particles_current_rhs[(intervals[idx_1].first+idx_p2)*size_particle_rhs],
                                                    dist_r2, 0, 0, 0);
                            }

    //                        if(((inout_index_particles[(intervals[idx_1].first+idx_p1)] == 356)
    //                                || inout_index_particles[(intervals[idx_1].first+idx_p2)] == 356)/*
    //                                && ((inout_index_particles[(intervals[idx_1].first+idx_p1)] == 1832)
    //                                    || inout_index_particles[(intervals[idx_1].first+idx_p2)] == 1832)
    //                                && ((inout_index_particles[(intervals[idx_1].first+idx_p1)] == 547)
    //                                    || inout_index_particles[(intervals[idx_1].first+idx_p2)] == 547)*/){// TODO
    //                            printf("print between :\n");
    //                            printf("index %ld (%ld) pos %e %e %e\n",
    //                                   (intervals[idx_1].first+idx_p1), inout_index_particles[(intervals[idx_1].first+idx_p1)],
    //                                   particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_X],
    //                                   particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_Y],
    //                                   particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_Z]);
    //                            printf("index %ld (%ld) pos %e %e %e\n",
    //                                   (intervals[idx_1].first+idx_p2),
    //                                   inout_index_particles[(intervals[idx_1].first+idx_p2)],
    //                                   particles_positions[(intervals[idx_1].first+idx_p2)*size_particle_positions + IDX_X],
    //                                   particles_positions[(intervals[idx_1].first+idx_p2)*size_particle_positions + IDX_Y],
    //                                   particles_positions[(intervals[idx_1].first+idx_p2)*size_particle_positions + IDX_Z]);
    //                            printf("Radius = %e (%e)\n", sqrt(dist_r2), dist_r2);
    //                        }
                        }
                    }

                    // with other interval
                    for(size_t idx_2 = idx_1+1 ; idx_2 < intervals.size() ; ++idx_2){
                        for(partsize_t idx_p1 = 0 ; idx_p1 < intervals[idx_1].second ; ++idx_p1){
                            for(partsize_t idx_p2 = 0 ; idx_p2 < intervals[idx_2].second ; ++idx_p2){
                                const real_number dist_r2 = compute_distance_r2(particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_X],
                                                                                particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_Y],
                                                                                particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_Z],
                                                                                particles_positions[(intervals[idx_2].first+idx_p2)*size_particle_positions + IDX_X],
                                                                                particles_positions[(intervals[idx_2].first+idx_p2)*size_particle_positions + IDX_Y],
                                                                                particles_positions[(intervals[idx_2].first+idx_p2)*size_particle_positions + IDX_Z],
                                                                                0, 0, 0);
                                if(dist_r2 < cutoff_radius_compute*cutoff_radius_compute){
                                    in_computer.template compute_interaction<size_particle_positions,size_particle_data,size_particle_rhs>(
                                                        &particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions],
                                                        &particles_data[(intervals[idx_1].first+idx_p1)*size_particle_data],
                                                        &particles_current_rhs[(intervals[idx_1].first+idx_p1)*size_particle_rhs],
                                                        &particles_positions[(intervals[idx_2].first+idx_p2)*size_particle_positions],
                                                        &particles_data[(intervals[idx_2].first+idx_p2)*size_particle_data],
                                                        &particles_current_rhs[(intervals[idx_2].first+idx_p2)*size_particle_rhs],
                                                        dist_r2, 0, 0, 0);
                                }

    //                            if(((inout_index_particles[(intervals[idx_1].first+idx_p1)] == 356)
    //                                    || inout_index_particles[(intervals[idx_2].first+idx_p2)] == 356)/*
    //                                    && ((inout_index_particles[(intervals[idx_1].first+idx_p1)] == 547)
    //                                        || inout_index_particles[(intervals[idx_2].first+idx_p2)] == 547)
    //                                    && ((inout_index_particles[(intervals[idx_1].first+idx_p1)] == 1832)
    //                                        || inout_index_particles[(intervals[idx_2].first+idx_p2)] == 1832)*/){// TODO
    //                                printf("print between :\n");
    //                                printf("index %ld (%ld) pos %e %e %e\n",
    //                                       (intervals[idx_1].first+idx_p1), inout_index_particles[(intervals[idx_1].first+idx_p1)],
    //                                       particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_X],
    //                                       particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_Y],
    //                                       particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_Z]);
    //                                printf("index %ld (%ld) pos %e %e %e\n",
    //                                       (intervals[idx_2].first+idx_p2),
    //                                       inout_index_particles[(intervals[idx_2].first+idx_p2)],
    //                                       particles_positions[(intervals[idx_2].first+idx_p2)*size_particle_positions + IDX_X],
    //                                       particles_positions[(intervals[idx_2].first+idx_p2)*size_particle_positions + IDX_Y],
    //                                       particles_positions[(intervals[idx_2].first+idx_p2)*size_particle_positions + IDX_Z]);
    //                                printf("Radius = %e (%e)\n", sqrt(dist_r2), dist_r2);
    //                            }
                            }
                        }
                    }
                }

                const std::vector<std::pair<partsize_t,partsize_t>>* neighbors[27];
                long int neighbors_indexes[27];
                std::array<real_number,3> shift[27];
                const int nbNeighbors = my_tree.getNeighbors(currenct_cell_idx, neighbors, neighbors_indexes, shift, false);

    //            if(((currenct_cell_idx == 785))){// TODO
    //                printf("box %ld:\n", iter_cell.first);
    //                printf("intervals.size() %lu:\n", intervals.size());
    //                printf("nbNeighbors %d\n",nbNeighbors);
    //            }

                for(size_t idx_1 = 0 ; idx_1 < intervals.size() ; ++idx_1){
                    // with other interval
                    for(size_t idx_neighbor = 0 ; idx_neighbor < nbNeighbors ; ++idx_neighbor){
                        if(currenct_cell_idx < neighbors_indexes[idx_neighbor]){
                            cells_locker.lock(neighbors_indexes[idx_neighbor]);

                            for(size_t idx_2 = 0 ; idx_2 < (*neighbors[idx_neighbor]).size() ; ++idx_2){
                                for(partsize_t idx_p1 = 0 ; idx_p1 < intervals[idx_1].second ; ++idx_p1){
                                    for(partsize_t idx_p2 = 0 ; idx_p2 < (*neighbors[idx_neighbor])[idx_2].second ; ++idx_p2){
                                        const real_number dist_r2 = compute_distance_r2(particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_X],
                                                                                        particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_Y],
                                                                                        particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_Z],
                                                                                        particles_positions[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_positions + IDX_X],
                                                                                        particles_positions[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_positions + IDX_Y],
                                                                                        particles_positions[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_positions + IDX_Z],
                                                                                        shift[idx_neighbor][IDX_X], shift[idx_neighbor][IDX_Y], shift[idx_neighbor][IDX_Z]);
                                        if(dist_r2 < cutoff_radius_compute*cutoff_radius_compute){
                                            in_computer.template compute_interaction<size_particle_positions,size_particle_data,size_particle_rhs>(
                                                                &particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions],
                                                                &particles_data[(intervals[idx_1].first+idx_p1)*size_particle_data],
                                                                &particles_current_rhs[(intervals[idx_1].first+idx_p1)*size_particle_rhs],
                                                                &particles_positions[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_positions],
                                                                &particles_data[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_data],
                                                                &particles_current_rhs[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_rhs],
                                                                dist_r2, shift[idx_neighbor][IDX_X], shift[idx_neighbor][IDX_Y], shift[idx_neighbor][IDX_Z]);
                                        }

    //                                    if(((inout_index_particles[(intervals[idx_1].first+idx_p1)] == 356)
    //                                            || inout_index_particles[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)] == 356)/*
    //                                        && (inout_index_particles[(intervals[idx_1].first+idx_p1)] == 547)
    //                                            || inout_index_particles[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)] == 547
    //                                        && (inout_index_particles[(intervals[idx_1].first+idx_p1)] == 1832)
    //                                            || inout_index_particles[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)] == 1832*/){// TODO
    //                                        printf("print between :\n");
    //                                        printf("index %ld (%ld) pos %e %e %e\n",
    //                                               (intervals[idx_1].first+idx_p1), inout_index_particles[(intervals[idx_1].first+idx_p1)],
    //                                               particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_X],
    //                                               particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_Y],
    //                                               particles_positions[(intervals[idx_1].first+idx_p1)*size_particle_positions + IDX_Z]);
    //                                        printf("index %ld (%ld) pos %e %e %e\n",
    //                                               ((*neighbors[idx_neighbor])[idx_2].first+idx_p2),
    //                                               inout_index_particles[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)],
    //                                               particles_positions[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_positions + IDX_X],
    //                                               particles_positions[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_positions + IDX_Y],
    //                                               particles_positions[((*neighbors[idx_neighbor])[idx_2].first+idx_p2)*size_particle_positions + IDX_Z]);
    //                                        printf("Radius = %e (%e)\n", sqrt(dist_r2), dist_r2);
    //                                    }
                                    }
                                }
                            }
                            cells_locker.unlock(neighbors_indexes[idx_neighbor]);
                        }
                    }
                }

                cells_locker.unlock(currenct_cell_idx);
            }
        }
    }
};

#endif