MemBalanced.hpp

 
/*
 * MemBalanced.hpp
 *
 *  Created on: Mar 22, 2015
 *  Last modified: June 25, 2015
 *      Authors: Pietro Incardona, Yaroslav Zaluzhnyi
 */
 
#ifndef CELLLISTBAL_HPP_
#define CELLLISTBAL_HPP_
 
#include "Space/Shape/Box.hpp"
#include "util/mathutil.hpp"
#include "Space/Shape/HyperCube.hpp"
 
template<typename local_index = size_t>
class Mem_bal
{
    typedef openfpm::vector<local_index> base;
 
    // that store the elements in the cell
    openfpm::vector<base> cl_base;
 
    openfpm::vector<size_t> ghostMarkers;
 
    local_index invalid;
 
public:
 
    typedef void toKernel_type;
 
    typedef local_index local_index_type;
 
    inline void init_to_zero(size_t slot, size_t tot_n_cell)
    {
        //resize the vector to needed number of cells
 
        cl_base.resize(tot_n_cell);
        ghostMarkers.resize(tot_n_cell);
        clear();
    }
 
    inline Mem_bal & operator=(const Mem_bal & cell)
    {
        cl_base = cell.cl_base;
        ghostMarkers = cell.ghostMarkers;
 
        return *this;
    }
 
    inline void addCell(size_t cell_id, typename base::value_type ele)
    {
        //add another neighbor element
 
        cl_base.get(cell_id).add(ele);
    }
 
    inline void remove(local_index cell, local_index ele)
    {
        cl_base.get(cell).remove(ele);
    }
 
    inline local_index getNelements(const local_index cell_id) const
    {
        return cl_base.get(cell_id).size();
    }
 
    inline auto get(local_index cell, local_index ele) -> decltype(cl_base.get(0).get(0)) &
    {
        return cl_base.get(cell).get(ele);
    }
 
    inline auto get(local_index cell, local_index ele) const -> decltype(cl_base.get(0).get(0)) &
    {
        return cl_base.get(cell).get(ele);
    }
 
    inline void addCellGhostMarkers()
    {
        ghostMarkers.resize(cl_base.size());
 
        for (int i = 0; i < cl_base.size(); ++i)
        {
            ghostMarkers.get(i) = cl_base.get(i).size();
        }
    }
 
    inline size_t getGhostMarker(local_index cell_id) const
    {
        return ghostMarkers.get(cell_id);
    }
 
    inline void swap(Mem_bal & cl)
    {
        cl_base.swap(cl.cl_base);
        ghostMarkers.swap(cl.ghostMarkers);
    }
 
    inline void swap(Mem_bal && cell)
    {
        cl_base.swap(cell.cl_base);
        ghostMarkers.swap(cell.ghostMarkers);
    }
 
    inline void clear()
    {
        for (size_t i = 0 ; i < cl_base.size() ; i++) {
            cl_base.get(i).clear();
            ghostMarkers.get(i) = 0;
        }
    }
 
    inline const local_index & getStartId(local_index cell_id) const
    {
        if (cl_base.get(cell_id).size() == 0)
            return invalid;
 
        return cl_base.get(cell_id).get(0);
    }
 
    inline const local_index & getGhostId(local_index cell_id) const
    {
        if (cl_base.get(cell_id).size() == 0)
            return invalid;
 
        return cl_base.get(cell_id).get(this->getGhostMarker(cell_id));
    }
 
    inline const local_index & getStopId(local_index cell_id) const
    {
        if (cl_base.get(cell_id).size() == 0)
            return invalid;
 
        return *(&cl_base.get(cell_id).last() + 1);
    }
 
    inline const local_index & get_lin(const local_index * cell_id) const
    {
        return *cell_id;
    }
 
public:
 
    inline Mem_bal(size_t slot)
    :invalid(0)
    {}
 
    inline void set_slot(size_t slot)
    {}
 
};
 
 
#endif /* CELLLISTBAL_HPP_ */