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)
	Saddle Search job constructor.
	~SaddleSearchJob (void)=default
	Saddle Search Job Deconstructor.
std::vector< std::string >	run (void)
	Kicks off the Saddle Search.
Public Member Functions inherited from eonc::Job
	Job (std::unique_ptr< Parameters > parameters)
	Job (std::shared_ptr< Potential > potPassed, const Parameters &parameters)
virtual	~Job ()=default
JobType	getType ()

Private Member Functions
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::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 )

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)),
        fCallsSaddle{0} {}

~SaddleSearchJob()

eonc::SaddleSearchJob::~SaddleSearchJob ( void )

default

Saddle Search Job Deconstructor.

Member Function Documentation

doSaddleSearch()

int SaddleSearchJob::doSaddleSearch ( )

private

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

Definition at line 109 of file SaddleSearchJob.cpp.

                                    {
  Matter matterTemp(pot, params);
  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 {
      printf("unknown exception: %i\n", e);
      throw e;
    }
  }
 
  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 SaddleSearchJob::printEndState ( int status )

private

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

Definition at line 177 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 > SaddleSearchJob::run ( void )

virtual

Kicks off the Saddle Search.

Implements eonc::Job.

Definition at line 27 of file SaddleSearchJob.cpp.

                                          {
  std::string reactantFilename("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";
 
  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");
    }
  } else {
    *saddle = *initial;
  }
 
  AtomMatrix mode = AtomMatrix::Zero(initial->numberOfAtoms(), 3);
  const bool canLoadMode =
      params.saddle_search_options.displace_type == eonc::EpiCenters::DISP_LOAD;
  if (canLoadMode && std::filesystem::exists(modeFilename)) {
    mode = eonc::helpers::loadMode(modeFilename, initial->numberOfAtoms());
  }
 
  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 returnFiles;
}

saveData()

void SaddleSearchJob::saveData ( int status )

private

Writes the results from the run to file.

Definition at line 138 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 77 of file SaddleSearchJob.h.

fCallsSaddle

int eonc::SaddleSearchJob::fCallsSaddle

private

Force calls to find the saddle.

Definition at line 80 of file SaddleSearchJob.h.

initial

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

private

Initial configuration.

Definition at line 73 of file SaddleSearchJob.h.

log

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

private

Definition at line 82 of file SaddleSearchJob.h.

returnFiles

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

private

Container for the results of the run.

Definition at line 68 of file SaddleSearchJob.h.

saddle

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

private

Configuration used during the saddle point search.

Definition at line 75 of file SaddleSearchJob.h.

saddleSearch

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

private

Initializes a ref SaddleSearchMethod (base class for polymorphism).

Definition at line 71 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