eonc::NudgedElasticBandJob Class Reference

#include <NudgedElasticBandJob.h>

Inheritance diagram for eonc::NudgedElasticBandJob:

Public Member Functions
	NudgedElasticBandJob (std::unique_ptr< Parameters > parameters, Runtime &rt)
	~NudgedElasticBandJob (void)=default
std::vector< std::string >	run (void)
	Virtual run; used solely for dynamic dispatch.
Public Member Functions inherited from eonc::Job
void	adoptRuntime (std::unique_ptr< Runtime > rt)
	Take ownership of a Runtime previously passed as Runtime&.
	Job (std::unique_ptr< Parameters > parameters, Runtime &rt)
	Borrow: caller keeps Runtime alive (CLI stack / Python Session).
	Job (std::unique_ptr< Parameters > parameters, std::unique_ptr< Runtime > rt)
	Own a Runtime (one-shot makeJob / rvalue).
	Job (std::unique_ptr< Parameters > parameters)
	Own a default-constructed Runtime.
	Job (std::shared_ptr< Potential > potPassed, const Parameters &parameters)
virtual	~Job ()=default
JobType	getType ()
PotRegistry &	pots () noexcept
void	releasePotential ()
	Drop the Potential so on_destroyed is recorded before Runtime dies.

Private Member Functions
void	printEndState (NudgedElasticBand::NEBStatus status)
void	saveData (NudgedElasticBand::NEBStatus status, NudgedElasticBand *neb)

Private Attributes
std::vector< std::string >	returnFiles
size_t	fCallsNEB
eonc::log::Scoped	m_log

Additional Inherited Members
Protected Attributes inherited from eonc::Job
JobType	jtype
Parameters	params
std::unique_ptr< Runtime >	owned_runtime_
	Non-null when this Job owns the composition root (one-shot makeJob).
Runtime *	runtime_
	Always valid: either owned_runtime_.get() or a caller-owned Runtime.
std::shared_ptr< Potential >	pot

Detailed Description

Definition at line 22 of file NudgedElasticBandJob.h.

Constructor & Destructor Documentation

NudgedElasticBandJob()

eonc::NudgedElasticBandJob::NudgedElasticBandJob ( std::unique_ptr< Parameters > parameters, Runtime & rt )

inline

Definition at line 25 of file NudgedElasticBandJob.h.

      : Job(std::move(parameters), rt),
        fCallsNEB{0} {}

~NudgedElasticBandJob()

eonc::NudgedElasticBandJob::~NudgedElasticBandJob ( void )

default

Member Function Documentation

printEndState()

void eonc::NudgedElasticBandJob::printEndState ( NudgedElasticBand::NEBStatus status )

private

Definition at line 314 of file NudgedElasticBandJob.cpp.

                                                                          {
  QUILL_LOG_DEBUG(m_log, "Final state: ");
  if (status == NudgedElasticBand::NEBStatus::GOOD)
    QUILL_LOG_DEBUG(m_log, "Nudged elastic band, successful.");
  else if (status == NudgedElasticBand::NEBStatus::BAD_MAX_ITERATIONS)
    QUILL_LOG_DEBUG(m_log, "Nudged elastic band, too many iterations.");
  else
    QUILL_LOG_WARNING(m_log, "Unknown status: {}!", static_cast<int>(status));
  return;
}

run()

std::vector< std::string > eonc::NudgedElasticBandJob::run ( void )

virtual

Virtual run; used solely for dynamic dispatch.

Implements eonc::Job.

Definition at line 29 of file NudgedElasticBandJob.cpp.

                                               {
  NudgedElasticBand::NEBStatus status;
  size_t f1;
 
  std::string reactantFilename = eonc::helpers::getRelevantFile("reactant.con");
  std::string productFilename = eonc::helpers::getRelevantFile("product.con");
 
  // TS interpolation: only when initializer is FILE (explicit path loading).
  // Previously, any ts.con in CWD would silently override SIDPP/IDPP paths.
  bool tsInterpolate = false;
  std::shared_ptr<Matter> transitionState = nullptr;
  if (params.neb_options().initialization.method == NEBInit::FILE &&
      std::filesystem::exists("ts.con")) {
    std::string transitionStateFilename =
        eonc::helpers::getRelevantFile("ts.con");
    transitionState = std::make_shared<Matter>(pot, params);
    tsInterpolate = true;
    if (!eonc::io::io_ok(
            transitionState->con2matter(transitionStateFilename))) {
      EONC_LOG_CRITICAL("Failed to load {}", transitionStateFilename);
      throw std::runtime_error("failed to load " + transitionStateFilename);
    }
  }
 
  auto initial = std::make_shared<Matter>(pot, params);
  auto final_state = std::make_shared<Matter>(pot, params);
 
  // When initializer=file and initial_path_in is set, endpoints are the first
  // and last frames of that list — do not require reactant.con / product.con
  // (issue #278; buggy endpoint files were still loaded and could crash).
  const bool usePathEndpoints =
      params.neb_options().initialization.method == NEBInit::FILE &&
      !params.neb_options().initialization.input_path.empty();
 
  if (usePathEndpoints) {
    const auto file_paths = eonc::helpers::neb_paths::readFilePaths(
        params.neb_options().initialization.input_path);
    if (file_paths.size() < 2) {
      throw std::runtime_error(
          "NEB initial_path_in must list at least two frames "
          "(reactant and product endpoints)");
    }
    if (!eonc::io::io_ok(initial->con2matter(file_paths.front().string()))) {
      EONC_LOG_CRITICAL("Failed to load NEB path reactant frame {}",
                        file_paths.front().string());
      throw std::runtime_error("failed to load NEB path reactant frame");
    }
    if (!eonc::io::io_ok(final_state->con2matter(file_paths.back().string()))) {
      EONC_LOG_CRITICAL("Failed to load NEB path product frame {}",
                        file_paths.back().string());
      throw std::runtime_error("failed to load NEB path product frame");
    }
    QUILL_LOG_INFO(m_log,
                   "NEB endpoints from initial path list (skipped {} / {})",
                   reactantFilename, productFilename);
  } else {
    if (!eonc::io::io_ok(initial->con2matter(reactantFilename))) {
      EONC_LOG_CRITICAL("Failed to load {}", reactantFilename);
      throw std::runtime_error("failed to load reactant.con");
    }
    if (!eonc::io::io_ok(final_state->con2matter(productFilename))) {
      EONC_LOG_CRITICAL("Failed to load {}", productFilename);
      throw std::runtime_error("failed to load product.con");
    }
  }
 
  eonc::helpers::neb_paths::requireSameAtomCount(*initial, *final_state,
                                                 "reactant and product");
  if (tsInterpolate) {
    eonc::helpers::neb_paths::requireSameAtomCount(*initial, *transitionState,
                                                   "reactant and ts.con");
  }
 
  // Endpoint minimization logic:
  // - If params.neb_options().endpoints.minimize is false: never minimize
  // endpoints.
  // - If params.neb_options().endpoints.minimize is true and
  // params.neb_options().initialization.input_path is empty: minimize
  // endpoints.
  // - If params.nebMinimEP is true and params.nebIpath is NOT empty:
  //     -> minimize endpoints only if params.nebMinimEPIpath is true.
  // Log what decision was made so users can see behavior.
  bool shouldMinimizeEndpoints = false;
  if (!params.neb_options().endpoints.minimize) {
    QUILL_LOG_DEBUG(m_log,
                    "minimize_endpoints == false: not minimizing endpoints.");
    shouldMinimizeEndpoints = false;
  } else {
    if (params.neb_options().initialization.input_path.empty()) {
      QUILL_LOG_DEBUG(m_log, "minimize_endpoints == true and nebIpath "
                             "empty: minimizing endpoints.");
      shouldMinimizeEndpoints = true;
    } else {
      // nebIpath provided: only minimize if neb_options.endpoints.use_path_file
      // explicitly allowed.
      if (params.neb_options().endpoints.use_path_file) {
        QUILL_LOG_DEBUG(
            m_log,
            "minimize_endpoints == true and nebIpath provided, but "
            "minimize_endpoints_for_ipath == true: minimizing endpoints.");
        shouldMinimizeEndpoints = true;
      } else {
        QUILL_LOG_DEBUG(
            m_log,
            "minimize_endpoints == true but nebIpath provided and "
            "minimize_endpoints_for_ipath == false: not minimizing endpoints.");
        shouldMinimizeEndpoints = false;
      }
    }
  }
 
  if (shouldMinimizeEndpoints) {
    QUILL_LOG_DEBUG(m_log, "Minimizing reactant");
    initial->relax(false, params.debug_options().write_movies,
                   params.main_options().checkpoint, "react_neb", "react_neb");
    QUILL_LOG_DEBUG(m_log, "Minimized reactant");
    QUILL_LOG_DEBUG(m_log, "Minimizing product");
    final_state->relax(false, params.debug_options().write_movies,
                       params.main_options().checkpoint, "prod_neb",
                       "prod_neb");
  }
 
  auto neb =
      std::make_unique<NudgedElasticBand>(initial, final_state, params, pot);
 
  if (tsInterpolate) {
    AtomMatrix reactantToTS = transitionState->pbc(
        transitionState->getPositions() - initial->getPositions());
    AtomMatrix TSToProduct = transitionState->pbc(
        final_state->getPositions() - transitionState->getPositions());
    for (int image = 1; image <= neb->numImages; image++) {
      int mid = neb->numImages / 2 + 1;
      if (image < mid) {
        double frac = static_cast<double>(image) / static_cast<double>(mid);
        neb->path[image]->setPositions(initial->getPositions() +
                                       frac * reactantToTS);
      } else if (image > mid) {
        double frac = static_cast<double>(image - mid) /
                      static_cast<double>(neb->numImages - mid + 1);
        neb->path[image]->setPositions(transitionState->getPositions() +
                                       frac * TSToProduct);
      } else if (image == mid) {
        neb->path[image]->setPositions(transitionState->getPositions());
      }
    }
  }
 
  f1 = PotRegistry::get().total_force_calls();
  status = neb->compute();
  fCallsNEB += PotRegistry::get().total_force_calls() - f1;
 
  if (status == NudgedElasticBand::NEBStatus::GOOD) {
    neb->printImageData();
    neb->findExtrema();
  }
 
  printEndState(status);
  saveData(status, neb.get());
 
  return returnFiles;
}

saveData()

void eonc::NudgedElasticBandJob::saveData ( NudgedElasticBand::NEBStatus status, NudgedElasticBand * neb )

private

Definition at line 191 of file NudgedElasticBandJob.cpp.

                                                            {
  std::string resultsFilename("results.dat");
  returnFiles.push_back(resultsFilename);
 
  {
    auto env = JobResultEnvelope::fromMinimization(
        status == NudgedElasticBand::NEBStatus::GOOD
            ? RunStatus::GOOD
            : RunStatus::FAIL_MAX_ITERATIONS,
        params.potential_options().potential,
        PotRegistry::get().total_force_calls(), true, neb->reactantEnergy);
    env.job_type = "neb";
    env.extras.emplace_back("force_calls_neb", static_cast<double>(fCallsNEB));
    env.extras.emplace_back("energy_reference", neb->reactantEnergy);
    env.extras.emplace_back("number_of_images",
                            static_cast<double>(neb->numImages));
    env.writeResultsDat(resultsFilename);
    std::ofstream out(resultsFilename, std::ios::binary | std::ios::app);
    if (!out) {
      QUILL_LOG_ERROR(m_log, "Failed to reopen {} for image keys",
                      resultsFilename);
      return;
    }
 
    for (long i = 0; i <= neb->numImages + 1; i++) {
      out << std::format(
          "{:f} image{}_energy\n",
          neb->path[i]->getPotentialEnergy() - neb->reactantEnergy, i);
      out << std::format("{:f} image{}_force\n",
                         neb->path[i]->getForces().norm(), i);
      double proj_norm = (i >= 1 && i <= neb->numImages)
                             ? neb->projectedForce[i]->norm()
                             : 0.0;
      out << std::format("{:f} image{}_projected_force\n", proj_norm, i);
    }
 
    long safeNumExtrema = std::min(
        neb->numExtrema, static_cast<long>(neb->extremumPosition.size()));
    out << std::format("{} number_of_extrema\n", safeNumExtrema);
    for (long i = 0; i < safeNumExtrema; i++) {
      out << std::format("{:f} extremum{}_position\n", neb->extremumPosition[i],
                         i);
      out << std::format("{:f} extremum{}_energy\n", neb->extremumEnergy[i], i);
    }
  }
 
  // Save the Full NEB Path
  std::string nebFilename("neb.con");
  returnFiles.push_back(nebFilename);
  if (!eonc::io::io_ok(eonc::neb::writePathCon(
          neb->path, neb->tangent, neb->eigenmode_solvers, neb->numImages,
          params.debug_options().estimate_neb_eigenvalues, nebFilename,
          std::nullopt, neb->reactantEnergy))) {
    QUILL_LOG_ERROR(m_log, "Failed to write {}", nebFilename);
  }
 
  // Save Discrete Saddle Point (Highest Energy Image)
  std::string spFilename("sp.con");
  if (!eonc::io::io_ok(
          neb->path[neb->maxEnergyImage]->matter2con(spFilename))) {
    QUILL_LOG_ERROR(m_log, "Failed to write {}", spFilename);
  }
  returnFiles.push_back(spFilename);
 
  // Setup Dimer Configurations for Each Spline Peak
  if (params.neb_options().mmf_peaks.enabled && neb->numExtrema > 0) {
    int peakCount = 0;
    for (long i = 0; i < neb->numExtrema; i++) {
      // Filter 1: Only look at maxima (negative curvature)
      // Filter 2: Energy threshold (e.g., peak must be > 0.05 eV above
      // reactant)
      double relativeEnergy = neb->extremumEnergy[i] - neb->reactantEnergy;
 
      if (neb->extremumCurvature[i] < 0 &&
          relativeEnergy > params.neb_options().mmf_peaks.tolerance) {
        double posFraction = neb->extremumPosition[i];
        int leftIdx = static_cast<int>(std::floor(posFraction));
        double f = posFraction - leftIdx;
 
        if (leftIdx < 0 || leftIdx >= neb->numImages + 1)
          continue;
 
        // 1. Write Interpolated Position (.con)
        Matter peakPos = eonc::helpers::neb_paths::interpolateImage(
            *neb->path[leftIdx], *neb->path[leftIdx + 1], f);
        std::string peakPosFile = std::format("peak{:02d}_pos.con", peakCount);
        if (!eonc::io::io_ok(peakPos.matter2con(peakPosFile))) {
          QUILL_LOG_ERROR(m_log, "Failed to write {}", peakPosFile);
        }
        returnFiles.push_back(peakPosFile);
 
        // 2. Write Interpolated Tangent as standard mode.dat
        AtomMatrix peakMode = eonc::neb::interpolatedPeakMode(
            neb->path, neb->tangent, neb->numImages, posFraction);
 
        std::string peakModeFile =
            std::format("peak{:02d}_mode.dat", peakCount);
        {
          std::ofstream modeOut(peakModeFile);
          if (modeOut) {
            for (long row = 0; row < peakMode.rows(); ++row) {
              modeOut << std::format("{:.17g} {:.17g} {:.17g}\n",
                                     peakMode(row, 0), peakMode(row, 1),
                                     peakMode(row, 2));
            }
            returnFiles.push_back(peakModeFile);
          }
        }
 
        QUILL_LOG_INFO(
            m_log,
            "Generated MMF peak {:02d} at position {:.3f} (Energy: {:.3f} eV)",
            peakCount, posFraction, relativeEnergy);
        peakCount++;
      }
    }
  }
 
  returnFiles.push_back("neb.dat");
  neb->printImageData(true, std::numeric_limits<size_t>::max());
}

Member Data Documentation

fCallsNEB

size_t eonc::NudgedElasticBandJob::fCallsNEB

private

Definition at line 38 of file NudgedElasticBandJob.h.

m_log

eonc::log::Scoped eonc::NudgedElasticBandJob::m_log

private

Definition at line 39 of file NudgedElasticBandJob.h.

returnFiles

std::vector<std::string> eonc::NudgedElasticBandJob::returnFiles

private

Definition at line 37 of file NudgedElasticBandJob.h.

---

The documentation for this class was generated from the following files:

• /home/runner/work/eOn/eOn/include/eon/NudgedElasticBandJob.h
• /home/runner/work/eOn/eOn/client/NudgedElasticBandJob.cpp