Program Listing for File neighbor_list.h

↰ Return to documentation for file (source/lib/include/neighbor_list.h)

// SPDX-License-Identifier: LGPL-3.0-or-later
#pragma once

#include <algorithm>
#include <cassert>
#include <iterator>
#include <vector>

#include "SimulationRegion.h"
#include "region.h"
#include "utilities.h"

namespace deepmd {

struct InputNlist {
  int inum;
  int* ilist;
  int* numneigh;
  int** firstneigh;
  int nswap;
  int* sendnum;
  int* recvnum;
  int* firstrecv;
  int** sendlist;
  int* sendproc;
  int* recvproc;
  void* world;
  InputNlist()
      : inum(0),
        ilist(NULL),
        numneigh(NULL),
        firstneigh(NULL),
        nswap(0),
        sendnum(nullptr),
        recvnum(nullptr),
        firstrecv(nullptr),
        sendlist(nullptr),
        sendproc(nullptr),
        recvproc(nullptr),
        world(0) {};
  InputNlist(int inum_, int* ilist_, int* numneigh_, int** firstneigh_)
      : inum(inum_),
        ilist(ilist_),
        numneigh(numneigh_),
        firstneigh(firstneigh_),
        nswap(0),
        sendnum(nullptr),
        recvnum(nullptr),
        firstrecv(nullptr),
        sendlist(nullptr),
        sendproc(nullptr),
        recvproc(nullptr),
        world(0) {};
  InputNlist(int inum_,
             int* ilist_,
             int* numneigh_,
             int** firstneigh_,
             int nswap,
             int* sendnum,
             int* recvnum,
             int* firstrecv,
             int** sendlist,
             int* sendproc,
             int* recvproc,
             void* world)
      : inum(inum_),
        ilist(ilist_),
        numneigh(numneigh_),
        firstneigh(firstneigh_),
        nswap(nswap),
        sendnum(sendnum),
        recvnum(recvnum),
        firstrecv(firstrecv),
        sendlist(sendlist),
        sendproc(sendproc),
        recvproc(recvproc),
        world(world) {};
  ~InputNlist() {};
};

void convert_nlist(InputNlist& to_nlist,
                   std::vector<std::vector<int> >& from_nlist);

int max_numneigh(const InputNlist& to_nlist);

// build neighbor list.
// outputs
//  nlist, max_list_size
//  max_list_size is the maximal size of jlist.
// inputs
//  c_cpy, nloc, nall, mem_size, rcut, region
//  mem_size is the size of allocated memory for jlist.
// returns
//  0: succssful
//  1: the memory is not large enough to hold all neighbors.
//     i.e. max_list_size > mem_nall
template <typename FPTYPE>
int build_nlist_cpu(InputNlist& nlist,
                    int* max_list_size,
                    const FPTYPE* c_cpy,
                    const int& nloc,
                    const int& nall,
                    const int& mem_size,
                    const float& rcut);

void use_nei_info_cpu(int* nlist,
                      int* ntype,
                      bool* nmask,
                      const int* type,
                      const int* nlist_map,
                      const int nloc,
                      const int nnei,
                      const int ntypes,
                      const bool b_nlist_map);

#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM

void convert_nlist_gpu_device(InputNlist& gpu_nlist,
                              InputNlist& cpu_nlist,
                              int*& gpu_memory,
                              const int& max_nbor_size);

void free_nlist_gpu_device(InputNlist& gpu_nlist);

void use_nlist_map(int* nlist,
                   const int* nlist_map,
                   const int nloc,
                   const int nnei);

#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM

#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
// build neighbor list.
// outputs
//  nlist, max_list_size
//  max_list_size is the maximal size of jlist.
// inputs
//  c_cpy, nloc, nall, mem_size, rcut, region
//  mem_size is the size of allocated memory for jlist.
// returns
//  0: succssful
//  1: the memory is not large enough to hold all neighbors.
//     i.e. max_list_size > mem_nall
template <typename FPTYPE>
int build_nlist_gpu(InputNlist& nlist,
                    int* max_list_size,
                    int* nlist_data,
                    const FPTYPE* c_cpy,
                    const int& nloc,
                    const int& nall,
                    const int& mem_size,
                    const float& rcut);

void filter_ftype_gpu(int* ftype_out, const int* ftype_in, const int nloc);

void use_nei_info_gpu(int* nlist,
                      int* ntype,
                      bool* nmask,
                      const int* type,
                      const int* nlist_map,
                      const int nloc,
                      const int nnei,
                      const int ntypes,
                      const bool b_nlist_map);

#endif  // GOOGLE_CUDA || TENSORFLOW_USE_ROCM

}  // namespace deepmd

// legacy code

// build nlist by an extended grid
void build_nlist(std::vector<std::vector<int> >& nlist0,
                 std::vector<std::vector<int> >& nlist1,
                 const std::vector<double>& coord,
                 const int& nloc,
                 const double& rc0,
                 const double& rc1,
                 const std::vector<int>& nat_stt_,
                 const std::vector<int>& nat_end_,
                 const std::vector<int>& ext_stt_,
                 const std::vector<int>& ext_end_,
                 const SimulationRegion<double>& region,
                 const std::vector<int>& global_grid);

// build nlist by a grid for a periodic region
void build_nlist(std::vector<std::vector<int> >& nlist0,
                 std::vector<std::vector<int> >& nlist1,
                 const std::vector<double>& coord,
                 const double& rc0,
                 const double& rc1,
                 const std::vector<int>& grid,
                 const SimulationRegion<double>& region);

// build nlist by a grid for a periodic region, atoms selected by sel0 and sel1
void build_nlist(std::vector<std::vector<int> >& nlist0,
                 std::vector<std::vector<int> >& nlist1,
                 const std::vector<double>& coord,
                 const std::vector<int>& sel0,
                 const std::vector<int>& sel1,
                 const double& rc0,
                 const double& rc1,
                 const std::vector<int>& grid,
                 const SimulationRegion<double>& region);

// brute force (all-to-all distance computation) neighbor list building
// if region is NULL, open boundary is assumed,
// otherwise, periodic boundary condition is defined by region
void build_nlist(std::vector<std::vector<int> >& nlist0,
                 std::vector<std::vector<int> >& nlist1,
                 const std::vector<double>& coord,
                 const double& rc0_,
                 const double& rc1_,
                 const SimulationRegion<double>* region = NULL);

// copy periodic images for the system
void copy_coord(std::vector<double>& out_c,
                std::vector<int>& out_t,
                std::vector<int>& mapping,
                std::vector<int>& ncell,
                std::vector<int>& ngcell,
                const std::vector<double>& in_c,
                const std::vector<int>& in_t,
                const double& rc,
                const SimulationRegion<double>& region);