mol_sys.hpp

Go to the documentation of this file.

Code

//-----------------------------------------------------------------------------------
// d-SEAMS - Deferred Structural Elucidation Analysis for Molecular Simulations
//
// Copyright (c) 2018--present d-SEAMS core team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the MIT License as published by
// the Open Source Initiative.
//
// A copy of the MIT License is included in the LICENSE file of this repository.
// You should have received a copy of the MIT License along with this program.
// If not, see <https://opensource.org/licenses/MIT>.
//-----------------------------------------------------------------------------------
 
#ifndef __MOL_SYS_H_
#define __MOL_SYS_H_
 
#include "boost/multi_array.hpp"
#include <algorithm>
#include <array>
#include <fstream>
#include <iterator>
#include <sstream>
#include <string>
#include <sys/stat.h>
#include <vector>
#include<unordered_map>
 
// For debugging, instantiate the unordered map [consider removal for
// production]
template class std::unordered_map<int, int>;
template class std::vector<std::vector<int>>;
 
namespace molSys {
 
// Enum type for bond type
 
enum class bond_type { staggered, eclipsed, out_of_range };
 
enum class atom_state_type {
  cubic,
  hexagonal,
  water,
  interfacial,
  clathrate,
  interClathrate,
  unclassified,
  reCubic,
  reHex
};
enum class atom_state_type {…};
 
struct Result {
  bond_type classifier; 
  double c_value;       
};
struct Result {…};
 
template <typename T> struct Point {
  int type, molID, atomID;  
  T x, y, z;                
  std::vector<Result> c_ij; 
  atom_state_type iceType =
      molSys::atom_state_type::unclassified; 
  bool inSlice = true;      
};
template <typename T> struct Point {…};
 
// Struct for a collection of points; contains information for a particular
// frame
template <typename S, typename T> struct PointCloud {
  std::vector<S> pts;    
  int currentFrame;      
  int nop;               
  std::vector<T> box;    
  std::vector<T> boxLow; 
  std::unordered_map<int, int> idIndexMap;
};
template <typename S, typename T> struct PointCloud {…};
 
std::unordered_map<int, int>
createIDMolIDmap(molSys::PointCloud<molSys::Point<double>, double> *yCloud);
 
std::unordered_multimap<int, int>
createMolIDAtomIDMultiMap(molSys::PointCloud<molSys::Point<double>, double> *yCloud);
 
std::vector<std::vector<int>>
hAtomMolList(molSys::PointCloud<molSys::Point<double>, double> *hCloud,
             molSys::PointCloud<molSys::Point<double>, double> *oCloud);
 
int searchMolList(std::vector<std::vector<int>> molList, int molIDtoFind);
 
molSys::PointCloud<molSys::Point<double>, double>
clearPointCloud(molSys::PointCloud<molSys::Point<double>, double> *yCloud);
} // namespace molSys
namespace molSys {…}
 
#endif // __MOL_SYS_H_