topo_bulk.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 __TOPO_BULK_H_
#define __TOPO_BULK_H_
 
#include <algorithm>
#include <array>
#include <fstream>
#include <iostream>
#include <iterator>
#include <math.h>
#include <memory>
#include <sstream>
#include <string>
#include <sys/stat.h>
#include <vector>
 
#include <cage.hpp>
#include <mol_sys.hpp>
#include <order_parameter.hpp>
#include <ring.hpp>
#include <seams_input.hpp>
#include <seams_output.hpp>
#include <shapeMatch.hpp>
 
namespace ring {
 
int bulkPolygonRingAnalysis(
    std::string path, std::vector<std::vector<int>> rings,
    std::vector<std::vector<int>> nList,
    molSys::PointCloud<molSys::Point<double>, double> *yCloud, int maxDepth,
    int firstFrame);
 
// DDC HC Ring functions
 
int topoBulkAnalysis(std::string path, std::vector<std::vector<int>> rings,
                     std::vector<std::vector<int>> nList,
                     molSys::PointCloud<molSys::Point<double>, double> *yCloud,
                     int firstFrame, bool onlyTetrahedral = true);
 
std::vector<int> findDDC(std::vector<std::vector<int>> rings,
                         std::vector<strucType> *ringType,
                         std::vector<int> listHC,
                         std::vector<cage::Cage> *cageList);
 
std::vector<int> findMixedRings(std::vector<std::vector<int>> rings,
                                std::vector<strucType> *ringType,
                                std::vector<int> *listDDC,
                                std::vector<int> *listHC);
 
std::vector<int> findHC(std::vector<std::vector<int>> rings,
                        std::vector<strucType> *ringType,
                        std::vector<std::vector<int>> nList,
                        std::vector<cage::Cage> *cageList);
 
bool conditionOneDDC(std::vector<std::vector<int>> rings,
                     std::vector<int> *peripheralRings, int iring);
 
bool conditionTwoDDC(std::vector<std::vector<int>> rings,
                     std::vector<int> *peripheralRings, int iring);
 
bool conditionThreeDDC(std::vector<std::vector<int>> rings,
                       std::vector<int> *peripheralRings);
 
bool basalConditions(std::vector<std::vector<int>> nList,
                     std::vector<int> *basal1, std::vector<int> *basal2);
 
bool basalNeighbours(std::vector<std::vector<int>> nList,
                     std::vector<int> *triplet, int atomOne, int atomTwo);
 
bool notNeighboursOfRing(std::vector<std::vector<int>> nList,
                         std::vector<int> *triplet, std::vector<int> *ring);
 
int findPrismatic(std::vector<std::vector<int>> rings, std::vector<int> *listHC,
                  std::vector<strucType> *ringType, int iring, int jring,
                  std::vector<int> *prismaticRings);
 
int getAtomTypesTopoBulk(std::vector<std::vector<int>> rings,
                         std::vector<ring::strucType> ringType,
                         std::vector<cage::iceType> *atomTypes);
 
int getStrucNumbers(std::vector<ring::strucType> ringType,
                    std::vector<cage::Cage> cageList, int *numHC, int *numDDC,
                    int *mixedRings, int *prismaticRings, int *basalRings);
 
} // namespace ring
 
namespace prism3 {
 
int findBulkPrisms(std::vector<std::vector<int>> rings,
                   std::vector<ring::strucType> *ringType,
                   std::vector<std::vector<int>> nList,
                   molSys::PointCloud<molSys::Point<double>, double> *yCloud,
                   std::vector<double> *rmsdPerAtom, double heightCutoff = 8);
 
bool basalPrismConditions(std::vector<std::vector<int>> nList,
                          std::vector<int> *basal1, std::vector<int> *basal2);
 
bool relaxedPrismConditions(std::vector<std::vector<int>> nList,
                            std::vector<int> *basal1, std::vector<int> *basal2);
 
bool basalRingsSeparation(
    molSys::PointCloud<molSys::Point<double>, double> *yCloud,
    std::vector<int> basal1, std::vector<int> basal2, double heightCutoff = 8);
} // namespace prism3
namespace prism3 {…}
 
#endif // __TOPO_BULK_H_