franzblau.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_FRANZBLAU_H_
#define SEAMS_FRANZBLAU_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 <seams_input.hpp>
#include <seams_output.hpp>



 
namespace primitive {

struct Vertex {
  int atomIndex;                   
  std::vector<int> neighListIndex; 
  bool inGraph =
      true; 
};

struct Graph {
  std::vector<Vertex> pts; 
  std::vector<std::vector<int>>
      rings; 
};

std::vector<std::vector<int>> ringNetwork(const std::vector<std::vector<int>> &nList,
                                          int maxDepth);

Graph populateGraphFromNListID(
    molSys::PointCloud<molSys::Point<double>, double> &yCloud,
    const std::vector<std::vector<int>> &neighHbondList);

Graph populateGraphFromIndices(const std::vector<std::vector<int>> &nList);

void restoreEdgesFromIndices(Graph &fullGraph,
                             const std::vector<std::vector<int>> &nList);

Graph countAllRingsFromIndex(const std::vector<std::vector<int>> &neighHbondList,
                             int maxDepth);

void removeNonSPrings(Graph &fullGraph);

[[nodiscard]] int findRings(Graph &fullGraph, int v, std::vector<int> &visited, int maxDepth,
              int depth, int root = -1);

[[nodiscard]] int shortestPath(Graph &fullGraph, int v, int goal, std::vector<int> &path,
                 std::vector<int> &visited, int maxDepth, int depth = 1);

Graph clearGraph(Graph &currentGraph);
 

class RingUpdater {
public:
  explicit RingUpdater(int maxDepth);
  ~RingUpdater();
  RingUpdater(RingUpdater &&) noexcept;
  RingUpdater &operator=(RingUpdater &&) noexcept;
  RingUpdater(const RingUpdater &) = delete;
  RingUpdater &operator=(const RingUpdater &) = delete;

  const std::vector<std::vector<int>> &
  update(const std::vector<std::vector<int>> &nList);

  [[nodiscard]] int lastRecomputedSources() const;

  [[nodiscard]] int lastBallsRefreshed() const;
 
private:
  struct Impl;
  std::unique_ptr<Impl> impl_;
};
 
} // namespace primitive
 
#endif // SEAMS_FRANZBLAU_H_