eonc::ProcessSearchJob Class Reference

Declaration of the Process Search job. More...

#include <ProcessSearchJob.h>

Inheritance diagram for eonc::ProcessSearchJob:

Public Member Functions
	ProcessSearchJob (std::unique_ptr< Parameters > parameters, Runtime &rt)
	Process Search job Constructor.
	ProcessSearchJob (std::shared_ptr< Potential > potPassed, const Parameters &parameters)
	~ProcessSearchJob ()=default
	Process Search job De-constructor.
std::vector< std::string >	run (void) override
	Kicks off the Process Search.
std::shared_ptr< Matter >	runFromMatter (std::shared_ptr< Matter > seed)
	In-process entry: seed reactant Matter, no pos.con.
std::shared_ptr< Matter >	getInitial () const
std::shared_ptr< Matter >	getSaddle () const
std::shared_ptr< Matter >	getMin1 () const
std::shared_ptr< Matter >	getMin2 () const
double	prefactorForward () const
double	prefactorReverse () const
double	barrierForward () const
double	barrierReverse () const
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
std::shared_ptr< Matter >	runPrepared ()
int	doProcessSearch (void)
	Runs the correct saddle search; also checks if the run was successful.
void	printEndState (int status)
	Logs the run status and makes sure the run was successful.
void	saveData (int status)
	Writes the results from the run to file.

Private Attributes
eonc::log::Scoped	log
std::vector< std::string >	returnFiles
	Container for the results of the run.
std::unique_ptr< SaddleSearchMethod >	saddleSearch
	Pulled from parameters.
std::shared_ptr< Matter >	initial
	Initial configuration.
std::shared_ptr< Matter >	saddle
	Configuration used during the saddle point search.
std::shared_ptr< Matter >	displacement
	Configuration used during the saddle point search.
std::shared_ptr< Matter >	min1
	First minimum from the saddle.
std::shared_ptr< Matter >	min2
	Second minimum from the saddle.
double	barriersValues [2] {0.0, 0.0}
double	prefactorsValues [2] {0.0, 0.0}
size_t	fCallsSaddle {0}
	Force calls to find the saddle.
size_t	fCallsMin {0}
	Force calls to minimize.
size_t	fCallsPrefactors {0}
	Force calls to find the prefactors.

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

Declaration of the Process Search job.

Definition at line 45 of file ProcessSearchJob.h.

Constructor & Destructor Documentation

ProcessSearchJob() [1/2]

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

inline

Process Search job Constructor.

Parameters

*params

defined by the config.init file

Definition at line 51 of file ProcessSearchJob.h.

      : Job(std::move(parameters), rt),
        fCallsSaddle{0},
        fCallsMin{0},
        fCallsPrefactors{0} {}

ProcessSearchJob() [2/2]

eonc::ProcessSearchJob::ProcessSearchJob ( std::shared_ptr< Potential > potPassed, const Parameters & parameters )

inline

Definition at line 56 of file ProcessSearchJob.h.

      : Job(std::move(potPassed), parameters),
        fCallsSaddle{0},
        fCallsMin{0},
        fCallsPrefactors{0} {}

~ProcessSearchJob()

eonc::ProcessSearchJob::~ProcessSearchJob ( )

default

Process Search job De-constructor.

Member Function Documentation

barrierForward()

double eonc::ProcessSearchJob::barrierForward ( ) const

inline

Definition at line 75 of file ProcessSearchJob.h.

{ return barriersValues[0]; }

barrierReverse()

double eonc::ProcessSearchJob::barrierReverse ( ) const

inline

Definition at line 76 of file ProcessSearchJob.h.

{ return barriersValues[1]; }

doProcessSearch()

int eonc::ProcessSearchJob::doProcessSearch ( void )

private

Runs the correct saddle search; also checks if the run was successful.

Definition at line 240 of file ProcessSearchJob.cpp.

                                      {
  Matter matterTemp(pot, params);
  long status;
  size_t fctmp{0};
 
  fctmp = pot->forceCallCounter;
  status = saddleSearch->run();
  if (params.saddle_search_options().method == "min_mode" &&
      params.saddle_search_options().minmode_method ==
          LowestEigenmode::MINMODE_GPRDIMER) {
    fCallsSaddle += saddleSearch->getForceCalls();
  } else if (params.saddle_search_options().method == "artn") {
    fCallsSaddle += saddleSearch->getForceCalls();
  } else {
    fCallsSaddle += pot->forceCallCounter - fctmp;
  }
  EONC_LOG_DEBUG("Got {} calls in the saddle search, with previous {}",
                 fCallsSaddle, fctmp);
 
  if (status != MinModeSaddleSearch::STATUS_GOOD) {
    return status;
  }
 
  AtomMatrix posSaddle = saddle->getPositions();
  AtomMatrix displacedPos;
 
  // Matter's copy assignment copies the potential; keep each endpoint's
  // own instance so the two minimizations can run at the same time.
  const auto min1Pot = min1->getPotential();
  const auto min2Pot = min2->getPotential();
  *min1 = *saddle;
  min1->setPotential(min1Pot);
 
  displacedPos =
      posSaddle - saddleSearch->getEigenvector() *
                      params.process_search_options().minimization_offset;
  min1->setPositions(displacedPos);
 
  *min2 = *saddle;
  min2->setPotential(min2Pot);
  displacedPos =
      posSaddle + saddleSearch->getEigenvector() *
                      params.process_search_options().minimization_offset;
  min2->setPositions(displacedPos);
 
  // Minimize both endpoints concurrently when the shared potential instance is
  // safe to call from multiple threads, or when each endpoint owns a separate
  // potential instance.
  QUILL_LOG_DEBUG(log, "Starting Minimization 1 & 2");
  bool converged1{false}, converged2{false};
  long fc1_before = min1->getPotentialCalls();
  long fc2_before = min2->getPotentialCalls();
 
  // Two threads may share an instance only when it is thread safe; a
  // per-image potential needs the endpoints to hold distinct instances.
  bool canParallel = eonc::potAllowsSharedInstance(*pot) ||
                     (pot->needsPerImageInstance() &&
                      min1->getPotential().get() != min2->getPotential().get());
  if (params.main_options().parallel && canParallel) {
    // An exception may not leave a thread function (std::terminate), and a
    // joinable std::thread may not be destroyed: t1 hands its error back and
    // the caller joins before rethrowing either side's.
    std::exception_ptr t1Error;
    std::thread t1([&] {
      try {
        converged1 = min1->relax(false, params.debug_options().write_movies,
                                 false, "min1");
      } catch (...) {
        t1Error = std::current_exception();
      }
    });
    try {
      converged2 = min2->relax(false, params.debug_options().write_movies,
                               false, "min2");
    } catch (...) {
      t1.join();
      throw;
    }
    t1.join();
    if (t1Error)
      std::rethrow_exception(t1Error);
  } else {
    converged1 =
        min1->relax(false, params.debug_options().write_movies, false, "min1");
    converged2 =
        min2->relax(false, params.debug_options().write_movies, false, "min2");
  }
 
  if (min1->getPotential().get() == min2->getPotential().get()) {
    fCallsMin += min1->getPotentialCalls() - fc1_before;
  } else {
    fCallsMin += (min1->getPotentialCalls() - fc1_before) +
                 (min2->getPotentialCalls() - fc2_before);
  }
  QUILL_LOG_DEBUG(log, "Min1: {} fcalls, Min2: {} fcalls",
                  min1->getPotentialCalls() - fc1_before,
                  min2->getPotentialCalls() - fc2_before);
 
  if (!converged1 || !converged2) {
    return MinModeSaddleSearch::STATUS_BAD_MINIMA;
  }
 
  auto sameAs = [](const Matter &a, const Matter &b) {
    Matter probe(a);
    return probe.compare(b);
  };
 
  if (!sameAs(*initial, *min1) && sameAs(*initial, *min2)) {
    matterTemp = *min1;
    *min1 = *min2;
    *min2 = matterTemp;
  }
 
  if (!sameAs(*initial, *min1)) {
    // Report how far off the endpoint landed. Whether the minimisation
    // stopped just outside the state-identity tolerance or relaxed into a
    // different state entirely calls for opposite fixes, and the status
    // alone does not distinguish them.
    const double tol =
        params.structure_comparison_options().distance_difference;
    auto countMoved = [&](const Matter &m) {
      long moved = 0;
      for (long i = 0; i < initial->numberOfAtoms(); ++i) {
        if (initial
                ->pbc(initial->getPositions().row(i) - m.getPositions().row(i))
                .norm() > tol) {
          ++moved;
        }
      }
      return moved;
    };
    QUILL_LOG_INFO(log,
                   "initial != min1: {} of {} atoms past the {} A tolerance "
                   "for min1 ({} for min2); largest separation {} A",
                   countMoved(*min1), initial->numberOfAtoms(), tol,
                   countMoved(*min2), initial->perAtomNorm(*min1));
    return MinModeSaddleSearch::STATUS_BAD_NOT_CONNECTED;
  }
 
  if (sameAs(*initial, *min2)) {
    QUILL_LOG_DEBUG(log, "both minima are the initial state");
    return MinModeSaddleSearch::STATUS_BAD_NOT_CONNECTED;
  }
 
  if (!params.process_search_options().minimize_first) {
    min1 = initial;
  }
 
  barriersValues[0] = saddle->getPotentialEnergy() - min1->getPotentialEnergy();
  barriersValues[1] = saddle->getPotentialEnergy() - min2->getPotentialEnergy();
 
  if ((params.saddle_search_options().max_energy < barriersValues[0]) ||
      (params.saddle_search_options().max_energy < barriersValues[1])) {
    return MinModeSaddleSearch::STATUS_BAD_HIGH_BARRIER;
  }
 
  if (barriersValues[0] < 0.0 || barriersValues[1] < 0.0) {
    return MinModeSaddleSearch::STATUS_NEGATIVE_BARRIER;
  }
 
  if (!params.prefactor_options().default_value) {
    fctmp = min1->getPotentialCalls();
    int prefStatus;
    double pref1, pref2;
    prefStatus = eonc::Prefactor::getPrefactors(
        params, min1.get(), saddle.get(), min2.get(), pref1, pref2);
    if (prefStatus == -1) {
      EONC_LOG_ERROR("Prefactor: bad calculation");
      return MinModeSaddleSearch::STATUS_FAILED_PREFACTOR;
    }
    fCallsPrefactors += min1->getPotentialCalls() - fctmp;
 
    if ((pref1 > params.prefactor_options().max_value) ||
        (pref1 < params.prefactor_options().min_value)) {
      EONC_LOG_ERROR("Bad reactant-to-saddle prefactor: {}", pref1);
      return MinModeSaddleSearch::STATUS_BAD_PREFACTOR;
    }
    if ((pref2 > params.prefactor_options().max_value) ||
        (pref2 < params.prefactor_options().min_value)) {
      EONC_LOG_ERROR("Bad product-to-saddle prefactor: {}", pref2);
      return MinModeSaddleSearch::STATUS_BAD_PREFACTOR;
    }
    prefactorsValues[0] = pref1;
    prefactorsValues[1] = pref2;
 
  } else {
    prefactorsValues[0] = params.prefactor_options().default_value;
    prefactorsValues[1] = params.prefactor_options().default_value;
  }
  return MinModeSaddleSearch::STATUS_GOOD;
}

getInitial()

std::shared_ptr< Matter > eonc::ProcessSearchJob::getInitial ( ) const

inline

Definition at line 69 of file ProcessSearchJob.h.

{ return initial; }

getMin1()

std::shared_ptr< Matter > eonc::ProcessSearchJob::getMin1 ( ) const

inline

Definition at line 71 of file ProcessSearchJob.h.

{ return min1; }

getMin2()

std::shared_ptr< Matter > eonc::ProcessSearchJob::getMin2 ( ) const

inline

Definition at line 72 of file ProcessSearchJob.h.

{ return min2; }

getSaddle()

std::shared_ptr< Matter > eonc::ProcessSearchJob::getSaddle ( ) const

inline

Definition at line 70 of file ProcessSearchJob.h.

{ return saddle; }

prefactorForward()

double eonc::ProcessSearchJob::prefactorForward ( ) const

inline

Definition at line 73 of file ProcessSearchJob.h.

{ return prefactorsValues[0]; }

prefactorReverse()

double eonc::ProcessSearchJob::prefactorReverse ( ) const

inline

Definition at line 74 of file ProcessSearchJob.h.

{ return prefactorsValues[1]; }

printEndState()

void eonc::ProcessSearchJob::printEndState ( int status )

private

Logs the run status and makes sure the run was successful.

Definition at line 502 of file ProcessSearchJob.cpp.

                                               {
  auto msg = saddleSearch->describeStatus(status);
  if (status == MinModeSaddleSearch::STATUS_GOOD) {
    QUILL_LOG_DEBUG(log, "[Saddle Search] {}", msg);
  } else {
    QUILL_LOG_ERROR(log, "[Saddle Search] {}", msg);
  }
}

run()

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

overridevirtual

Kicks off the Process Search.

Implements eonc::Job.

Definition at line 39 of file ProcessSearchJob.cpp.

                                           {
  std::string reactantFilename = eonc::helpers::getRelevantFile("pos.con");
  std::string displacementFilename("displacement.con");
  std::string modeFilename("direction.dat");
  size_t fctmp{0};
  initial = std::make_shared<Matter>(pot, params);
  if (params.saddle_search_options().method == "min_mode" ||
      params.saddle_search_options().method == "basin_hopping" ||
      params.saddle_search_options().method == "bgsd") {
    displacement = std::make_shared<Matter>(pot, params);
  } else if (params.saddle_search_options().method == "dynamics") {
    displacement = nullptr;
  }
  saddle = std::make_shared<Matter>(pot, params);
  // Give min2 its own potential for parallel endpoint minimization
  // A clone keeps this job's potential; makePotential rebuilds from the
  // configuration and is the fallback for backends that cannot clone.
  std::shared_ptr<Potential> min2Pot = pot;
  if (pot->needsPerImageInstance() && params.main_options().parallel) {
    auto cloned = pot->clonePotential();
    min2Pot = cloned ? cloned : eonc::helpers::makePotential(params);
  }
  min1 = std::make_shared<Matter>(pot, params);
  min2 = std::make_shared<Matter>(min2Pot, params);
 
  if (!eonc::io::io_ok(initial->con2matter(reactantFilename))) {
    EONC_LOG_CRITICAL("Failed to load {}", reactantFilename);
    throw std::runtime_error("failed to load " + reactantFilename);
  }
 
  if (params.process_search_options().minimize_first) {
    QUILL_LOG_DEBUG(log, "Minimizing initial structure\n");
    fctmp = initial->getPotentialCalls();
    initial->relax();
    fCallsMin += initial->getPotentialCalls() - fctmp;
    QUILL_LOG_DEBUG(log, "Initial minimization took {} fcalls",
                    initial->getPotentialCalls() - fctmp);
  }
 
  barriersValues[0] = barriersValues[1] = 0;
  prefactorsValues[0] = prefactorsValues[1] = 0;
 
  AtomMatrix mode = AtomMatrix::Zero(initial->numberOfAtoms(), 3);
  if (params.saddle_search_options().method == "min_mode" ||
      params.saddle_search_options().method == "basin_hopping" ||
      params.saddle_search_options().method == "bgsd") {
    if (params.saddle_search_options().displace_type ==
        eonc::EpiCenters::DISP_LOAD) {
      // Load displacement.con, or synthesize from pos.con + direction.dat
      // (#79).
      if (!eonc::helpers::loadOrSynthesizeDisplacement(
              *saddle, *initial, displacementFilename, modeFilename,
              params.saddle_search_options().displace_magnitude)) {
        EONC_LOG_CRITICAL("Failed to load {} (and no usable {})",
                          displacementFilename, modeFilename);
        throw std::runtime_error("failed to load " + displacementFilename);
      }
      *min1 = *min2 = *initial;
    } else if (eonc::helpers::applyClientDisplacement(*saddle, *initial, params,
                                                      &mode)) {
      *min1 = *min2 = *initial;
    } else {
      *saddle = *min1 = *min2 = *initial;
    }
    if (displacement) {
      *displacement = *saddle;
    }
  } else {
    // ARTn and dynamics start from the initial minimum
    *saddle = *min1 = *min2 = *initial;
  }
  min2->setPotential(min2Pot);
 
  const bool useARTnAsMinMode =
      params.saddle_search_options().method == "min_mode" &&
      params.saddle_search_options().minmode_method == "artn";
 
  if (params.saddle_search_options().method == "min_mode") {
    if (params.saddle_search_options().displace_type ==
            eonc::EpiCenters::DISP_LOAD &&
        std::filesystem::exists(modeFilename)) {
      mode = eonc::helpers::loadMode(modeFilename, initial->numberOfAtoms());
    }
#ifdef WITH_ARTN
    // ARTn as a min-mode drop-in: eOn displaces, seeds the mode, ARTn
    // takes over from the displaced structure.
    if (useARTnAsMinMode) {
      saddleSearch =
          std::make_unique<ARTnSaddleSearch>(saddle, pot, mode, params);
    } else
#endif
    {
      saddleSearch = std::make_unique<MinModeSaddleSearch>(
          saddle, mode, initial->getPotentialEnergy(), params, pot);
    }
#ifdef WITH_ARTN
  } else if (params.saddle_search_options().method == "artn") {
    // ARTn handles its own push from the minimum, eigenmode estimation,
    // and perpendicular relaxation internally.
    AtomMatrix artnMode = AtomMatrix::Zero(initial->numberOfAtoms(), 3);
    if (params.saddle_search_options().displace_type ==
            eonc::EpiCenters::DISP_LOAD &&
        std::filesystem::exists(modeFilename)) {
      artnMode =
          eonc::helpers::loadMode(modeFilename, initial->numberOfAtoms());
    }
    saddleSearch =
        std::make_unique<ARTnSaddleSearch>(saddle, pot, artnMode, params);
#endif
  } else if (params.saddle_search_options().method == "basin_hopping") {
    saddleSearch =
        std::make_unique<BasinHoppingSaddleSearch>(min1, saddle, pot, params);
  } else if (params.saddle_search_options().method == "dynamics") {
    saddleSearch = std::make_unique<DynamicsSaddleSearch>(saddle, params);
  } else if (params.saddle_search_options().method == "bgsd") {
    saddleSearch = std::make_unique<BiasedGradientSquaredDescent>(
        saddle, initial->getPotentialEnergy(), params);
  }
 
#ifndef WITH_ARTN
  // Post-dispatch guard for both ARTn entry points so users without a
  // WITH_ARTN build get a clean per-case error instead of a silent
  // fall-through. Two distinct messages so downstream tooling and the
  // integration tests can match on the specific entry point.
  if (params.saddle_search_options().method == "artn") {
    throw std::runtime_error(
        "saddle_search.method=artn requires a build with ARTn support "
        "(reconfigure with -Dwith_artn=true)");
  }
  if (useARTnAsMinMode) {
    throw std::runtime_error(
        "saddle_search.minmode_method=artn requires a build with ARTn "
        "support (reconfigure with -Dwith_artn=true)");
  }
#endif
 
  if (!saddleSearch) {
    throw std::runtime_error("unknown saddle_search.method");
  }
 
  (void)runPrepared();
  return returnFiles;
}

runFromMatter()

std::shared_ptr< Matter > eonc::ProcessSearchJob::runFromMatter

(

std::shared_ptr< Matter >

seed

)

In-process entry: seed reactant Matter, no pos.con.

Definition at line 184 of file ProcessSearchJob.cpp.

                                                          {
  if (!seed) {
    throw std::runtime_error("ProcessSearchJob::runFromMatter: null Matter");
  }
  initial = seed;
  initial->setPotential(pot);
  // A clone keeps this job's potential; makePotential rebuilds from the
  // configuration and is the fallback for backends that cannot clone.
  std::shared_ptr<Potential> min2Pot = pot;
  if (pot->needsPerImageInstance() && params.main_options().parallel) {
    auto cloned = pot->clonePotential();
    min2Pot = cloned ? cloned : eonc::helpers::makePotential(params);
  }
  displacement = std::make_shared<Matter>(pot, params);
  saddle = std::make_shared<Matter>(pot, params);
  min1 = std::make_shared<Matter>(pot, params);
  min2 = std::make_shared<Matter>(min2Pot, params);
  AtomMatrix mode = AtomMatrix::Zero(initial->numberOfAtoms(), 3);
  if (!eonc::helpers::applyClientDisplacement(*saddle, *initial, params,
                                              &mode)) {
    *saddle = *initial;
  }
  *displacement = *saddle;
  *min1 = *min2 = *initial;
  min2->setPotential(min2Pot);
  if (params.saddle_search_options().method == "min_mode") {
    saddleSearch = std::make_unique<MinModeSaddleSearch>(
        saddle, mode, initial->getPotentialEnergy(), params, pot);
  } else if (params.saddle_search_options().method == "basin_hopping") {
    saddleSearch =
        std::make_unique<BasinHoppingSaddleSearch>(min1, saddle, pot, params);
  } else if (params.saddle_search_options().method == "dynamics") {
    saddleSearch = std::make_unique<DynamicsSaddleSearch>(saddle, params);
  } else if (params.saddle_search_options().method == "bgsd") {
    saddleSearch = std::make_unique<BiasedGradientSquaredDescent>(
        saddle, initial->getPotentialEnergy(), params);
  } else {
    throw std::runtime_error(
        "ProcessSearchJob::runFromMatter: unsupported saddle_search.method");
  }
  return runPrepared();
}

runPrepared()

std::shared_ptr< Matter > eonc::ProcessSearchJob::runPrepared ( )

private

Definition at line 227 of file ProcessSearchJob.cpp.

                                                    {
  if (!saddleSearch) {
    throw std::runtime_error("unknown saddle_search.method");
  }
 
  int status = doProcessSearch();
 
  printEndState(status);
  saveData(status);
 
  return min2 ? min2 : saddle;
}

saveData()

void eonc::ProcessSearchJob::saveData ( int status )

private

Writes the results from the run to file.

Definition at line 432 of file ProcessSearchJob.cpp.

                                          {
  std::string resultsFilename("results.dat");
  returnFiles.push_back(resultsFilename);
 
  std::ofstream out(resultsFilename, std::ios::binary);
  if (out) {
    out << std::format("{} termination_reason\n", status);
    out << std::format("{} termination_reason_text\n",
                       saddleSearch->describeStatus(status));
    out << std::format("{} random_seed\n", params.main_options().randomSeed);
    out << std::format(
        "{} potential_type\n",
        magic_enum::enum_name<PotType>(params.potential_options().potential));
    out << std::format("{} total_force_calls\n",
                       fCallsMin + fCallsSaddle + fCallsPrefactors);
    out << std::format("{} force_calls_minimization\n", fCallsMin);
    out << std::format("{} force_calls_saddle\n", fCallsSaddle);
    out << std::format("{:.12e} potential_energy_saddle\n",
                       saddle->getPotentialEnergy());
    out << std::format("{:.12e} potential_energy_reactant\n",
                       min1->getPotentialEnergy());
    out << std::format("{:.12e} potential_energy_product\n",
                       min2->getPotentialEnergy());
    out << std::format("{:.12e} barrier_reactant_to_product\n",
                       barriersValues[0]);
    out << std::format("{:.12e} barrier_product_to_reactant\n",
                       barriersValues[1]);
    if (params.saddle_search_options().method == "min_mode") {
      out << std::format("{:.12e} displacement_saddle_distance\n",
                         displacement->perAtomNorm(*saddle));
    } else {
      out << std::format("{:.12e} displacement_saddle_distance\n", 0.0);
    }
    if (params.saddle_search_options().method == "dynamics") {
      auto ds = dynamic_cast<DynamicsSaddleSearch &>(*saddleSearch);
      out << std::format("{:.12e} simulation_time\n",
                         ds.time * params.constants().timeUnit);
      out << std::format("{:.12e} md_temperature\n",
                         params.saddle_search_options().dynamics.temperature);
    }
    out << std::format("{} force_calls_prefactors\n", fCallsPrefactors);
    out << std::format("{:.12e} prefactor_reactant_to_product\n",
                       prefactorsValues[0]);
    out << std::format("{:.12e} prefactor_product_to_reactant\n",
                       prefactorsValues[1]);
  }
 
  std::string reactantFilename("reactant.con");
  returnFiles.push_back(reactantFilename);
  if (!eonc::io::io_ok(min1->matter2con(reactantFilename))) {
    QUILL_LOG_ERROR(log, "Failed to write {}", reactantFilename);
  }
 
  std::string modeFilename("mode.dat");
  returnFiles.push_back(modeFilename);
  eonc::helpers::saveMode(modeFilename, saddle, saddleSearch->getEigenvector());
 
  std::string saddleFilename("saddle.con");
  returnFiles.push_back(saddleFilename);
  if (!eonc::io::io_ok(saddle->matter2con(saddleFilename))) {
    QUILL_LOG_ERROR(log, "Failed to write {}", saddleFilename);
  }
 
  std::string productFilename("product.con");
  returnFiles.push_back(productFilename);
  if (!eonc::io::io_ok(min2->matter2con(productFilename))) {
    QUILL_LOG_ERROR(log, "Failed to write {}", productFilename);
  }
}

Member Data Documentation

barriersValues

double eonc::ProcessSearchJob::barriersValues[2] {0.0, 0.0}

private

Array containg the value of the potential barriers from reactant to product and vice versa

Definition at line 110 of file ProcessSearchJob.h.

{0.0, 0.0};

displacement

std::shared_ptr<Matter> eonc::ProcessSearchJob::displacement

private

Configuration used during the saddle point search.

Definition at line 102 of file ProcessSearchJob.h.

fCallsMin

size_t eonc::ProcessSearchJob::fCallsMin {0}

private

Force calls to minimize.

Definition at line 118 of file ProcessSearchJob.h.

{0};

fCallsPrefactors

size_t eonc::ProcessSearchJob::fCallsPrefactors {0}

private

Force calls to find the prefactors.

Definition at line 120 of file ProcessSearchJob.h.

{0};

fCallsSaddle

size_t eonc::ProcessSearchJob::fCallsSaddle {0}

private

Force calls to find the saddle.

Definition at line 116 of file ProcessSearchJob.h.

{0};

initial

std::shared_ptr<Matter> eonc::ProcessSearchJob::initial

private

Initial configuration.

Definition at line 98 of file ProcessSearchJob.h.

log

eonc::log::Scoped eonc::ProcessSearchJob::log

private

Definition at line 79 of file ProcessSearchJob.h.

min1

std::shared_ptr<Matter> eonc::ProcessSearchJob::min1

private

First minimum from the saddle.

Definition at line 104 of file ProcessSearchJob.h.

min2

std::shared_ptr<Matter> eonc::ProcessSearchJob::min2

private

Second minimum from the saddle.

Definition at line 106 of file ProcessSearchJob.h.

prefactorsValues

double eonc::ProcessSearchJob::prefactorsValues[2] {0.0, 0.0}

private

Array containg the value of the prefactors of the matter from reactant to product and vice versa

Definition at line 113 of file ProcessSearchJob.h.

{0.0, 0.0};

returnFiles

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

private

Container for the results of the run.

Definition at line 89 of file ProcessSearchJob.h.

saddle

std::shared_ptr<Matter> eonc::ProcessSearchJob::saddle

private

Configuration used during the saddle point search.

Definition at line 100 of file ProcessSearchJob.h.

saddleSearch

std::unique_ptr<SaddleSearchMethod> eonc::ProcessSearchJob::saddleSearch

private

Pulled from parameters.

sa ref BasinHoppingSaddleSearch DynamicsSaddleSearch BiasedGradientSquaredDescent MinModeSaddleSearch

Definition at line 96 of file ProcessSearchJob.h.

---

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

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