VerletList.hpp

#ifndef OPENFPM_DATA_SRC_NN_VERLETLIST_VERLETLIST_HPP_
#define OPENFPM_DATA_SRC_NN_VERLETLIST_VERLETLIST_HPP_
 
#include "Vector/map_vector.hpp"
 
#include "VerletNNIterator.hpp"
#include "NN/CellList/CellList.hpp"
#include "NN/CellList/CellList_util.hpp"
#include "NN/Mem_type/MemFast.hpp"
#include "NN/Mem_type/MemBalanced.hpp"
#include "NN/Mem_type/MemMemoryWise.hpp"
 
 
// Verlet list config options
constexpr int VL_NON_SYMMETRIC = 1;
constexpr int VL_SYMMETRIC = 2;
constexpr int VL_CRS_SYMMETRIC = 4;
constexpr int VL_ADAPTIVE_RCUT = 8;
constexpr int VL_NMAX_NEIGHBOR = 16;
constexpr int VL_SKIP_REF_PART = 32;
 
constexpr int VERLET_STARTING_NSLOT = 128;
 
#ifdef LOCAL_INDEX64
typedef size_t local_index_;
#else
typedef unsigned int local_index_;
#endif
 
 
template<bool isNMax, bool skipRefPart>
struct iteratePartNeighbor;
 
template<>
struct iteratePartNeighbor<false, false> {
 
    template<typename NeighborIter_type, typename VerletList_type, typename vPos_type, unsigned int dim, typename T>
    inline void operator() (
        VerletList_type& verletList,
        NeighborIter_type & it,
        const vPos_type & pos,
        size_t p, Point<dim,T> xp,
        T r_cut, size_t neighborMaxNum)
    {
        T r_cut2 = r_cut * r_cut;
 
        while (it.isNext())
        {
            size_t q = it.get();
 
            Point<dim,T> xq = pos.template get<0>(q);
 
            if (xp.distance2(xq) < r_cut2) {
                verletList.addPart(p,q);
            }
 
            ++it;
        }
    }
};
 
template<>
struct iteratePartNeighbor<false, true> {
 
    template<typename NeighborIter_type, typename VerletList_type, typename vPos_type, unsigned int dim, typename T>
    inline void operator() (
        VerletList_type& verletList,
        NeighborIter_type & it,
        const vPos_type & pos,
        size_t p, Point<dim,T> xp,
        T r_cut, size_t neighborMaxNum)
    {
        T r_cut2 = r_cut * r_cut;
 
        while (it.isNext())
        {
            auto q = it.get();
 
            Point<dim,T> xq = pos.template get<0>(q);
 
            if (xp.distance2(xq) < r_cut2 && p != q) {
                verletList.addPart(p,q);
            }
            ++it;
        }
    }
};
 
template<>
struct iteratePartNeighbor<true, false> {
    template<typename NeighborIter_type, typename VerletList_type, typename vPos_type, unsigned int dim, typename T>
    inline void operator() (
        VerletList_type& verletList,
        NeighborIter_type & it,
        const vPos_type & pos,
        size_t p, Point<dim,T> xp,
        T r_cut, size_t neighborMaxNum)
    {
        struct ReorderType {
            T dist;
            size_t id;
            bool operator<(const ReorderType &other) const { return this->dist < other.dist; }
        };
 
        openfpm::vector<ReorderType> neighborList;
 
        while (it.isNext())
        {
            auto q = it.get();
 
            Point<dim,T> xq = pos.template get<0>(q);
 
            if (xp.distance(xq) < r_cut) {
                ReorderType qReorder;
                qReorder.dist = xp.distance(xq);
                qReorder.id = q;
                neighborList.add(qReorder);
            }
 
            ++it;
        }
 
        neighborList.sort();
        for(size_t i = 0; i < neighborList.size(); ++i) {
            if (i < neighborMaxNum)
            verletList.addPart(p, neighborList.get(i).id);
        }
    }
};
 
template<>
struct iteratePartNeighbor<true, true> {
 
    template<typename NeighborIter_type, typename VerletList_type, typename vPos_type, unsigned int dim, typename T>
    inline void operator() (
        VerletList_type& verletList,
        NeighborIter_type & it,
        const vPos_type & pos,
        size_t p, Point<dim,T> xp,
        T r_cut, size_t neighborMaxNum)
    {
        struct ReorderType {
            T dist;
            size_t id;
            bool operator<(const ReorderType &other) const { return this->dist < other.dist; }
        };
 
        openfpm::vector<ReorderType> neighborList;
 
        while (it.isNext())
        {
            auto q = it.get();
 
            Point<dim,T> xq = pos.template get<0>(q);
 
            if (xp.distance(xq) < r_cut) {
                ReorderType qReorder;
                qReorder.dist = xp.distance(xq);
                qReorder.id = q;
                neighborList.add(qReorder);
            }
 
            ++it;
        }
 
        neighborList.sort();
        for(size_t i = 0; i < neighborList.size(); ++i) {
            if (i < neighborMaxNum && p != neighborList.get(i).id)
                verletList.addPart(p, neighborList.get(i).id);
        }
    }
};
 
 
template<unsigned int dim,
    typename T,
    unsigned int opt = VL_NON_SYMMETRIC,
    typename Mem_type = Mem_fast<HeapMemory,local_index_>,
    typename transform = no_transform<dim,T>,
    typename vPos_type = openfpm::vector<Point<dim,T>>,
    typename CellListImpl = CellList<dim,T,Mem_fast<HeapMemory,typename Mem_type::local_index_type>,transform,vPos_type> >
class VerletList: public Mem_type
{
protected:
 
    typename Mem_type::local_index_type slot;
 
    openfpm::vector<typename Mem_type::local_index_type> domainParticlesCRS;
 
    size_t neighborMaxNum=0;
 
    T rCut;
 
    // Not used by default unless filled with fillNonSymmAdaptive
    openfpm::vector<T> rCuts;
 
private:
 
    size_t n_dec;
 
    CellListImpl cellList;
 
public:
    void initCl(CellListImpl & cellList, const vPos_type & vPos, size_t ghostMarker)
    {
        // CellList_gpu receives a property vector to potentially reorder it during cell list construction
        // stub because of legacy naming
        openfpm::vector<aggregate<int>> vPropStub;
 
        if (opt & VL_SYMMETRIC || opt & VL_CRS_SYMMETRIC)
            cellList.setOpt(CL_SYMMETRIC);
        else
            cellList.setOpt(CL_NON_SYMMETRIC);
 
        cellList.fill(vPos, vPropStub, ghostMarker);
    }
 
    inline void fillCRSSymmetric(
        const vPos_type & pos,
        T r_cut,
        size_t ghostMarker,
        const openfpm::vector<size_t> & dom,
        const openfpm::vector<subsub_lin<dim>>& anom)
    {
        size_t end = pos.size();
 
        Mem_type::init_to_zero(slot,end);
        domainParticlesCRS.clear();
 
        // iterate the particles
        auto it = ParticleItCRS_Cells<dim,CellListImpl,vPos_type>(cellList,dom,anom,cellList.getNNc_sym());
        while (it.isNext())
        {
            typename Mem_type::local_index_type p = it.get();
            Point<dim,T> xp = pos.template get<0>(p);
 
            domainParticlesCRS.add(p);
 
            // Get the neighborhood of the particle
            auto NN = it.getNNIteratorCSR(pos);
 
            iteratePartNeighbor<(bool)(opt&VL_NMAX_NEIGHBOR),(bool)(opt&VL_SKIP_REF_PART)>{}(*this, NN, pos, p, xp, r_cut, neighborMaxNum);
            ++it;
        }
    }
 
    inline void fillSymmetric(
        const vPos_type & pos,
        T r_cut,
        size_t ghostMarker,
        CellListImpl & cellList)
    {
        size_t end = ghostMarker;
 
        Mem_type::init_to_zero(slot,end);
        domainParticlesCRS.clear();
 
        // iterate the particles
        auto it = pos.getIteratorTo(end);
        while (it.isNext())
        {
            typename Mem_type::local_index_type p = it.get();
            Point<dim,T> xp = pos.template get<0>(p);
 
            // Get the neighborhood of the particle
            auto NN = cellList.getNNIteratorBoxSym(cellList.getCell(xp),p,pos);
 
            iteratePartNeighbor<(bool)(opt&VL_NMAX_NEIGHBOR),(bool)(opt&VL_SKIP_REF_PART)>{}(*this, NN, pos, p, xp, r_cut, neighborMaxNum);
            ++it;
        }
    }
 
    inline void fillNonSymmetric(
        const vPos_type & pos,
        T r_cut,
        size_t ghostMarker,
        CellListImpl & cellList)
    {
        size_t end = ghostMarker;
 
        Mem_type::init_to_zero(slot,end);
 
        // iterate the particles
        auto it = pos.getIteratorTo(end);
        while (it.isNext())
        {
            typename Mem_type::local_index_type p = it.get();
            Point<dim,T> xp = pos.template get<0>(p);
 
            // Get the neighborhood of the particle
            auto NN = cellList.getNNIteratorBox(cellList.getCell(xp));
 
            iteratePartNeighbor<(bool)(opt&VL_NMAX_NEIGHBOR),(bool)(opt&VL_SKIP_REF_PART)>{}(*this, NN, pos, p, xp, r_cut, neighborMaxNum);
            ++it;
        }
    }
 
    template <typename domainIterator_type>
    inline void fillNonSymmetricIterator(
        domainIterator_type& it,
        const vPos_type & pos,
        T r_cut,
        size_t ghostMarker,
        CellListImpl & cellList)
    {
        fillNonSymmetricIterator<domainIterator_type>(it, pos, pos, r_cut, ghostMarker, cellList);
    }
 
    template <typename domainIterator_type, typename vPos_type2>
    inline void fillNonSymmetricIterator(
        domainIterator_type& it,
        const vPos_type2 & domainPos,
        const vPos_type & supportPos,
        T r_cut,
        size_t ghostMarker,
        CellListImpl & cellList)
    {
        size_t end = ghostMarker;
 
        Mem_type::init_to_zero(slot,end);
 
        while (it.isNext())
        {
            typename Mem_type::local_index_type p = it.get();
            Point<dim,T> xp = domainPos.template get<0>(p);
 
            // Get the neighborhood of the particle
            auto NN = cellList.getNNIteratorBox(cellList.getCell(xp));
 
            iteratePartNeighbor<(bool)(opt&VL_NMAX_NEIGHBOR),(bool)(opt&VL_SKIP_REF_PART)>{}(*this, NN, supportPos, p, xp, r_cut, neighborMaxNum);
            ++it;
        }
    }
 
    inline void InitializeNonSymmAdaptive(
        const Box<dim,T> & box,
        openfpm::vector<T> &rCuts,
        const vPos_type & pos,
        size_t ghostMarker)
    {
        if (rCuts.size() != pos.size())
        {
            std::cerr << __FILE__ << ":" << __LINE__
                << " ERROR: when constructing adaptive cut-off Verlet list, pos.size() != rCuts.size(), ["
                << rCuts.size() << "!=" << pos.size() << "]" << std::endl;
            std::runtime_error("Runtime adaptive cut-off Verlet list error");
        }
 
        this->rCuts = rCuts;
        T rCutMax = 0.0;
 
        // Assign rCutMax for Cell List as
        // the largest cut-off radius from rCuts
        for (size_t i = 0; i < rCuts.size(); ++i)
            if (rCuts.get(i) > rCutMax)
                rCutMax = rCuts.get(i);
 
        // Number of divisions
        size_t div[dim];
 
        Box<dim,T> bt = box;
 
        // Calculate the divisions for the Cell-lists
        cl_param_calculate(bt,div,rCutMax,Ghost<dim,T>(0.0));
 
        // Initialize a cell-list
        cellList.Initialize(bt,div);
 
        initCl(cellList,pos,ghostMarker);
 
        Mem_type::init_to_zero(slot,ghostMarker);
 
        // iterate the particles
        auto it = pos.getIteratorTo(ghostMarker);
        while (it.isNext())
        {
            typename Mem_type::local_index_type p = it.get();
            Point<dim,T> xp = pos.template get<0>(p);
 
            // Get the neighborhood of the particle
            auto boxIterator = cellList.getNNIteratorBox(cellList.getCell(xp));
 
            iteratePartNeighbor<(bool)(opt&VL_NMAX_NEIGHBOR),(bool)(opt&VL_SKIP_REF_PART)>{}(
                *this, boxIterator, pos, p, xp, rCuts.get(p), neighborMaxNum);
            ++it;
        }
    }
 
    template <typename domainIterator_type, typename vPos_type2>
    inline void fillNonSymmAdaptiveIterator(
        domainIterator_type& it,
        const vPos_type2 & domainPos,
        const vPos_type & supportPos,
        openfpm::vector<T> &rCuts,
        size_t ghostMarker)
    {
        if (rCuts.size() != ghostMarker)
        {
            std::cerr << __FILE__ << ":" << __LINE__
                << " ERROR: when constructing adaptive cut-off Verlet list, pos.size_local() != rCuts.size(), ["
                << rCuts.size() << "!=" << domainPos.size_local() << "]" << std::endl;
            std::runtime_error("Runtime adaptive cut-off Verlet list error");
        }
 
        size_t end = ghostMarker;
 
        Mem_type::init_to_zero(slot,end);
 
        // iterate the particles
        while (it.isNext())
        {
            typename Mem_type::local_index_type p = it.get();
            Point<dim,T> xp = domainPos.template get<0>(p);
 
            // iterate the whole domain instead of neighborhood iteration
            // no auxillary cell list is needed
            auto NN = supportPos.getIteratorTo(supportPos.size_local());
            T r_cut = rCuts.get(p);
 
            iteratePartNeighbor<(bool)(opt&VL_NMAX_NEIGHBOR),(bool)(opt&VL_SKIP_REF_PART)>{}(*this, NN, supportPos, p, xp, r_cut, neighborMaxNum);
            ++it;
        }
    }
 
    inline void fillNonSymmetricRadius(
        const vPos_type & pos,
        T r_cut,
        size_t ghostMarker,
        CellListImpl & cellList)
    {
        size_t end = ghostMarker;
 
        Mem_type::init_to_zero(slot,end);
 
        // iterate the particles
        auto it = pos.getIteratorTo(end);
        while (it.isNext())
        {
            typename Mem_type::local_index_type p = it.get();
            Point<dim,T> xp = pos.template get<0>(p);
 
            // Get the neighborhood of the particle
            auto NN = cellList.getNNIteratorRadius(cellList.getCell(xp),r_cut);
 
            iteratePartNeighbor<(bool)(opt&VL_NMAX_NEIGHBOR),(bool)(opt&VL_SKIP_REF_PART)>{}(*this, NN, pos, p, xp, r_cut, neighborMaxNum);
            ++it;
        }
    }
 
    typedef Mem_type Mem_type_type;
 
    typedef size_t value_type;
 
    size_t size()
    {
        return Mem_type::size();
    }
 
    inline void addPart(size_t p, size_t q)
    {
        Mem_type::addCell(p,q);
    }
 
    inline void replaceNeighbParts(size_t p, const openfpm::vector<size_t> &buffer)
    {
        Mem_type::clear(p);
        for (size_t i = 0; i < buffer.size(); i++)
        {
            Mem_type::addCell(p,buffer.get(i));
        }
    }
 
    void Initialize(
        const Box<dim,T> & box,
        T r_cut,
        vPos_type & pos,
        size_t ghostMarker)
    {
        this->rCut = r_cut;
        // Number of divisions
        size_t div[dim];
 
        Box<dim,T> bt = box;
 
        // Calculate the divisions for the Cell-lists
        cl_param_calculate(bt,div,r_cut,Ghost<dim,T>(0.0));
 
        // Initialize a cell-list
        cellList.Initialize(bt,div);
 
        initCl(cellList,pos,ghostMarker);
 
        fillNonSymmetric(pos,r_cut,ghostMarker,cellList);
    }
 
    template <typename domainIterator_type>
    void Initialize(
        CellListImpl& cellList,
        T r_cut,
        domainIterator_type& it,
        const vPos_type& pos,
        size_t ghostMarker)
    {
        this->rCut = r_cut;
        this->cellList = cellList;
 
        fillNonSymmetricIterator(it,pos,r_cut,ghostMarker,cellList);
    }
 
    template <typename domainIterator_type>
    void Initialize(
        CellListImpl& cellList,
        T r_cut,
        domainIterator_type& it,
        const vPos_type& domainPos,
        const vPos_type& supportPos,
        size_t ghostMarker)
    {
        this->rCut = r_cut;
        this->cellList = cellList;
 
        fillNonSymmetricIterator(it,domainPos,supportPos,r_cut,ghostMarker,cellList);
    }
 
    void InitializeSym(
        const Box<dim,T> & box,
        const Box<dim,T> & dom,
        const Ghost<dim,T> & ghostSize,
        T r_cut,
        vPos_type & pos,
        size_t ghostMarker)
    {
        this->rCut = r_cut;
        // Padding
        size_t pad = 0;
 
        // Cell decomposer
        CellDecomposer_sm<dim,T,shift<dim,T>> cd_sm;
 
        // Calculate the divisions for the Cell-lists
        cl_param_calculateSym<dim,T>(box,cd_sm,ghostSize,r_cut,pad);
 
        // Initialize a cell-list
        cellList.Initialize(cd_sm,dom,pad);
        initCl(cellList,pos,ghostMarker);
 
        // create verlet
        fillSymmetric(pos, r_cut, ghostMarker, cellList);
    }
 
 
    void initializeCrs(
        const Box<dim,T> & box,
        const Box<dim,T> & dom,
        const Ghost<dim,T> & ghostSize,
        T r_cut,
        vPos_type & pos,
        size_t ghostMarker)
    {
        this->rCut = r_cut;
        // Padding
        size_t pad = 0;
 
        // Cell decomposer
        CellDecomposer_sm<dim,T,shift<dim,T>> cd_sm;
 
        // Calculate the divisions for the Cell-lists
        cl_param_calculateSym<dim,T>(box,cd_sm,ghostSize,r_cut,pad);
 
        // Initialize a cell-list
        cellList.Initialize(cd_sm,dom,pad);
        initCl(cellList,pos,ghostMarker);
    }
 
    void update(
        const Box<dim,T> & dom,
        T r_cut,
        vPos_type & pos,
        size_t & ghostMarker)
    {
        initCl(cellList,pos,ghostMarker);
 
        if (opt & VL_SYMMETRIC)
            fillSymmetric(pos,r_cut,ghostMarker,cellList);
        else
            fillNonSymmetric(pos,r_cut,ghostMarker,cellList);
    }
 
    void updateCrs(
        vPos_type & pos,
        T r_cut,
        size_t & ghostMarker,
        const openfpm::vector<size_t> & dom_c,
        const openfpm::vector<subsub_lin<dim>> & anom_c)
    {
        initCl(cellList,pos,ghostMarker);
        fillCRSSymmetric(pos,r_cut,ghostMarker,dom_c,anom_c);
    }
 
    VerletList()
    :Mem_type(VERLET_STARTING_NSLOT),slot(VERLET_STARTING_NSLOT),n_dec(0)
    {};
 
    VerletList(const VerletList<dim,T,opt,Mem_type,transform,vPos_type,CellListImpl> & cell)
    :Mem_type(VERLET_STARTING_NSLOT),slot(VERLET_STARTING_NSLOT)
    {
        this->operator=(cell);
    }
 
    VerletList(VerletList<dim,T,opt,Mem_type,transform,vPos_type,CellListImpl> && cell)
    :Mem_type(VERLET_STARTING_NSLOT),slot(VERLET_STARTING_NSLOT),n_dec(0)
    {
        this->operator=(cell);
    }
 
 
    VerletList(Box<dim,T> & box, T r_cut, Matrix<dim,T> mat, const size_t pad = 1, size_t slot=STARTING_NSLOT)
    :slot(VERLET_STARTING_NSLOT),CellDecomposer_sm<dim,T,transform>(box,div,mat,box.getP1(),pad)
    {
        Box<dim,T> sbox(box);
        Initialize(sbox,r_cut,pad,slot);
    }
 
    VerletList(Box<dim,T> & box, T r_cut, vPos_type & pos, size_t ghostMarker, size_t slot=VERLET_STARTING_NSLOT)
    :slot(slot)
    {
        Box<dim,T> sbox(box);
        Initialize(sbox,r_cut,pos,ghostMarker);
    }
 
    VerletList(Box<dim,T> & box, Box<dim,T> & dom, T r_cut, vPos_type & pos, size_t ghostMarker, size_t slot=VERLET_STARTING_NSLOT)
    :slot(slot)
    {
        Initialize(box,r_cut,pos);
    }
 
    ~VerletList()
    {}
 
    VerletList<dim,T,opt,Mem_type,transform,vPos_type,CellListImpl> &
    operator=(VerletList<dim,T,opt,Mem_type,transform,vPos_type,CellListImpl> && vl)
    {
        slot = vl.slot;
 
        Mem_type::operator=(vl);
        domainParticlesCRS.swap(vl.domainParticlesCRS);
 
        n_dec = vl.n_dec;
 
        return *this;
    }
 
    VerletList<dim,T,opt,Mem_type,transform,vPos_type,CellListImpl> &
    operator=(const VerletList<dim,T,opt,Mem_type,transform,vPos_type,CellListImpl> & vl)
    {
        slot = vl.slot;
 
        Mem_type::operator=(vl);
 
        cellList = vl.cellList;
 
        domainParticlesCRS = vl.domainParticlesCRS;
        n_dec = vl.n_dec;
 
        return *this;
    }
 
    inline size_t getNNPart(size_t p) const
    {
        return Mem_type::getNelements(p);
    }
 
    inline size_t get(size_t p, size_t q) const
    {
        return Mem_type::get(p,q);
    }
 
    inline void swap(VerletList<dim,T,opt,Mem_type,transform,vPos_type,CellListImpl> & vl)
    {
        Mem_type::swap(vl);
        domainParticlesCRS.swap(vl.domainParticlesCRS);
 
        size_t vl_slot_tmp = vl.slot;
        vl.slot = slot;
        slot = vl_slot_tmp;
 
        cellList.swap(vl.cellList);
 
        size_t n_dec_tmp = vl.n_dec;
        vl.n_dec = n_dec;
        n_dec = n_dec_tmp;
    }
 
    inline VerletNNIterator<dim,VerletList<dim,T,opt,Mem_type,transform,vPos_type,CellListImpl>>
    getNNIterator(size_t p)
    {
        VerletNNIterator<dim,VerletList<dim,T,opt,Mem_type,transform,vPos_type,CellListImpl>> vln(p,*this);
 
        return vln;
    }
 
    void clear()
    {
        Mem_type::clear();
    }
 
    inline const typename Mem_type::local_index_type &
    getStart(typename Mem_type::local_index_type p)
    {
        return Mem_type::getStartId(p);
    }
 
    inline const typename Mem_type::local_index_type &
    getStop(typename Mem_type::local_index_type p)
    {
        return Mem_type::getStopId(p);
    }
 
    inline const typename Mem_type::local_index_type &
    get_lin(const typename Mem_type::local_index_type * p)
    {
        return Mem_type::get_lin(p);
    }
 
    CellListImpl & getInternalCellList()
    {
        return cellList;
    }
 
    void set_ndec(size_t n_dec)
    {
        this->n_dec = n_dec;
 
        cellList.set_ndec(n_dec);
    }
 
    size_t get_ndec()
    {
        return n_dec;
    }
 
    size_t getNeighborMaxNum() const
    {
        return neighborMaxNum;
    }
 
    void setNeighborMaxNum(size_t neighborMaxNum)
    {
        this->neighborMaxNum = neighborMaxNum;
    }
 
    size_t getOpt() const
    {
        return opt;
    }
 
    openfpm::vector<typename Mem_type::local_index_type> & getParticleSeq()
    {
        return domainParticlesCRS;
    }
 
    T getRCut()
    {
        return rCut;
    }
 
    T getRCuts(size_t p)
    {
        return rCuts.get(p);
    }
 
    void clear(typename Mem_type::local_index_type p)
    {
        Mem_type::clear(p);
    }
};
 
template<unsigned int dim, typename St, unsigned int opt> using VERLET_MEMFAST = VerletList<dim,St,opt,Mem_fast<>,shift<dim,St>>;
template<unsigned int dim, typename St, unsigned int opt> using VERLET_MEMBAL = VerletList<dim,St,opt,Mem_bal<>,shift<dim,St>>;
template<unsigned int dim, typename St, unsigned int opt> using VERLET_MEMMW = VerletList<dim,St,opt,Mem_mw<>,shift<dim,St>>;
 
template<unsigned int dim, typename St, unsigned int opt> using VERLET_MEMFAST_INT = VerletList<dim,St,opt,Mem_fast<HeapMemory,unsigned int>,shift<dim,St>>;
template<unsigned int dim, typename St, unsigned int opt> using VERLET_MEMBAL_INT = VerletList<dim,St,opt,Mem_bal<unsigned int>,shift<dim,St>>;
template<unsigned int dim, typename St, unsigned int opt> using VERLET_MEMMW_INT = VerletList<dim,St,opt,Mem_mw<unsigned int>,shift<dim,St>>;
 
 
#endif /* OPENFPM_DATA_SRC_NN_VERLETLIST_VERLETLIST_HPP_ */