eonc::VesinNeighbors Class Reference

RAII wrapper around vesin_neighbors for Matter-style boxes (double[9] row-major 3×3 cell, same layout as Matter::cell). More...

#include <VesinNeighbors.h>

Classes
struct	Options

Public Member Functions
	VesinNeighbors ()=default
	VesinNeighbors (const VesinNeighbors &)=delete
VesinNeighbors &	operator= (const VesinNeighbors &)=delete
	VesinNeighbors (VesinNeighbors &&other) noexcept
VesinNeighbors &	operator= (VesinNeighbors &&other) noexcept
	~VesinNeighbors ()
void	compute (const double *R, std::size_t n, const double *box, const Options &opt)
	Build / rebuild the list.
std::size_t	size () const
std::size_t	i (std::size_t p) const
std::size_t	j (std::size_t p) const
double	distance (std::size_t p) const
	Distance |r_ij| (requires return_distances).
const double *	vector (std::size_t p) const
	Vector r_j − r_i (+ PBC). Requires return_vectors.
const int32_t *	shift (std::size_t p) const
const VesinNeighborList &	raw () const
	Raw list for advanced consumers (Metatomic tensor conversion).
VesinNeighborList &	raw ()
VesinNeighborList *	release ()
	Steal ownership of the internal list (for Metatomic custom deleters).

Private Member Functions
void	free_list ()

Private Attributes
VesinNeighborList	list_ {}
bool	owns_ {false}

Detailed Description

RAII wrapper around vesin_neighbors for Matter-style boxes (double[9] row-major 3×3 cell, same layout as Matter::cell).

Pair vector convention matches vesin: r_ij = r_j - r_i + S @ H. Classical pair pots that used r_i - r_j must flip the sign.

Definition at line 27 of file VesinNeighbors.h.

Constructor & Destructor Documentation

VesinNeighbors() [1/3]

eonc::VesinNeighbors::VesinNeighbors ( )

default

VesinNeighbors() [2/3]

eonc::VesinNeighbors::VesinNeighbors ( const VesinNeighbors & )

delete

VesinNeighbors() [3/3]

eonc::VesinNeighbors::VesinNeighbors ( VesinNeighbors && other )

noexcept

Definition at line 14 of file VesinNeighbors.cpp.

    : list_(other.list_),
      owns_(other.owns_) {
  other.list_ = VesinNeighborList{};
  other.owns_ = false;
}

~VesinNeighbors()

eonc::VesinNeighbors::~VesinNeighbors

(

)

Definition at line 32 of file VesinNeighbors.cpp.

{ free_list(); }

Member Function Documentation

compute()

void eonc::VesinNeighbors::compute	(	const double *	R,
		std::size_t	n,
		const double *	box,
		const Options &	opt )

Build / rebuild the list.

R is length 3*n (x,y,z interleaved); box is length 9 (row-major cell vectors).

Keep the same VesinNeighbors instance across force evaluations so vesin can re-use pair/distance/vector allocations (see vesin_neighbors docs). Freeing before every compute is incorrect and expensive.

Definition at line 42 of file VesinNeighbors.cpp.

                                                 {
  if (R == nullptr || (n > 0 && box == nullptr)) {
    throw std::invalid_argument("VesinNeighbors::compute: null R or box");
  }
  if (opt.cutoff <= 0.0) {
    free_list();
    return;
  }
 
  // Pass the existing VesinNeighborList through so vesin can re-use pair /
  // distance / vector buffers (upstream contract). Do not vesin_free first —
  // that forces a full realloc every call and is the #386 ASV regression.
  VesinOptions vopt{};
  vopt.cutoff = opt.cutoff;
  vopt.full = opt.full;
  vopt.sorted = opt.sorted;
  vopt.algorithm = opt.algorithm;
  vopt.skin = opt.skin;
  vopt.n_threads = opt.n_threads;
  vopt.return_shifts = opt.return_shifts;
  vopt.return_distances = opt.return_distances;
  vopt.return_vectors = opt.return_vectors;
 
  bool periodic[3] = {opt.periodic[0], opt.periodic[1], opt.periodic[2]};
  double box33[3][3];
  for (int a = 0; a < 3; ++a) {
    for (int b = 0; b < 3; ++b) {
      box33[a][b] = box[3 * a + b];
    }
  }
 
  VesinDevice cpu{VesinCPU, 0};
  const char *error_message = nullptr;
  int status =
      vesin_neighbors(reinterpret_cast<const double (*)[3]>(R), n, box33,
                      periodic, cpu, vopt, &list_, &error_message);
  if (status != EXIT_SUCCESS) {
    std::string err = "vesin_neighbors failed";
    if (error_message != nullptr) {
      err += ": ";
      err += error_message;
    }
    free_list();
    throw std::runtime_error(err);
  }
  owns_ = true;
}

distance()

double eonc::VesinNeighbors::distance ( std::size_t p ) const

inlinenodiscard

Distance |r_ij| (requires return_distances).

Definition at line 71 of file VesinNeighbors.h.

                                                   {
    return list_.distances[p];
  }

free_list()

void eonc::VesinNeighbors::free_list ( )

private

Definition at line 34 of file VesinNeighbors.cpp.

                               {
  if (owns_) {
    vesin_free(&list_);
    owns_ = false;
  }
  list_ = VesinNeighborList{};
}

i()

std::size_t eonc::VesinNeighbors::i ( std::size_t p ) const

inlinenodiscard

Definition at line 67 of file VesinNeighbors.h.

{ return list_.pairs[p][0]; }

j()

std::size_t eonc::VesinNeighbors::j ( std::size_t p ) const

inlinenodiscard

Definition at line 68 of file VesinNeighbors.h.

{ return list_.pairs[p][1]; }

operator=() [1/2]

VesinNeighbors & eonc::VesinNeighbors::operator= ( const VesinNeighbors & )

delete

operator=() [2/2]

VesinNeighbors & eonc::VesinNeighbors::operator= ( VesinNeighbors && other )

noexcept

Definition at line 21 of file VesinNeighbors.cpp.

                                                                       {
  if (this != &other) {
    free_list();
    list_ = other.list_;
    owns_ = other.owns_;
    other.list_ = VesinNeighborList{};
    other.owns_ = false;
  }
  return *this;
}

raw() [1/2]

VesinNeighborList & eonc::VesinNeighbors::raw ( )

inlinenodiscard

Definition at line 86 of file VesinNeighbors.h.

{ return list_; }

raw() [2/2]

const VesinNeighborList & eonc::VesinNeighbors::raw ( ) const

inlinenodiscard

Raw list for advanced consumers (Metatomic tensor conversion).

Definition at line 85 of file VesinNeighbors.h.

{ return list_; }

release()

VesinNeighborList * eonc::VesinNeighbors::release

(

)

Steal ownership of the internal list (for Metatomic custom deleters).

After release, this object is empty until the next compute.

Definition at line 91 of file VesinNeighbors.cpp.

                                           {
  if (!owns_) {
    return nullptr;
  }
  auto *heap = new VesinNeighborList(list_);
  list_ = VesinNeighborList{};
  owns_ = false;
  return heap;
}

shift()

const int32_t * eonc::VesinNeighbors::shift ( std::size_t p ) const

inlinenodiscard

Definition at line 80 of file VesinNeighbors.h.

                                                        {
    return list_.shifts[p];
  }

size()

std::size_t eonc::VesinNeighbors::size ( ) const

inlinenodiscard

Definition at line 65 of file VesinNeighbors.h.

{ return list_.length; }

vector()

const double * eonc::VesinNeighbors::vector ( std::size_t p ) const

inlinenodiscard

Vector r_j − r_i (+ PBC). Requires return_vectors.

Definition at line 76 of file VesinNeighbors.h.

                                                        {
    return list_.vectors[p];
  }

Member Data Documentation

list_

VesinNeighborList eonc::VesinNeighbors::list_ {}

private

Definition at line 93 of file VesinNeighbors.h.

{};

owns_

bool eonc::VesinNeighbors::owns_ {false}

private

Definition at line 94 of file VesinNeighbors.h.

{false};

---

The documentation for this class was generated from the following files:

• /home/runner/work/eOn/eOn/include/eon/VesinNeighbors.h
• /home/runner/work/eOn/eOn/client/VesinNeighbors.cpp