eonc::neb::zoom Namespace Reference

Classes
struct	Window
	Inclusive image indices on the current band. More...

Functions
Window	selectWindow (const std::vector< double > &energy, std::size_t climbingImage, const neb_options_t::zoom_options_t &cfg)
	Auto: contiguous images around the climbing image whose energy is above E_ref + alpha * barrier.
bool	redistributePath (std::vector< std::shared_ptr< Matter > > &path, Window window, neb_options_t::zoom_options_t::Interpolation how)
	Place every band image on the window by equal arc length.

Function Documentation

redistributePath()

bool eonc::neb::zoom::redistributePath	(	std::vector< std::shared_ptr< Matter > > &	path,
		Window	window,
		neb_options_t::zoom_options_t::Interpolation	how )

Place every band image on the window by equal arc length.

Window endpoints become the new fixed band endpoints. Cubic uses resamplePath; linear uses segment interpolation. Returns false when the window cannot be resampled.

Definition at line 118 of file NEBZoom.cpp.

                                                                    {
  if (!window.valid || path.size() < 3 || window.hi <= window.lo ||
      window.hi >= path.size()) {
    return false;
  }
  for (const auto &image : path) {
    if (!image) {
      return false;
    }
  }
 
  std::vector<Matter> sub;
  sub.reserve(window.hi - window.lo + 1);
  for (std::size_t i = window.lo; i <= window.hi; ++i) {
    sub.push_back(*path[i]);
  }
 
  std::vector<Matter> placed;
  if (how == neb_options_t::zoom_options_t::Interpolation::Linear) {
    placed = linearResample(sub, path.size());
  } else if (sub.size() == path.size()) {
    std::vector<std::shared_ptr<Matter>> tmp;
    tmp.reserve(sub.size());
    for (const auto &image : sub) {
      tmp.push_back(std::make_shared<Matter>(image));
    }
    eonc::helpers::neb_paths::resamplePathInPlace(
        std::span<std::shared_ptr<Matter>>{tmp.data(), tmp.size()});
    placed.reserve(tmp.size());
    for (const auto &image : tmp) {
      placed.push_back(*image);
    }
  } else {
    placed = eonc::helpers::neb_paths::resamplePath(sub, path.size() - 2);
  }
  if (placed.size() != path.size()) {
    return false;
  }
  for (std::size_t i = 0; i < path.size(); ++i) {
    path[i]->setPositions(placed[i].getPositions());
  }
  return true;
}

selectWindow()

Window eonc::neb::zoom::selectWindow	(	const std::vector< double > &	energy,
		std::size_t	climbingImage,
		const neb_options_t::zoom_options_t &	cfg )

Auto: contiguous images around the climbing image whose energy is above E_ref + alpha * barrier.

Manual: climbing image +/- offset. A one-image auto window falls back to the manual offset.

Definition at line 74 of file NEBZoom.cpp.

                                                            {
  Window window;
  const std::size_t n = energy.size();
  if (n < 3 || climbingImage == 0 || climbingImage + 1 >= n) {
    return window;
  }
 
  std::size_t lo = 0;
  std::size_t hi = 0;
  if (cfg.mode == neb_options_t::zoom_options_t::Mode::Manual) {
    std::tie(lo, hi) = manualWindow(n, climbingImage, cfg.offset);
  } else {
    const double eRef = std::min(energy.front(), energy.back());
    const double eMax = *std::max_element(energy.begin(), energy.end());
    const double barrier = eMax - eRef;
    const bool usable = barrier > 0.0 && cfg.alpha > 0.0 && cfg.alpha < 1.0;
    if (!usable) {
      std::tie(lo, hi) = manualWindow(n, climbingImage, cfg.offset);
    } else {
      const double threshold = eRef + cfg.alpha * barrier;
      lo = climbingImage;
      hi = climbingImage;
      while (lo > 0 && energy[lo - 1] > threshold) {
        --lo;
      }
      while (hi + 1 < n && energy[hi + 1] > threshold) {
        ++hi;
      }
      if (hi <= lo) {
        std::tie(lo, hi) = manualWindow(n, climbingImage, cfg.offset);
      }
    }
  }
  if (hi <= lo || hi >= n) {
    return window;
  }
  window.lo = lo;
  window.hi = hi;
  window.valid = true;
  return window;
}