Gen

Topics
	Ring

Namespaces
namespace	gen
	Small generic functions that are shared by all namespaces.

Classes
struct	gen::FracBox

Functions
double	gen::radDeg (double angle)
	Inline function for converting radians->degrees.
double	gen::eigenVecAngle (std::vector< double > OO, std::vector< double > OH)
	Eigen function for getting the angle (in radians) between the O–O and O-H vectors.
double	gen::getAverageWithoutOutliers (std::vector< double > inpVec)
	Get the average, after excluding the outliers, using quartiles.
double	gen::calcMedian (std::vector< double > *input)
	Inline generic function for calculating the median given a vector of the values.
FracBox	gen::makeFracBox (const molSys::PointCloud< molSys::Point< double >, double > &yCloud)
std::array< double, 3 >	gen::fracDelta (const FracBox &b, double xi, double yi, double zi, double xj, double yj, double zj)
double	gen::fracDistSq (const FracBox &b, double xi, double yi, double zi, double xj, double yj, double zj)
bool	gen::smithInside (const FracBox &b, double r2)
std::array< double, 3 >	gen::triclinicMinImage (const molSys::PointCloud< molSys::Point< double >, double > &yCloud, double xi, double yi, double zi, double xj, double yj, double zj)
double	gen::periodicDistSq (const FracBox &b, const molSys::PointCloud< molSys::Point< double >, double > &yCloud, int iatom, int jatom)
	Inline generic function for obtaining the unwrapped periodic distance between two particles, whose indices (not IDs) have been given.
double	gen::periodicDistSq (const molSys::PointCloud< molSys::Point< double >, double > &yCloud, int iatom, int jatom)
double	gen::periodicDist (const molSys::PointCloud< molSys::Point< double >, double > &yCloud, int iatom, int jatom)
	Inline generic function for obtaining the unwrapped periodic distance between two particles, whose indices (not IDs) have been given.
void	gen::batchPeriodicDistSq (const molSys::PointCloud< molSys::Point< double >, double > &yCloud, int iatom, const int *jatom, std::size_t n, double *distSq)
std::string	gen::formatDumpBox (const std::vector< double > &box)
void	gen::writeDumpBoxBounds (std::ostream &os, const molSys::PointCloud< molSys::Point< double >, double > &yCloud)
std::array< double, 3 >	gen::relDistFromPoint (const FracBox &b, const molSys::PointCloud< molSys::Point< double >, double > &yCloud, int iatom, double xj, double yj, double zj)
	Inline generic function for obtaining the unwrapped periodic distance between one particle and another point, whose index has been given.
std::array< double, 3 >	gen::relDistFromPoint (const molSys::PointCloud< molSys::Point< double >, double > &yCloud, int iatom, double xj, double yj, double zj)
double	gen::unWrappedDistFromPoint (const molSys::PointCloud< molSys::Point< double >, double > &yCloud, int iatom, const std::vector< double > &singlePoint)
double	gen::distance (const molSys::PointCloud< molSys::Point< double >, double > &yCloud, int iatom, int jatom)
	Inline generic function for obtaining the wrapped distance between two particles WITHOUT applying PBCs, whose indices (not IDs) have been given.
std::array< double, 3 >	gen::relDist (const molSys::PointCloud< molSys::Point< double >, double > &yCloud, int iatom, int jatom)
	Inline generic function for getting the relative unwrapped distance between two particles for each dimension.
bool	gen::compareByAtomID (const molSys::Point< double > &a, const molSys::Point< double > &b)
	Inline generic function for sorting or comparing two particles, according to the atom ID when the entire Point objects have been passed.
int	gen::prettyPrintYoda (const molSys::PointCloud< molSys::Point< double >, double > &yCloud, std::string outFile)
	Generic function for printing all the struct information.
int	gen::unwrappedCoordShift (const molSys::PointCloud< molSys::Point< double >, double > &yCloud, int iatomIndex, int jatomIndex, double *x_i, double *y_i, double *z_i, double *x_j, double *y_j, double *z_j)
	Shift particles (unwrapped coordinates).
double	gen::angDistDegQuaternions (std::vector< double > quat1, std::vector< double > quat2)
std::vector< std::string >	gen::tokenizer (std::string line)
	Function for tokenizing line strings into words (strings) delimited by whitespace.
std::vector< double >	gen::tokenizerDouble (std::string line)
	Function for tokenizing line strings into a vector of doubles.
std::vector< int >	gen::tokenizerInt (std::string line)
	Function for tokenizing line strings into a vector of ints.
bool	gen::file_exists (const std::string &name)
	Function for checking if a file exists or not.
std::vector< std::complex< double > >	gen::avgVector (std::vector< std::complex< double > > v, int l, int neigh)
	Calculates the complex vector, normalized by the number of nearest neighbours, of length \(2l+1\).

Variables
constexpr double	gen::pi = std::numbers::pi
	Uses Boost to get the value of pi.
double	gen::FracBox::lx = 0.0
double	gen::FracBox::ly = 0.0
double	gen::FracBox::lz = 0.0
double	gen::FracBox::xy = 0.0
double	gen::FracBox::xz = 0.0
double	gen::FracBox::yz = 0.0
double	gen::FracBox::ox = 0.0
double	gen::FracBox::oy = 0.0
double	gen::FracBox::oz = 0.0
double	gen::FracBox::wx = 0.0
double	gen::FracBox::wy = 0.0
double	gen::FracBox::wz = 0.0
double	gen::FracBox::halfMin = 0.0
bool	gen::FracBox::triclinic = false
bool	gen::FracBox::ok = false

Detailed Description

Function Documentation

angDistDegQuaternions()

double gen::angDistDegQuaternions	(	std::vector< double >	quat1,
		std::vector< double >	quat2 )

Function for getting the angular distance between two quaternions. Returns the result in degrees

avgVector()

std::vector< std::complex< double > > gen::avgVector ( std::vector< std::complex< double > > v, int l, int neigh )

inline

Calculates the complex vector, normalized by the number of nearest neighbours, of length \(2l+1\).

Parameters

[in]	v	The complex vector to be normalized, of length \(2l+1\)
[in]	l	A free integer parameter
[in]	neigh	The number of nearest neighbours

Returns

length \(2l+1\), normalized by the number of nearest neighbours

Definition at line 697 of file generic.hpp.

                                                             {
  if (neigh == 0) {
    return v;
  }
  for (int m = 0; m < 2 * l + 1; m++) {
    v[m] = (1.0 / static_cast<double>(neigh)) * v[m];
  }
 
  return v;
}

batchPeriodicDistSq()

void gen::batchPeriodicDistSq ( const molSys::PointCloud< molSys::Point< double >, double > & yCloud, int iatom, const int * jatom, std::size_t n, double * distSq )

inline

Definition at line 426 of file generic.hpp.

                                                   {
  const FracBox b = makeFracBox(yCloud);
#ifdef SEAMS_HAS_MINIMAGE
  if (n > 0 && b.ok && b.triclinic) {
    mi_cell cell;
    if (pointCloudCell(yCloud, &cell)) {
      const auto &pi = yCloud.pts[static_cast<std::size_t>(iatom)];
      const double p[3] = {pi.x, pi.y, pi.z};
      std::vector<double> qs(n * 3);
      for (std::size_t k = 0; k < n; ++k) {
        const auto &pj = yCloud.pts[static_cast<std::size_t>(jatom[k])];
        qs[3 * k] = pj.x;
        qs[3 * k + 1] = pj.y;
        qs[3 * k + 2] = pj.z;
      }
      if (mi_dist2_many(&cell, p, qs.data(), n, distSq) == 0) {
        for (std::size_t k = 0; k < n; ++k) {
          if (smithInside(b, distSq[k])) {
            continue;
          }
          const double q[3] = {qs[3 * k], qs[3 * k + 1], qs[3 * k + 2]};
          double ed[3] = {0.0, 0.0, 0.0};
          if (mi_displacement_euclidean(&cell, q, p, ed) == 0) {
            distSq[k] = ed[0] * ed[0] + ed[1] * ed[1] + ed[2] * ed[2];
          }
        }
        return;
      }
    }
  }
#endif
  for (std::size_t k = 0; k < n; k++) {
    distSq[k] = periodicDistSq(b, yCloud, iatom, jatom[k]);
  }
}

calcMedian()

double gen::calcMedian ( std::vector< double > * input )

inline

Inline generic function for calculating the median given a vector of the values.

Parameters

[in]	yCloud	The input PointCloud, which contains the particle coordinates, simulation box lengths etc.
[in]	input	The input vector with the values

Returns

The median value

Definition at line 87 of file generic.hpp.

                                                   {
  int n = (*input).size(); // Number of elements
  double median;           // Output median value
 
  // Sort a copy (avoid mutating input)
  std::vector<double> sorted = *input;
  std::sort(sorted.begin(), sorted.end());
 
  // Calculate the median
  // For even values, the median is the average of the two middle values
  if (n % 2 == 0) {
    median = 0.5 * (sorted[n / 2] + sorted[n / 2 - 1]);
  } else {
    median = sorted[(n + 1) / 2 - 1];
  }
 
  return median;
}

compareByAtomID()

bool gen::compareByAtomID ( const molSys::Point< double > & a, const molSys::Point< double > & b )

inline

Inline generic function for sorting or comparing two particles, according to the atom ID when the entire Point objects have been passed.

Parameters

[in]	a	The input Point for A.
[in]	b	The input Point for B.

Returns

True if the atom ID of A is less than the atom ID of B

Definition at line 620 of file generic.hpp.

                                                          {
  return a.atomID < b.atomID;
}

distance()

double gen::distance ( const molSys::PointCloud< molSys::Point< double >, double > & yCloud, int iatom, int jatom )

inline

Inline generic function for obtaining the wrapped distance between two particles WITHOUT applying PBCs, whose indices (not IDs) have been given.

Parameters

[in]	yCloud	The input PointCloud, which contains the particle coordinates, simulation box lengths etc.
[in]	iatom	The index of the \( i^{th} \) atom.
[in]	jatom	The index of the \( j^{th} \) atom.

Returns

The wrapped distance.

Definition at line 575 of file generic.hpp.

                    {
  std::array<double, 3> dr;
  double r2 = 0.0; // Squared absolute distance
 
  // Get x1-x2 etc
  dr[0] = fabs(yCloud.pts[iatom].x - yCloud.pts[jatom].x);
  dr[1] = fabs(yCloud.pts[iatom].y - yCloud.pts[jatom].y);
  dr[2] = fabs(yCloud.pts[iatom].z - yCloud.pts[jatom].z);
 
  // Get the squared absolute distance
  for (int k = 0; k < 3; k++) {
    r2 += pow(dr[k], 2.0);
  }
 
  return sqrt(r2);
}

eigenVecAngle()

double gen::eigenVecAngle	(	std::vector< double >	OO,
		std::vector< double >	OH )

Eigen function for getting the angle (in radians) between the O–O and O-H vectors.

file_exists()

bool gen::file_exists ( const std::string & name )

inline

Function for checking if a file exists or not.

Parameters

[in]

name

The name of the file

Definition at line 684 of file generic.hpp.

                                               {
  return std::filesystem::exists(name);
}

formatDumpBox()

std::string gen::formatDumpBox ( const std::vector< double > & box )

inline

Definition at line 465 of file generic.hpp.

                                                             {
  std::ostringstream oss;
  if (box.size() >= 3) {
    oss << box[0] << ' ' << box[1] << ' ' << box[2];
  }
  if (box.size() >= 6) {
    oss << " xy " << box[3] << " xz " << box[4] << " yz " << box[5];
  }
  return oss.str();
}

fracDelta()

std::array< double, 3 > gen::fracDelta ( const FracBox & b, double xi, double yi, double zi, double xj, double yj, double zj )

inline

Definition at line 203 of file generic.hpp.

                                                  {
  if (!b.triclinic) {
    std::array<double, 3> dr = {xi - xj, yi - yj, zi - zj};
    const double len[3] = {b.lx, b.ly, b.lz};
    for (int k = 0; k < 3; k++) {
      dr[static_cast<std::size_t>(k)] -=
          len[k] * std::floor(dr[static_cast<std::size_t>(k)] / len[k] + 0.5);
    }
    return dr;
  }
  const double sz_i = (zi - b.oz) / b.lz;
  const double sy_i = (yi - b.oy - b.yz * sz_i) / b.ly;
  const double sx_i = (xi - b.ox - b.xy * sy_i - b.xz * sz_i) / b.lx;
  const double sz_j = (zj - b.oz) / b.lz;
  const double sy_j = (yj - b.oy - b.yz * sz_j) / b.ly;
  const double sx_j = (xj - b.ox - b.xy * sy_j - b.xz * sz_j) / b.lx;
  double dsx = sx_i - sx_j;
  double dsy = sy_i - sy_j;
  double dsz = sz_i - sz_j;
  dsx -= std::round(dsx);
  dsy -= std::round(dsy);
  dsz -= std::round(dsz);
  return {b.lx * dsx + b.xy * dsy + b.xz * dsz, b.ly * dsy + b.yz * dsz,
          b.lz * dsz};
}

fracDistSq()

double gen::fracDistSq ( const FracBox & b, double xi, double yi, double zi, double xj, double yj, double zj )

inline

Definition at line 231 of file generic.hpp.

                                                          {
  const auto dr = fracDelta(b, xi, yi, zi, xj, yj, zj);
  return dr[0] * dr[0] + dr[1] * dr[1] + dr[2] * dr[2];
}

getAverageWithoutOutliers()

double gen::getAverageWithoutOutliers

(

std::vector< double >

inpVec

)

Get the average, after excluding the outliers, using quartiles.

makeFracBox()

FracBox gen::makeFracBox ( const molSys::PointCloud< molSys::Point< double >, double > & yCloud )

inline

Definition at line 154 of file generic.hpp.

                                                                         {
  FracBox b;
  const auto &box = yCloud.box;
  const auto &boxLow = yCloud.boxLow;
  b.ox = boxLow.size() > 0 ? boxLow[0] : 0.0;
  b.oy = boxLow.size() > 1 ? boxLow[1] : 0.0;
  b.oz = boxLow.size() > 2 ? boxLow[2] : 0.0;
  if (box.size() >= 6) {
    const double xy = box[3];
    const double xz = box[4];
    const double yz = box[5];
    const double xmin = std::min(std::min(0.0, xy), std::min(xz, xy + xz));
    const double xmax = std::max(std::max(0.0, xy), std::max(xz, xy + xz));
    const double ymin = std::min(0.0, yz);
    const double ymax = std::max(0.0, yz);
    b.lx = box[0] - xmax + xmin;
    b.ly = box[1] - ymax + ymin;
    b.lz = box[2];
    b.xy = xy;
    b.xz = xz;
    b.yz = yz;
    b.ox -= xmin;
    b.oy -= ymin;
    b.triclinic = true;
  } else if (box.size() >= 3) {
    b.lx = box[0];
    b.ly = box[1];
    b.lz = box[2];
  } else {
    return b;
  }
  if (!(b.lx > 0.0 && b.ly > 0.0 && b.lz > 0.0)) {
    return b;
  }
  const double bcz = b.xy * b.yz - b.ly * b.xz;
  b.wx = b.lx * b.ly * b.lz /
         std::sqrt(b.ly * b.lz * b.ly * b.lz + b.xy * b.lz * b.xy * b.lz +
                   bcz * bcz);
  b.wy = b.ly * b.lz / std::sqrt(b.lz * b.lz + b.yz * b.yz);
  b.wz = b.lz;
  b.halfMin = 0.5 * std::min(b.wx, std::min(b.wy, b.wz));
  b.ok = true;
  return b;
}

periodicDist()

double gen::periodicDist ( const molSys::PointCloud< molSys::Point< double >, double > & yCloud, int iatom, int jatom )

inline

Inline generic function for obtaining the unwrapped periodic distance between two particles, whose indices (not IDs) have been given.

Parameters

[in]	yCloud	The input PointCloud, which contains the particle coordinates, simulation box lengths etc.
[in]	iatom	The index of the \( i^{th} \) atom.
[in]	jatom	The index of the \( j^{th} \) atom.

Returns

The unwrapped periodic distance.

Definition at line 417 of file generic.hpp.

                                   {
  return std::sqrt(periodicDistSq(yCloud, iatom, jatom));
}

periodicDistSq() [1/2]

double gen::periodicDistSq ( const FracBox & b, const molSys::PointCloud< molSys::Point< double >, double > & yCloud, int iatom, int jatom )

inline

Inline generic function for obtaining the unwrapped periodic distance between two particles, whose indices (not IDs) have been given.

Parameters

[in]	yCloud	The input PointCloud, which contains the particle coordinates, simulation box lengths etc.
[in]	iatom	The index of the \( i^{th} \) atom.
[in]	jatom	The index of the \( j^{th} \) atom.

Returns

The unwrapped periodic distance.

Definition at line 363 of file generic.hpp.

                                     {
  const auto &pi = yCloud.pts[static_cast<std::size_t>(iatom)];
  const auto &pj = yCloud.pts[static_cast<std::size_t>(jatom)];
  if (b.ok) {
    const double r2 = fracDistSq(b, pi.x, pi.y, pi.z, pj.x, pj.y, pj.z);
    if (smithInside(b, r2)) {
      return r2;
    }
#ifdef SEAMS_HAS_MINIMAGE
    double ed[3] = {0.0, 0.0, 0.0};
    if (euclideanDelta(yCloud, pi.x, pi.y, pi.z, pj.x, pj.y, pj.z, ed)) {
      return ed[0] * ed[0] + ed[1] * ed[1] + ed[2] * ed[2];
    }
#endif
    return r2;
  }
  if (yCloud.box.size() >= 6) {
    const auto dr =
        triclinicMinImage(yCloud, pi.x, pi.y, pi.z, pj.x, pj.y, pj.z);
    return dr[0] * dr[0] + dr[1] * dr[1] + dr[2] * dr[2];
  }
  std::array<double, 3> dr;
  double r2 = 0.0;
  dr[0] = std::fabs(pi.x - pj.x);
  dr[1] = std::fabs(pi.y - pj.y);
  dr[2] = std::fabs(pi.z - pj.z);
  for (int k = 0; k < 3; k++) {
    dr[static_cast<std::size_t>(k)] -=
        yCloud.box[static_cast<std::size_t>(k)] *
        std::round(dr[static_cast<std::size_t>(k)] /
                   yCloud.box[static_cast<std::size_t>(k)]);
    r2 += dr[static_cast<std::size_t>(k)] * dr[static_cast<std::size_t>(k)];
  }
  return r2;
}

periodicDistSq() [2/2]

double gen::periodicDistSq ( const molSys::PointCloud< molSys::Point< double >, double > & yCloud, int iatom, int jatom )

inline

Definition at line 402 of file generic.hpp.

                                     {
  return periodicDistSq(makeFracBox(yCloud), yCloud, iatom, jatom);
}

prettyPrintYoda()

int gen::prettyPrintYoda ( const molSys::PointCloud< molSys::Point< double >, double > & yCloud, std::string outFile )

nodiscard

Generic function for printing all the struct information.

radDeg()

double gen::radDeg ( double angle )

inline

Inline function for converting radians->degrees.

Parameters

[in]

angle

The input angle, in radians

Returns

The input angle, in degrees

Definition at line 71 of file generic.hpp.

{ return (angle * 180) / gen::pi; }

relDist()

std::array< double, 3 > gen::relDist ( const molSys::PointCloud< molSys::Point< double >, double > & yCloud, int iatom, int jatom )

inline

Inline generic function for getting the relative unwrapped distance between two particles for each dimension.

The indices (not IDs) of the particles have been given.

Parameters

[in]	yCloud	The input PointCloud, which contains the particle coordinates, simulation box lengths etc.
[in]	iatom	The index of the \( i^{th} \) atom.
[in]	jatom	The index of the \( j^{th} \) atom.

Returns

The unwrapped relative distances for each dimension.

Definition at line 605 of file generic.hpp.

                   {
  return relDistFromPoint(yCloud, iatom, yCloud.pts[jatom].x,
                          yCloud.pts[jatom].y, yCloud.pts[jatom].z);
}

relDistFromPoint() [1/2]

std::array< double, 3 > gen::relDistFromPoint ( const FracBox & b, const molSys::PointCloud< molSys::Point< double >, double > & yCloud, int iatom, double xj, double yj, double zj )

inline

Inline generic function for obtaining the unwrapped periodic distance between one particle and another point, whose index has been given.

Parameters

[in]	b	The box of yCloud, from makeFracBox.
[in]	yCloud	The input PointCloud, which contains the particle coordinates, simulation box lengths etc.
[in]	iatom	The index of the \( i^{th} \) atom.
[in]	xj,yj,zj	The other point.

Returns

The unwrapped periodic distance.

Definition at line 512 of file generic.hpp.

                                     {
  if (b.ok) {
    const auto &pi = yCloud.pts[static_cast<std::size_t>(iatom)];
    const auto dr = fracDelta(b, pi.x, pi.y, pi.z, xj, yj, zj);
    const double r2 = dr[0] * dr[0] + dr[1] * dr[1] + dr[2] * dr[2];
    if (smithInside(b, r2)) {
      return dr;
    }
#ifdef SEAMS_HAS_MINIMAGE
    double ed[3] = {0.0, 0.0, 0.0};
    if (euclideanDelta(yCloud, pi.x, pi.y, pi.z, xj, yj, zj, ed)) {
      return {ed[0], ed[1], ed[2]};
    }
#endif
    return dr;
  }
  if (yCloud.box.size() >= 6) {
    return triclinicMinImage(yCloud, yCloud.pts[iatom].x, yCloud.pts[iatom].y,
                             yCloud.pts[iatom].z, xj, yj, zj);
  }
 
  std::array<double, 3> dr = {yCloud.pts[iatom].x - xj, yCloud.pts[iatom].y - yj,
                              yCloud.pts[iatom].z - zj};
  for (int k = 0; k < 3; k++) {
    if (dr[k] < -yCloud.box[k] * 0.5) {
      dr[k] += yCloud.box[k];
    }
    if (dr[k] >= yCloud.box[k] * 0.5) {
      dr[k] -= yCloud.box[k];
    }
  }
  return dr;
}

relDistFromPoint() [2/2]

std::array< double, 3 > gen::relDistFromPoint ( const molSys::PointCloud< molSys::Point< double >, double > & yCloud, int iatom, double xj, double yj, double zj )

inline

Definition at line 549 of file generic.hpp.

                                     {
  return relDistFromPoint(makeFracBox(yCloud), yCloud, iatom, xj, yj, zj);
}

smithInside()

bool gen::smithInside ( const FracBox & b, double r2 )

inline

Definition at line 241 of file generic.hpp.

                                                     {
  return b.ok && (!b.triclinic || std::sqrt(r2) + 1e-12 < b.halfMin);
}

tokenizer()

std::vector< std::string > gen::tokenizer ( std::string line )

inline

Function for tokenizing line strings into words (strings) delimited by whitespace.

This returns a vector with the words in it.

Parameters

[in]

line

The string containing the line to be tokenized

Definition at line 645 of file generic.hpp.

                                                      {
  std::istringstream iss(line);
  std::vector<std::string> tokens{std::istream_iterator<std::string>{iss},
                                  std::istream_iterator<std::string>{}};
  return tokens;
}

tokenizerDouble()

std::vector< double > gen::tokenizerDouble ( std::string line )

inline

Function for tokenizing line strings into a vector of doubles.

Parameters

[in]

line

The string containing the line to be tokenized

Definition at line 656 of file generic.hpp.

                                                         {
  std::istringstream iss(line);
  std::vector<double> tokens;
  double number; // Each number being read in from the line
  while (iss >> number) {
    tokens.push_back(number);
  }
  return tokens;
}

tokenizerInt()

std::vector< int > gen::tokenizerInt ( std::string line )

inline

Function for tokenizing line strings into a vector of ints.

Parameters

[in]

line

The string containing the line to be tokenized

Definition at line 670 of file generic.hpp.

                                                   {
  std::istringstream iss(line);
  std::vector<int> tokens;
  int number; // Each number being read in from the line
  while (iss >> number) {
    tokens.push_back(number);
  }
  return tokens;
}

triclinicMinImage()

std::array< double, 3 > gen::triclinicMinImage ( const molSys::PointCloud< molSys::Point< double >, double > & yCloud, double xi, double yi, double zi, double xj, double yj, double zj )

inline

Definition at line 298 of file generic.hpp.

                                                           {
  const FracBox b = makeFracBox(yCloud);
  if (b.ok && b.triclinic) {
    const auto dr = fracDelta(b, xi, yi, zi, xj, yj, zj);
    const double r2 = dr[0] * dr[0] + dr[1] * dr[1] + dr[2] * dr[2];
    if (smithInside(b, r2)) {
      return dr;
    }
#ifdef SEAMS_HAS_MINIMAGE
    double ed[3] = {0.0, 0.0, 0.0};
    if (euclideanDelta(yCloud, xi, yi, zi, xj, yj, zj, ed)) {
      return {ed[0], ed[1], ed[2]};
    }
#endif
    return dr;
  }
  const auto &box = yCloud.box;
  const auto &boxLow = yCloud.boxLow;
  const double xspan = box[0];
  const double yspan = box[1];
  const double zspan = box[2];
  const double xlo_b = boxLow.size() > 0 ? boxLow[0] : 0.0;
  const double ylo_b = boxLow.size() > 1 ? boxLow[1] : 0.0;
  const double zlo_b = boxLow.size() > 2 ? boxLow[2] : 0.0;
  const double xy = box[3];
  const double xz = box[4];
  const double yz = box[5];
  const double xmin = std::min(std::min(0.0, xy), std::min(xz, xy + xz));
  const double xmax = std::max(std::max(0.0, xy), std::max(xz, xy + xz));
  const double ymin = std::min(0.0, yz);
  const double ymax = std::max(0.0, yz);
  const double lx = xspan - xmax + xmin;
  const double ly = yspan - ymax + ymin;
  const double lz = zspan;
  const double ox = xlo_b - xmin;
  const double oy = ylo_b - ymin;
  const double oz = zlo_b;
  const double sz_i = (zi - oz) / lz;
  const double sy_i = (yi - oy - yz * sz_i) / ly;
  const double sx_i = (xi - ox - xy * sy_i - xz * sz_i) / lx;
  const double sz_j = (zj - oz) / lz;
  const double sy_j = (yj - oy - yz * sz_j) / ly;
  const double sx_j = (xj - ox - xy * sy_j - xz * sz_j) / lx;
  double dsx = sx_i - sx_j;
  double dsy = sy_i - sy_j;
  double dsz = sz_i - sz_j;
  dsx -= std::round(dsx);
  dsy -= std::round(dsy);
  dsz -= std::round(dsz);
  return {lx * dsx + xy * dsy + xz * dsz, ly * dsy + yz * dsz, lz * dsz};
}

unwrappedCoordShift()

int gen::unwrappedCoordShift ( const molSys::PointCloud< molSys::Point< double >, double > & yCloud, int iatomIndex, int jatomIndex, double * x_i, double * y_i, double * z_i, double * x_j, double * y_j, double * z_j )

nodiscard

Shift particles (unwrapped coordinates).

unWrappedDistFromPoint()

double gen::unWrappedDistFromPoint ( const molSys::PointCloud< molSys::Point< double >, double > & yCloud, int iatom, const std::vector< double > & singlePoint )

inline

Definition at line 555 of file generic.hpp.

                                          {
  const auto dr =
      relDistFromPoint(yCloud, iatom, singlePoint[0], singlePoint[1],
                       singlePoint[2]);
  return std::sqrt(dr[0] * dr[0] + dr[1] * dr[1] + dr[2] * dr[2]);
}

writeDumpBoxBounds()

void gen::writeDumpBoxBounds ( std::ostream & os, const molSys::PointCloud< molSys::Point< double >, double > & yCloud )

inline

Definition at line 477 of file generic.hpp.

                                                                 {
  const bool tilt = yCloud.box.size() >= 6;
  if (tilt) {
    os << "ITEM: BOX BOUNDS xy xz yz pp pp pp\n";
  } else {
    os << "ITEM: BOX BOUNDS pp pp pp\n";
  }
  for (int k = 0; k < 3; k++) {
    const double lo = (static_cast<std::size_t>(k) < yCloud.boxLow.size())
                          ? yCloud.boxLow[k]
                          : 0.0;
    const double len = (static_cast<std::size_t>(k) < yCloud.box.size())
                           ? yCloud.box[k]
                           : 0.0;
    os << lo << ' ' << lo + len;
    if (tilt) {
      os << ' ' << yCloud.box[static_cast<std::size_t>(k + 3)];
    }
    os << '\n';
  }
}

Variable Documentation

halfMin

double gen::FracBox::halfMin = 0.0

Definition at line 148 of file generic.hpp.

lx

double gen::FracBox::lx = 0.0

Definition at line 136 of file generic.hpp.

ly

double gen::FracBox::ly = 0.0

Definition at line 137 of file generic.hpp.

lz

double gen::FracBox::lz = 0.0

Definition at line 138 of file generic.hpp.

ok

bool gen::FracBox::ok = false

Definition at line 150 of file generic.hpp.

ox

double gen::FracBox::ox = 0.0

Definition at line 142 of file generic.hpp.

oy

double gen::FracBox::oy = 0.0

Definition at line 143 of file generic.hpp.

oz

double gen::FracBox::oz = 0.0

Definition at line 144 of file generic.hpp.

pi

double gen::pi = std::numbers::pi

constexpr

Uses Boost to get the value of pi.

Definition at line 64 of file generic.hpp.

triclinic

bool gen::FracBox::triclinic = false

Definition at line 149 of file generic.hpp.

wx

double gen::FracBox::wx = 0.0

Definition at line 145 of file generic.hpp.

wy

double gen::FracBox::wy = 0.0

Definition at line 146 of file generic.hpp.

wz

double gen::FracBox::wz = 0.0

Definition at line 147 of file generic.hpp.

xy

double gen::FracBox::xy = 0.0

Definition at line 139 of file generic.hpp.

xz

double gen::FracBox::xz = 0.0

Definition at line 140 of file generic.hpp.

yz

double gen::FracBox::yz = 0.0

Definition at line 141 of file generic.hpp.