topology_util.h

// -*-c++-*-
#ifndef STORMM_TOPOLOGY_BOUNDS_CHECKS_H
#define STORMM_TOPOLOGY_BOUNDS_CHECKS_H
 
#include <string>
#include <vector>
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "Constants/scaling.h"
#include "DataTypes/common_types.h"
#include "DataTypes/stormm_vector_types.h"
#include "Math/sorting_enumerators.h"
#include "Math/vector_ops.h"
#include "Potential/energy_enumerators.h"
#include "Reporting/error_format.h"
#include "atomgraph.h"
#include "atomgraph_abstracts.h"
#include "topology_limits.h"
 
namespace stormm {
namespace topology {
 
using card::Hybrid;
using card::HybridTargetLevel;
using data_types::getStormmScalarTypeName;
using data_types::getStormmHpcVectorTypeName;
using data_types::isScalarType;
using data_types::isHpcVectorType;
using energy::NonbondedTheme;
using energy::VdwCombiningRule;
using stmath::UniqueValueHandling;
using stmath::reduceUniqueValues;

template <typename T> std::vector<T> extractBoundedListEntries(const std::vector<T> &va,
                                                               const std::vector<int> &va_bounds,
                                                               int index);
 
template <typename T>
void extractBoundedListEntries(std::vector<T> *result, const std::vector<T> &va,
                               const std::vector<int> &va_bounds, int index);
 
template <typename T> std::vector<T>
extractBoundedListEntries(const std::vector<T> &va, const std::vector<int> &va_bounds,
                          const std::vector<int> &indices,
                          UniqueValueHandling filter = UniqueValueHandling::UNIQUE_VALUES_ONLY);
 
template <typename T> void
extractBoundedListEntries(std::vector<T> *result, const std::vector<T> &va,
                          const std::vector<int> &va_bounds, const std::vector<int> &indices,
                          UniqueValueHandling filter = UniqueValueHandling::UNIQUE_VALUES_ONLY);

template <typename T>
std::vector<T> getRealParameters(const Hybrid<double> &item, const Hybrid<float> &sp_item,
                                 HybridTargetLevel tier, int low_index, int high_index,
                                 const char* caller = nullptr, const char* method = nullptr);
  
std::string writeAtomList(const std::vector<int> &atom_list, const ChemicalDetailsKit &cdk);

bool isBonded(const NonbondedKit<double> &nbk, int atom_i, int atom_j);
bool isBonded(const AtomGraph &ag, int atom_i, int atom_j);
bool isBonded(const AtomGraph *ag, int atom_i, int atom_j);

int matchTopology(const AtomGraph *query_ag, const std::vector<AtomGraph*> &repo);
int matchTopology(const AtomGraph &query_ag, const std::vector<AtomGraph*> &repo);
int matchTopology(const AtomGraph *query_ag, const std::vector<AtomGraph> &repo);
int matchTopology(const AtomGraph &query_ag, const std::vector<AtomGraph> &repo);

template <typename T>
bool hasVdwProperties(const NonbondedKit<T> &nbk, int atom_index,
                      VdwCombiningRule lj_rule = VdwCombiningRule::NBFIX);
 
bool hasVdwProperties(const AtomGraph *ag, int atom_index,
                      VdwCombiningRule lj_rule = VdwCombiningRule::NBFIX);
 
bool hasVdwProperties(const AtomGraph &ag, int atom_index,
                      VdwCombiningRule lj_rule = VdwCombiningRule::NBFIX);

template <typename T>
bool hasRelevantProperties(const NonbondedKit<T> &nbk, int atom_index, NonbondedTheme theme,
                           VdwCombiningRule lj_rule = VdwCombiningRule::NBFIX);
 
} // namespace topology
} // namespace stormm
 
#include "topology_util.tpp"
 
#endif