Gen

Topics
	Ring

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

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.
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 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::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 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.
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.

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 478 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 250 of file generic.hpp.

                                                   {
  for (std::size_t k = 0; k < n; k++) {
    distSq[k] = periodicDistSq(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 401 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 356 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 465 of file generic.hpp.

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

formatDumpBox()

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

inline

Definition at line 259 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();
}

getAverageWithoutOutliers()

double gen::getAverageWithoutOutliers

(

std::vector< double >

inpVec

)

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

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 243 of file generic.hpp.

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

periodicDistSq()

double gen::periodicDistSq ( 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 196 of file generic.hpp.

                                     {
#ifdef SEAMS_HAS_MINIMAGE
  const mi_cell cell = pointCloudCell(yCloud);
  const double p[3] = {yCloud.pts[iatom].x, yCloud.pts[iatom].y,
                       yCloud.pts[iatom].z};
  const double q[3] = {yCloud.pts[jatom].x, yCloud.pts[jatom].y,
                       yCloud.pts[jatom].z};
  double out = 0.0;
  mi_dist2(&cell, p, q, &out);
  return out;
#else
  if (yCloud.box.size() >= 6) {
    const auto dr = triclinicMinImage(
        yCloud, yCloud.pts[iatom].x, yCloud.pts[iatom].y, yCloud.pts[iatom].z,
        yCloud.pts[jatom].x, yCloud.pts[jatom].y, yCloud.pts[jatom].z);
    return dr[0] * dr[0] + dr[1] * dr[1] + dr[2] * dr[2];
  }
 
  std::array<double, 3> dr;
  double r2 = 0.0; // Squared absolute distance
 
  // Get x1-x2 etc
  dr[0] = std::fabs(yCloud.pts[iatom].x - yCloud.pts[jatom].x);
  dr[1] = std::fabs(yCloud.pts[iatom].y - yCloud.pts[jatom].y);
  dr[2] = std::fabs(yCloud.pts[iatom].z - yCloud.pts[jatom].z);
 
  // Three-axis wrap for an orthorhombic length-3 box
  for (int k = 0; k < 3; k++) {
    dr[k] -= yCloud.box[k] * std::round(dr[k] / yCloud.box[k]);
    r2 += dr[k] * dr[k];
  }
 
  return r2;
#endif
}

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 386 of file generic.hpp.

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

relDistFromPoint()

std::array< double, 3 > gen::relDistFromPoint ( 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]	yCloud	The input PointCloud, which contains the particle coordinates, simulation box lengths etc.
[in]	iatom	The index of the \( i^{th} \) atom.
[in]	singlePoint	Vector containing coordinate values

Returns

The unwrapped periodic distance.

Definition at line 305 of file generic.hpp.

                                     {
#ifdef SEAMS_HAS_MINIMAGE
  const mi_cell cell = pointCloudCell(yCloud);
  const double p[3] = {xj, yj, zj};
  const double q[3] = {yCloud.pts[iatom].x, yCloud.pts[iatom].y,
                       yCloud.pts[iatom].z};
  double dr[3] = {0.0, 0.0, 0.0};
  mi_displacement(&cell, p, q, dr);
  return {dr[0], dr[1], dr[2]};
#else
  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;
#endif
}

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 426 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 437 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 451 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 134 of file generic.hpp.

                                                           {
#ifdef SEAMS_HAS_MINIMAGE
  const mi_cell cell = pointCloudCell(yCloud);
  const double p[3] = {xj, yj, zj};
  const double q[3] = {xi, yi, zi};
  double dr[3] = {0.0, 0.0, 0.0};
  mi_displacement(&cell, p, q, dr);
  return {dr[0], dr[1], dr[2]};
#else
  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;
 
  auto toFrac = [&](double x, double y, double z) {
    const double sz = (z - oz) / lz;
    const double sy = (y - oy - yz * sz) / ly;
    const double sx = (x - ox - xy * sy - xz * sz) / lx;
    return std::array<double, 3>{sx, sy, sz};
  };
  const auto si = toFrac(xi, yi, zi);
  const auto sj = toFrac(xj, yj, zj);
  double dsx = si[0] - sj[0];
  double dsy = si[1] - sj[1];
  double dsz = si[2] - sj[2];
  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};
#endif
}

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 336 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 271 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

pi

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

constexpr

Uses Boost to get the value of pi.

Definition at line 64 of file generic.hpp.