Gen

Collaboration diagram for Gen:

Modules
	Ring

Functions
double	gen::radDeg (double angle)
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. More...
double	gen::getAverageWithoutOutliers (std::vector< double > inpVec)
	Get the average, after excluding the outliers, using quartiles. More...
double	gen::calcMedian (std::vector< double > *input)
	Inline generic function for calculating the median given a vector of the values. More...
double	gen::periodicDist (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. More...
double	gen::unWrappedDistFromPoint (molSys::PointCloud< molSys::Point< double >, double > *yCloud, int iatom, std::vector< double > singlePoint)
double	gen::distance (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. More...
std::array< double, 3 >	gen::relDist (molSys::PointCloud< molSys::Point< double >, double > *yCloud, int iatom, int jatom)
bool	gen::compareByAtomID (const molSys::Point< double > &a, const molSys::Point< double > &b)
int	gen::prettyPrintYoda (molSys::PointCloud< molSys::Point< double >, double > *yCloud, std::string outFile)
	Generic function for printing all the struct information. More...
int	gen::unwrappedCoordShift (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) More...
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. This returns a vector with the words in it. More...
std::vector< double >	gen::tokenizerDouble (std::string line)
	Function for tokenizing line strings into a vector of doubles. More...
std::vector< int >	gen::tokenizerInt (std::string line)
	Function for tokenizing line strings into a vector of ints. More...
bool	gen::file_exists (const std::string &name)
	Function for checking if a file exists or not. More...
std::vector< std::complex< double > >	gen::avgVector (std::vector< std::complex< double >> v, int l, int neigh)

Variables
const double	gen::pi = boost::math::constants::pi<double>()

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

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

Parameters

[in]	quat1	The first quaternion
[in]	quat2	The second quaternion

Returns

The output angle between the input quaternions, in degrees

Definition at line 267 of file generic.cpp.

                                                           {
  //
  double prod; // Product of quat1 and conjugate of quat2
  // The angular distance is
  // angularDistance = 2*cosInverse(quat1*conj(quat2))
  prod = quat1[0] * quat2[0] - quat1[1] * quat2[1] - quat1[2] * quat2[2] -
         quat1[3] * quat2[3];
  // The angular distance is:
  double angDist = 2 * acos(prod) * 180.0 / (gen::pi);
  // Return the angular distance
  return angDist;
}

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

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

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

                                                   {
  int n = (*input).size(); // Number of elements
  double median;           // Output median value
 
  // Sort the vector
  std::sort((*input).begin(), (*input).end());
 
  // Calculate the median
  // For even values, the median is the average of the two middle values
  if (n % 2 == 0) {
    median = 0.5 * ((*input)[n / 2] + (*input)[n / 2 - 1]); // n/2+n/2-1
  } // median is average of middle values
  else {
    median = (*input)[(n + 1) / 2 -
                      1]; // middle value of 7 elements is the 4th element
  }                       // if odd, it is the middle value
 
  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 234 of file generic.hpp.

                                                          {
  return a.atomID < b.atomID;
}

distance()

double gen::distance ( 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 170 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.

Function for obtaining the angle between two input vectors (std::vector). Internally, the vectors are converted to Eigen vectors. The dot product between the input vectors is used to calculate the angle between them.

Parameters

[in]	OO	The O–O vector (but can be any vector, in general).
[in]	OH	The O-H vector (but can be any vector, in general).

Returns

The output angle between the input vectors, in radians

Definition at line 155 of file generic.cpp.

                                                                    {
  Eigen::Vector3d eigOO = Eigen::Map<Eigen::Vector3d>(OO.data(), OO.size());
  Eigen::Vector3d eigOH = Eigen::Map<Eigen::Vector3d>(OH.data(), OH.size());
  double angle;
  angle = acos(eigOO.dot(eigOH) / (eigOO.norm() * eigOH.norm()));
  return angle;
}

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

                                               {
  // Replace by boost function later
  struct stat buffer;
  return (stat(name.c_str(), &buffer) == 0);
}

getAverageWithoutOutliers()

double gen::getAverageWithoutOutliers

(

std::vector< double >

inpVec

)

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

Get the average, after excluding the outliers, using quartiles

Parameters

[in]

inpVec

The vector containing values whose average is desired

Returns

The desired average value

Definition at line 169 of file generic.cpp.

                                                              {
  //
  double avgVal = 0.0;   // Average value, excluding the outliers
  double median;         // Median value
  int n = inpVec.size(); // Number of values
  std::vector<double> lowerRange,
      upperRange;                       // n/2 smallest and n/2 largest numbers
  double firstQuartile, thirdQuartile;  // First and third quartiles
  double iqr;                           // Interquartile range
  double outlierLimLow, outlierLimHigh; // Outliers limit
  int numOfObservations = 0; // Number of observations used for the average
  // ----------------------
  // Calculate the median (the vector is sorted inside the function)
  median = calcMedian(&inpVec);
  // ----------------------
  // Get the n/2 smallest and largest numbers
  //
  if (n % 2 == 0) {
    for (int i = 0; i < n / 2; i++) {
      // n/2 smallest numbers
      lowerRange.push_back(inpVec[i]);
      // n/2 largest numbers
      upperRange.push_back(inpVec[n / 2 + i]);
    } // end of loop to fill up the n/2 smallest and n/2 largest
  }   // even
  else {
    //
    int halfN = (n + 1) / 2;
    // Exclude the median
    for (int i = 0; i < halfN; i++) {
      // (n+1)/2 smallest numbers
      lowerRange.push_back(inpVec[i]);
      // (n+1)/2 largest numbers
      upperRange.push_back(inpVec[halfN + i]);
    } // end of filling up the smallest and largest half-ranges
  }   // for odd numbers
  // ----------------------
  // Calculate the first and third quartiles, and interquartile range
  //
  // First quartile
  firstQuartile = calcMedian(&lowerRange);
  // Third quartile
  thirdQuartile = calcMedian(&upperRange);
  // Interquartile range
  iqr = thirdQuartile - firstQuartile;
  // ----------------------
  // Calculate the average without outliers
  // Outliers are defined as values which
  // are less than Q1 - 1.5IQR
  // or greater than Q3 + 1.5IQR
  //
  // Get the limits for the outliers
  outlierLimLow = firstQuartile - 1.5 * iqr;
  outlierLimHigh = thirdQuartile + 1.5 * iqr;
  //
  // Loop through the values in inpVec to get the average, excluding outliers
  for (int i = 0; i < n; i++) {
    //
    if (inpVec[i] < outlierLimLow) {
      continue;
    } // lower limit outlier
    else if (inpVec[i] > outlierLimHigh) {
      continue;
    } // higher limit outlier
    else {
      // Number of observations added
      numOfObservations++;
      // Add to the average
      avgVal += inpVec[i];
    } // take the average
  }   // end of loop for getting the average
  //
  // Divide by the number of observations used
  avgVal /= numOfObservations;
  // ----------------------
  // This fails if there are not enough observations (ring size = 3)
  if (numOfObservations == 0) {
    double sumVal = 0.0;
    // Loop through all the values and sum
    for (int i = 0; i <= n; i++) {
      sumVal += inpVec[i];
    } // end of sum
    // Normalize
    avgVal = sumVal / n;
    return avgVal;
  } // for triangular prism blocks
  // ----------------------
 
  return avgVal;
}

periodicDist()

double gen::periodicDist ( 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 108 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++) {
    // Correct for periodicity
    dr[k] -= yCloud->box[k] * round(dr[k] / yCloud->box[k]);
    r2 += pow(dr[k], 2.0);
  }
 
  return sqrt(r2);
}

prettyPrintYoda()

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

Generic function for printing all the struct information.

Function for printing out info in a PointCloud object.

Parameters

[in]	yCloud	The input PointCloud to be printed.
[in]	outFile	The name of the output file to which the information will be printed.

Definition at line 25 of file generic.cpp.

                       {
  std::ofstream outputFile;
  // Create a new file in the output directory
  outputFile.open(outFile);
 
  if (outputFile.is_open()) {
    // First line
    outputFile << "# Frame\tAtomID\tx\ty\tz\tcij\ticeType\n";
    // Write out all the information out line by line
    for (int i = 0; i < yCloud->nop; i++) {
      outputFile << yCloud->currentFrame << "\t" << yCloud->pts[i].atomID
                 << "\t" << yCloud->pts[i].x << "\t" << yCloud->pts[i].y << "\t"
                 << yCloud->pts[i].z << "\t";
      // Print out cij
      // for(int c=0; c<yCloud->pts[i].c_ij.size(); c++){outputFile <<
      // yCloud->pts[i].c_ij[c]<<"\t";} Print out the classifier
      // TODO: Should print string representation
      outputFile << static_cast<int>(yCloud->pts[i].iceType) << "\n";
    }
  }
  // Close the file
  outputFile.close();
  return 0;
}

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

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

relDist()

std::array<double, 3> gen::relDist ( 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 200 of file generic.hpp.

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

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 259 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 270 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 284 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;
}

unwrappedCoordShift()

int gen::unwrappedCoordShift	(	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)

Function for getting the unwrapped coordinates of a pair of atoms.

Parameters

[in]	yCloud	The input PointCloud to be printed.
[in]	iatomIndex	Index of the \( i^{th} \) atom.
[in]	jatomIndex	Index of the \( j^{th} \) atom.
[in,out]	x_i	X Coordinate of the \( i^{th} \) atom corresponding to the unwrapped distance.
[in,out]	y_i	Y Coordinate of the \( i^{th} \) atom corresponding to the unwrapped distance.
[in,out]	z_i	Z Coordinate of the \( i^{th} \) atom corresponding to the unwrapped distance.
[in,out]	x_j	X Coordinate of the \( j^{th} \) atom corresponding to the unwrapped distance.
[in,out]	y_j	Y Coordinate of the \( j^{th} \) atom corresponding to the unwrapped distance.
[in,out]	z_j	Z Coordinate of the \( j^{th} \) atom corresponding to the unwrapped distance.

Definition at line 71 of file generic.cpp.

                              {
  //
  double x_iatom, y_iatom, z_iatom;
  double x_jatom, y_jatom, z_jatom;
  double x_ij, y_ij, z_ij; // Relative distance
  std::vector<double> box = yCloud->box;
  double xPBC, yPBC, zPBC; // Actual unwrapped distance
 
  // ----------------------------------------------------------------------
  // INIT
  // iatom
  x_iatom = yCloud->pts[iatomIndex].x;
  y_iatom = yCloud->pts[iatomIndex].y;
  z_iatom = yCloud->pts[iatomIndex].z;
  // jatom
  x_jatom = yCloud->pts[jatomIndex].x;
  y_jatom = yCloud->pts[jatomIndex].y;
  z_jatom = yCloud->pts[jatomIndex].z;
  // ----------------------------------------------------------------------
  // GET RELATIVE DISTANCE
  x_ij = x_iatom - x_jatom;
  y_ij = y_iatom - y_jatom;
  z_ij = z_iatom - z_jatom;
  // ----------------------------------------------------------------------
  // SHIFT COORDINATES IF REQUIRED
  // Shift x
  if (fabs(x_ij) > 0.5 * box[0]) {
    // Get the actual distance
    xPBC = box[0] - fabs(x_ij);
    if (x_ij < 0) {
      x_jatom = x_iatom - xPBC;
    } // To the -x side of currentIndex
    else {
      x_jatom = x_iatom + xPBC;
    } // Add to the + side
  }   // Shift nextElement
  //
  // Shift y
  if (fabs(y_ij) > 0.5 * box[1]) {
    // Get the actual distance
    yPBC = box[1] - fabs(y_ij);
    if (y_ij < 0) {
      y_jatom = y_iatom - yPBC;
    } // To the -y side of currentIndex
    else {
      y_jatom = y_iatom + yPBC;
    } // Add to the + side
  }   // Shift nextElement
  //
  // Shift z
  if (fabs(z_ij) > 0.5 * box[2]) {
    // Get the actual distance
    zPBC = box[2] - fabs(z_ij);
    if (z_ij < 0) {
      z_jatom = z_iatom - zPBC;
    } // To the -z side of currentIndex
    else {
      z_jatom = z_iatom + zPBC;
    } // Add to the + side
  }   // Shift nextElement
  // ----------------------------------------------------------------------
  // Assign values
  *x_i = x_iatom;
  *y_i = y_iatom;
  *z_i = z_iatom;
  *x_j = x_jatom;
  *y_j = y_jatom;
  *z_j = z_jatom;
 
  return 0;
}

unWrappedDistFromPoint()

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

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 138 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 - singlePoint[0]);
  dr[1] = fabs(yCloud->pts[iatom].y - singlePoint[1]);
  dr[2] = fabs(yCloud->pts[iatom].z - singlePoint[2]);
 
  // Get the squared absolute distance
  for (int k = 0; k < 3; k++) {
    // Correct for periodicity
    dr[k] -= yCloud->box[k] * round(dr[k] / yCloud->box[k]);
    r2 += pow(dr[k], 2.0);
  }
 
  return sqrt(r2);
}

Variable Documentation

pi

const double gen::pi = boost::math::constants::pi<double>()

Uses Boost to get the value of pi.

Definition at line 54 of file generic.hpp.