NEBInitialPaths.hpp

Go to the documentation of this file.

#pragma once
#include "Matter.h"
#include <filesystem>
#include <format>
#include <memory>
#include <span>
#include <stdexcept>
#include <string_view>
 
namespace eonc {
 
namespace helpers::neb_paths {
namespace fs = std::filesystem;

inline void requireSameAtomCount(const Matter &a, const Matter &b,
                                 std::string_view what) {
  if (a.numberOfAtoms() == b.numberOfAtoms()) {
    return;
  }
  throw std::invalid_argument(std::format(
      "NEB: {} do not have the same number of atoms ({} vs {})", what,
      a.numberOfAtoms(), b.numberOfAtoms()));
}
 
std::vector<Matter> linearPath(const Matter &initImg, const Matter &finalImg,
                               const size_t nimgs);
 
std::vector<Matter> filePathInit(const std::vector<fs::path> &fsrcs,
                                 const Matter &refImg, const size_t nimgs);

AtomMatrix cubicInterpolate(const AtomMatrix &P0, const AtomMatrix &T0,
                            const AtomMatrix &P1, const AtomMatrix &T1,
                            double f);
 
std::vector<Matter> resamplePath(const std::vector<Matter> &densePath,
                                 size_t targetCount);

void resamplePathInPlace(std::span<std::shared_ptr<Matter>> path);

std::vector<std::filesystem::path>
readFilePaths(const std::string &listFilePath);
 
MatrixXd getDistanceMatrix(const Matter &m);
 
std::vector<Matter> idppPath(const Matter &initImg, const Matter &finalImg,
                             size_t nimgs, const Parameters &params,
                             bool use_zbl = false);
 
std::vector<Matter> idppCollectivePath(const Matter &initImg,
                                       const Matter &finalImg, size_t nimgs,
                                       const Parameters &params,
                                       bool use_zbl = false);
 
std::vector<Matter> sidppPath(const Matter &initImg, const Matter &finalImg,
                              size_t target_nimgs, const Parameters &params,
                              bool use_zbl = false);

void ensureDistinctAdjacentImages(const std::vector<Matter> &path,
                                  double min_sep);
 
// Helper to insert an image linearly between two others
Matter interpolateImage(const Matter &A, const Matter &B, double fraction);
// Helper to construct ZBL potentials
std::shared_ptr<Potential> createZBLPotential();
 
} // namespace helpers::neb_paths
 
} // namespace eonc