Z_Tree.h

#pragma once
 
#include <stdint.h>
#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <map>
#include "eigen_matrix_defs.h"
#include "compact_data_representations.h"
#include <malloc.h>
#include <random>
#include <thread>
#include <mutex>
#include <condition_variable>
 
namespace Fish{
class IndividualFish;
}
 
namespace Grid
{
    typedef uint64_t bit64;
    typedef uint32_t bit32;
    typedef uint16_t bit16;
    typedef uint8_t  bit8;
 
    typedef int64_t int64;
    typedef int32_t int32;
    typedef int16_t int16;
    typedef int8_t  int8;
 
    typedef std::mt19937 rng_type;
 
/*
\class FastNeighbourLookup
    "Close-neighbour" lookup structure, based on the 3-Dimensional Z-curve (or Morton index).
    Object are sorted according to their Z index value.
    This keeps spatially close elements close or "often close" in a statistical and cache friendly way
*/
class FastNeighbourLookup {
public:
 
    static const int max_num_neigbours = 5;     // BS: 5 set by Martin Føre
    FastNeighbourLookup(){}
    ~FastNeighbourLookup();
    void Init(int num_individuals);
 
    /*
        gives indices of a set of all or some of the 'close' neighbors to to given my_index
    */
    int SelectedNeigbours(int my_index, int neigbour_indices[max_num_neigbours], Fish::vec3& density_gradient);
 
    /*
        spawns a new thread to update neighbour lookup structure
    */
    void AsyncUpdate(std::vector<Fish::IndividualFish>& individuals, const double* const X);
 
    /*
        has the previous AsyncUpdate completed?
    */
    bool AsyncUpdateIsComplete();
 
    /*
        returns the new Z-based ordering for the index lookup
        elements must be sorted according to this ordering for the lookup results to be correct
        the value "array[i]" denotes the new position of the previous element "i"
    */
    std::vector<int>& SortedZcurveOrdering();
 
 
private:
    void Update();
 
    std::vector<int> m_sorted_Z_curve_ordering;
    std::vector<int> m_inverse_sorted_Z_curve_ordering;
 
 
    struct Particle {
        Particle(){}
        Particle(const Fish::vec3& p, const Fish::vec3& v, int n);
 
        static bit32 expand(bit32 a);
        static bit32 make_Z_index(bit8 X, bit8 Y, bit8 Z);
        static bit32 make_Z_index(const Eigen::Vector3d & P);
        void make_Z_index() {
            Z_index = make_Z_index(P);//bit8(P.x()),bit8(P.y()),bit8(P.z()));
        }
 
        Eigen::Matrix<bit8, 3, 1> decompress_Z_index();
 
        //CompactData::Position P;
        //bit8 x;
        //bit8 y;
        //bit8 z;
        Eigen::Vector3d P;
        Eigen::Vector3d V;
        bit32 Z_index;
        int N_index;
    };
 
    std::vector<Particle> m_particle_temp_buffer; // temporary sorting buffer
    std::vector<Particle> m_particle; // position particles, sorted by Z_index
 
    std::vector<bit32>  m_Z_map; // direct lookup map from Z-index to end index of cell
    std::vector<bit32>  m_Cell; // compressed Z-map, with Zero cells omitted. index of first particle in cell
    std::vector<int> m_neighbour_fast_map; // working buffer
    
    struct neighbour_set {
        neighbour_set() {for(int i = 0; i < max_num_neigbours; ++i){ix[i]=-1;}num = 0;density_gradient_unit.setZero();}
        int ix[max_num_neigbours];
        int num;
        Eigen::Vector3d density_gradient_unit;
    };
 
    std::vector<neighbour_set> m_neighbours_buffer1;
    std::vector<neighbour_set> m_neighbours_buffer2;
 
    neighbour_set* read_buffer;
    neighbour_set* write_buffer;
 
    void UpdateWorkingLoop();
    enum async_state {IDLE, WORKING, TERMINATING};                  
    async_state                 m_async_state;
 
    std::mutex                  m_async_mutex;
    std::thread                 m_async_thread;
    std::condition_variable     m_async_condition_variable;
 
    rng_type rng;
};
 
}