eonc::SaddleSearchJob Class Reference

Declaration of the Saddle Search job. More...

#include <SaddleSearchJob.h>

Inheritance diagram for eonc::SaddleSearchJob:

Public Member Functions
	SaddleSearchJob (std::unique_ptr< Parameters > parameters, Runtime &rt)
	Saddle Search job constructor.
	~SaddleSearchJob (void)=default
	Saddle Search Job Deconstructor.
std::vector< std::string >	run (void) override
	Kicks off the Saddle Search.
std::shared_ptr< Matter >	runFromMatter (std::shared_ptr< Matter > seed)
	In-process entry: seed reactant Matter, no pos.con.
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 (const AtomMatrix &mode)
int	doSaddleSearch ()
	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
std::vector< std::string >	returnFiles
	Container for the results of the run.
std::unique_ptr< SaddleSearchMethod >	saddleSearch
	Initializes a ref SaddleSearchMethod (base class for polymorphism).
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.
int	fCallsSaddle
	Force calls to find the saddle.
eonc::log::Scoped	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

Declaration of the Saddle Search job.

Definition at line 45 of file SaddleSearchJob.h.

Constructor & Destructor Documentation

SaddleSearchJob()

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

inline

Saddle Search job constructor.

Parameters

*params

defined by the config.init file

Definition at line 51 of file SaddleSearchJob.h.

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

~SaddleSearchJob()

eonc::SaddleSearchJob::~SaddleSearchJob ( void )

default

Saddle Search Job Deconstructor.

Member Function Documentation

doSaddleSearch()

int eonc::SaddleSearchJob::doSaddleSearch ( )

private

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

Definition at line 139 of file SaddleSearchJob.cpp.

                                    {
  long status;
  int f1{0};
  f1 = this->pot->forceCallCounter;
  try {
    status = saddleSearch->run();
  } catch (int e) {
    if (e == 100) {
      status = MinModeSaddleSearch::STATUS_POTENTIAL_FAILED;
    } else {
      QUILL_LOG_ERROR(log, "unknown exception: {}", e);
      throw e;
    }
  } catch (const std::exception &e) {
    QUILL_LOG_ERROR(log, "Saddle search potential failed: {}", e.what());
    status = MinModeSaddleSearch::STATUS_POTENTIAL_FAILED;
  }
 
  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 += this->pot->forceCallCounter - f1;
  }
 
  return status;
}

printEndState()

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

private

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

Definition at line 209 of file SaddleSearchJob.cpp.

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

run()

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

overridevirtual

Kicks off the Saddle Search.

Implements eonc::Job.

Definition at line 29 of file SaddleSearchJob.cpp.

                                          {
  std::string reactantFilename = eonc::helpers::getRelevantFile("pos.con");
  std::string displacementFilename("displacement.con");
  std::string modeFilename("direction.dat");
 
  if (params.main_options().checkpoint) {
    if (std::filesystem::exists("displacement_cp.con") &&
        std::filesystem::exists("mode_cp.dat")) {
      displacementFilename = "displacement_cp.con";
      modeFilename = "mode_cp.dat";
      QUILL_LOG_DEBUG(log, "Resuming from checkpoint");
    } else {
      QUILL_LOG_DEBUG(log, "No checkpoint files found");
    }
  }
 
  initial = std::make_shared<Matter>(pot, params);
  displacement = std::make_shared<Matter>(pot, params);
  saddle = std::make_shared<Matter>(pot, params);
 
  if (!eonc::io::io_ok(initial->con2matter(reactantFilename))) {
    EONC_LOG_CRITICAL("Failed to load {}", reactantFilename);
    throw std::runtime_error("failed to load " + reactantFilename);
  }
 
  const bool standaloneARTn = params.saddle_search_options().method == "artn";
 
  AtomMatrix mode = AtomMatrix::Zero(initial->numberOfAtoms(), 3);
  if (!standaloneARTn && 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("missing displacement.con and direction.dat");
    }
    if (std::filesystem::exists(modeFilename)) {
      mode = eonc::helpers::loadMode(modeFilename, initial->numberOfAtoms());
    }
  } else if (!standaloneARTn && eonc::helpers::applyClientDisplacement(
                                    *saddle, *initial, params, &mode)) {
    // listed_atoms / random / last_atom / least_coordinated / not_fcc_hcp
  } else {
    *saddle = *initial;
  }
 
  if (standaloneARTn && std::filesystem::exists(modeFilename)) {
    mode = eonc::helpers::loadMode(modeFilename, initial->numberOfAtoms());
  }
 
  (void)runPrepared(mode);
  return returnFiles;
}

runFromMatter()

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

(

std::shared_ptr< Matter >

seed

)

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

Definition at line 86 of file SaddleSearchJob.cpp.

                                                         {
  if (!seed) {
    throw std::runtime_error("SaddleSearchJob::runFromMatter: null Matter");
  }
  initial = seed;
  initial->setPotential(pot);
  displacement = std::make_shared<Matter>(pot, params);
  saddle = std::make_shared<Matter>(pot, params);
  AtomMatrix mode = AtomMatrix::Zero(initial->numberOfAtoms(), 3);
  if (!eonc::helpers::applyClientDisplacement(*saddle, *initial, params,
                                              &mode)) {
    *saddle = *initial;
  }
  *displacement = *saddle;
  return runPrepared(mode);
}

runPrepared()

std::shared_ptr< Matter > eonc::SaddleSearchJob::runPrepared ( const AtomMatrix & mode )

private

Definition at line 103 of file SaddleSearchJob.cpp.

                                                                         {
  const bool useStandaloneARTn =
      params.saddle_search_options().method == "artn";
  const bool useARTnAsMinMode =
      params.saddle_search_options().method == "min_mode" &&
      params.saddle_search_options().minmode_method == "artn";
 
#ifdef WITH_ARTN
  if (useStandaloneARTn || useARTnAsMinMode) {
    saddleSearch =
        std::make_unique<ARTnSaddleSearch>(saddle, pot, mode, params);
  } else
#endif
  {
#ifndef WITH_ARTN
    if (useStandaloneARTn) {
      throw std::runtime_error(
          "saddle_search.method=artn requires a build with ARTn support");
    }
    if (useARTnAsMinMode) {
      throw std::runtime_error(
          "saddle_search.minmode_method=artn requires a build with ARTn "
          "support");
    }
#endif
    saddleSearch = std::make_unique<MinModeSaddleSearch>(
        saddle, mode, initial->getPotentialEnergy(), params, pot);
  }
 
  int status = doSaddleSearch();
  printEndState(status);
  saveData(status);
 
  return saddle;
}

saveData()

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

private

Writes the results from the run to file.

Definition at line 170 of file SaddleSearchJob.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 << "saddle_search job_type\n";
    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",
                       this->pot->forceCallCounter.load());
    out << std::format("{} force_calls_saddle\n", fCallsSaddle);
    out << std::format("{} iterations\n", saddleSearch->getIterationCount());
    if (status != MinModeSaddleSearch::STATUS_POTENTIAL_FAILED) {
      out << std::format("{:f} potential_energy_saddle\n",
                         saddle->getPotentialEnergy());
      out << std::format("{:f} final_eigenvalue\n",
                         saddleSearch->getEigenvalue());
    }
    out << std::format("{:f} potential_energy_reactant\n",
                       initial->getPotentialEnergy());
  }
 
  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);
  }
}

Member Data Documentation

displacement

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

private

Configuration used during the saddle point search.

Definition at line 80 of file SaddleSearchJob.h.

fCallsSaddle

int eonc::SaddleSearchJob::fCallsSaddle

private

Force calls to find the saddle.

Definition at line 83 of file SaddleSearchJob.h.

initial

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

private

Initial configuration.

Definition at line 76 of file SaddleSearchJob.h.

log

eonc::log::Scoped eonc::SaddleSearchJob::log

private

Definition at line 85 of file SaddleSearchJob.h.

returnFiles

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

private

Container for the results of the run.

Definition at line 71 of file SaddleSearchJob.h.

saddle

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

private

Configuration used during the saddle point search.

Definition at line 78 of file SaddleSearchJob.h.

saddleSearch

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

private

Initializes a ref SaddleSearchMethod (base class for polymorphism).

Definition at line 74 of file SaddleSearchJob.h.

---

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

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