topo_bulk.hpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------------
// 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 SEAMS_TOPO_BULK_H_
#define SEAMS_TOPO_BULK_H_
 
#include <algorithm>
#include <array>
#include <fstream>
#include <iostream>
#include <iterator>
#include <cmath>
#include <memory>
#include <sstream>
#include <string>
#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 {

[[nodiscard]] int bulkPolygonRingAnalysis(
    std::string path, const std::vector<std::vector<int>> &rings,
    const std::vector<std::vector<int>> &nList,
    molSys::PointCloud<molSys::Point<double>, double> &yCloud, int maxDepth,
    int firstFrame);
 
// DDC HC Ring functions

[[nodiscard]] int topoBulkAnalysis(std::string path, const std::vector<std::vector<int>> &rings,
                     const std::vector<std::vector<int>> &nList,
                     molSys::PointCloud<molSys::Point<double>, double> &yCloud,
                     int firstFrame, bool onlyTetrahedral = true);

struct RingSearchIndex {
  std::vector<std::vector<int>> ringsContainingAtom;
};

[[nodiscard]] RingSearchIndex
buildRingSearchIndex(const std::vector<std::vector<int>> &rings, int numAtoms);

std::vector<int> findDDC(const std::vector<std::vector<int>> &rings,
                         std::vector<strucType> &ringType,
                         const std::vector<int> &listHC,
                         std::vector<cage::Cage> &cageList);

std::vector<int> findDDC(const std::vector<std::vector<int>> &rings,
                         std::vector<strucType> &ringType,
                         const std::vector<int> &listHC,
                         std::vector<cage::Cage> &cageList,
                         const RingSearchIndex &index);

std::vector<int> findMixedRings(const std::vector<std::vector<int>> &rings,
                                std::vector<strucType> &ringType,
                                std::vector<int> &listDDC,
                                std::vector<int> &listHC);

std::vector<int> findHC(const std::vector<std::vector<int>> &rings,
                        std::vector<strucType> &ringType,
                        const std::vector<std::vector<int>> &nList,
                        std::vector<cage::Cage> &cageList);

std::vector<int> findHC(const std::vector<std::vector<int>> &rings,
                        std::vector<strucType> &ringType,
                        const std::vector<std::vector<int>> &nList,
                        std::vector<cage::Cage> &cageList,
                        const RingSearchIndex &index);

bool conditionOneDDC(const std::vector<std::vector<int>> &rings,
                     std::vector<int> &peripheralRings, int iring);

bool conditionOneDDC(const std::vector<std::vector<int>> &rings,
                     std::vector<int> &peripheralRings, int iring,
                     const RingSearchIndex &index);

bool conditionTwoDDC(const std::vector<std::vector<int>> &rings,
                     std::vector<int> &peripheralRings, int iring);

bool conditionTwoDDC(const std::vector<std::vector<int>> &rings,
                     std::vector<int> &peripheralRings, int iring,
                     const RingSearchIndex &index);

bool conditionThreeDDC(const std::vector<std::vector<int>> &rings,
                       std::vector<int> &peripheralRings);

bool basalConditions(const std::vector<std::vector<int>> &nList,
                     const std::vector<int> &basal1,
                     const std::vector<int> &basal2);

bool basalNeighbours(const std::vector<std::vector<int>> &nList,
                     std::vector<int> &triplet, int atomOne, int atomTwo);

bool notNeighboursOfRing(const std::vector<std::vector<int>> &nList,
                         std::vector<int> &triplet,
                         const std::vector<int> &ring);

[[nodiscard]] int findPrismatic(const std::vector<std::vector<int>> &rings, std::vector<int> &listHC,
                  std::vector<strucType> &ringType, int iring, int jring,
                  std::vector<int> &prismaticRings);

[[nodiscard]] int findPrismatic(const std::vector<std::vector<int>> &rings,
                                std::vector<int> &listHC,
                                std::vector<strucType> &ringType, int iring,
                                int jring, std::vector<int> &prismaticRings,
                                const RingSearchIndex &index);

[[nodiscard]] int getAtomTypesTopoBulk(const std::vector<std::vector<int>> &rings,
                         const std::vector<ring::strucType> &ringType,
                         std::vector<cage::iceType> &atomTypes);

[[nodiscard]] int getStrucNumbers(const std::vector<ring::strucType> &ringType,
                    const std::vector<cage::Cage> &cageList, int &numHC, int &numDDC,
                    int &mixedRings, int &prismaticRings, int &basalRings);
 
} // namespace ring

 
namespace prism3 {

[[nodiscard]] int findBulkPrisms(const std::vector<std::vector<int>> &rings,
                   std::vector<ring::strucType> &ringType,
                   const std::vector<std::vector<int>> &nList,
                   molSys::PointCloud<molSys::Point<double>, double> &yCloud,
                   std::vector<double> &rmsdPerAtom, double heightCutoff = 8);

bool basalPrismConditions(const std::vector<std::vector<int>> &nList,
                          std::vector<int> &basal1, std::vector<int> &basal2);

bool relaxedPrismConditions(const std::vector<std::vector<int>> &nList,
                            std::vector<int> &basal1, std::vector<int> &basal2);

bool basalRingsSeparation(
    molSys::PointCloud<molSys::Point<double>, double> &yCloud,
    const std::vector<int> &basal1, const std::vector<int> &basal2, double heightCutoff = 8);
} // namespace prism3

 
#endif // SEAMS_TOPO_BULK_H_