eonc::PrefactorJob Class Reference

#include <PrefactorJob.h>

Inheritance diagram for eonc::PrefactorJob:

Public Member Functions
	PrefactorJob (std::unique_ptr< Parameters > parameters, Runtime &rt)
	~PrefactorJob ()=default
std::vector< std::string >	run () override
	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.

Static Public Attributes
static constexpr std::string_view	PREFACTOR_REACTANT {"reactant"}
static constexpr std::string_view	PREFACTOR_SADDLE {"saddle"}
static constexpr std::string_view	PREFACTOR_PRODUCT {"product"}

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 21 of file PrefactorJob.h.

Constructor & Destructor Documentation

PrefactorJob()

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

inline

Definition at line 23 of file PrefactorJob.h.

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

~PrefactorJob()

eonc::PrefactorJob::~PrefactorJob ( )

default

Member Function Documentation

run()

std::vector< std::string > eonc::PrefactorJob::run ( )

overridevirtual

Virtual run; used solely for dynamic dispatch.

Implements eonc::Job.

Definition at line 32 of file PrefactorJob.cpp.

                                       {
  std::vector<std::string> returnFiles;
  VectorXd freqs;
 
  std::string reactantFilename = eonc::helpers::getRelevantFile("reactant.con");
  std::string saddleFilename = eonc::helpers::getRelevantFile("saddle.con");
  std::string productFilename = eonc::helpers::getRelevantFile("product.con");
 
  auto reactant = std::make_unique<Matter>(pot, params);
  auto saddle = std::make_unique<Matter>(pot, params);
  auto product = std::make_unique<Matter>(pot, params);
 
  if (!eonc::io::io_ok(reactant->con2matter(reactantFilename)) ||
      !eonc::io::io_ok(saddle->con2matter(saddleFilename)) ||
      !eonc::io::io_ok(product->con2matter(productFilename))) {
    EONC_LOG_CRITICAL("Failed to load reactant/saddle/product for prefactor");
    throw std::runtime_error("failed to load prefactor geometries");
  }
  double pref1 = 0.0, pref2 = 0.0;
  const int prefStatus = eonc::Prefactor::getPrefactors(
      params, reactant.get(), saddle.get(), product.get(), pref1, pref2);
 
  VectorXi atoms;
  if (params.prefactor_options().all_free_atoms) {
    std::string matterFilename;
    if (params.prefactor_options().configuration ==
        PrefactorJob::PREFACTOR_REACTANT) {
      matterFilename = reactantFilename;
    } else if (params.prefactor_options().configuration ==
               PrefactorJob::PREFACTOR_SADDLE) {
      matterFilename = saddleFilename;
    } else if (params.prefactor_options().configuration ==
               PrefactorJob::PREFACTOR_PRODUCT) {
      matterFilename = productFilename;
    }
    if (!eonc::io::io_ok(reactant->con2matter(matterFilename)) ||
        !eonc::io::io_ok(saddle->con2matter(matterFilename)) ||
        !eonc::io::io_ok(product->con2matter(matterFilename))) {
      EONC_LOG_CRITICAL("Failed to reload {} for all-free-atoms prefactor",
                        matterFilename);
      throw std::runtime_error("failed to load prefactor configuration");
    }
 
    atoms = eonc::Prefactor::allFreeAtoms(reactant.get());
  } else {
    if (!eonc::io::io_ok(reactant->con2matter(reactantFilename)) ||
        !eonc::io::io_ok(saddle->con2matter(saddleFilename)) ||
        !eonc::io::io_ok(product->con2matter(productFilename))) {
      EONC_LOG_CRITICAL(
          "Failed to reload reactant/saddle/product for prefactor");
      throw std::runtime_error("failed to load prefactor geometries");
    }
 
    atoms = eonc::Prefactor::movedAtoms(params, reactant.get(), saddle.get(),
                                        product.get());
  }
  bool failed = (prefStatus == -1) || (atoms.rows() == 0);
 
  if (!failed) {
    if (params.prefactor_options().configuration ==
        PrefactorJob::PREFACTOR_REACTANT) {
      Hessian hessian(params, reactant.get());
      freqs = hessian.getFreqs(reactant.get(), atoms);
    } else if (params.prefactor_options().configuration ==
               PrefactorJob::PREFACTOR_SADDLE) {
      Hessian hessian(params, saddle.get());
      freqs = hessian.getFreqs(saddle.get(), atoms);
    } else if (params.prefactor_options().configuration ==
               PrefactorJob::PREFACTOR_PRODUCT) {
      Hessian hessian(params, product.get());
      freqs = hessian.getFreqs(product.get(), atoms);
    }
  }
 
  if (!failed) {
    failed = freqs.size() != 3 * atoms.rows();
  }
 
  std::string results_file("results.dat");
  std::string freq_file("freq.dat");
  returnFiles.push_back(results_file);
  returnFiles.push_back(freq_file);
 
  std::ofstream outFreq(freq_file, std::ios::binary);
 
  auto env = JobResultEnvelope::fromMinimization(
      failed ? RunStatus::FAIL_POTENTIAL_FAILED : RunStatus::GOOD,
      params.potential_options().potential,
      PotRegistry::get().total_force_calls(), false, 0.0);
  env.job_type = "prefactor";
  env.tags.emplace_back("good", failed ? "false" : "true");
  env.extras.emplace_back("force_calls", static_cast<double>(env.force_calls));
  if (!failed) {
    env.extras.emplace_back("prefactor_reactant_to_product", pref1);
    env.extras.emplace_back("prefactor_product_to_reactant", pref2);
  }
  env.writeResultsDat(results_file);
 
  if (outFreq && !failed) {
    for (int i = 0; i < freqs.size(); i++) {
      if (0. < freqs[i]) {
        outFreq << std::format("{:f}\n",
                               std::sqrt(freqs[i]) /
                                   (2 * eonc::helpers::pi * 10.18e-15));
      } else {
        outFreq << std::format("{:f}\n",
                               -std::sqrt(-freqs[i]) /
                                   (2 * eonc::helpers::pi * 10.18e-15));
      }
    }
  }
 
  if (std::filesystem::exists("freqs.dat")) {
    returnFiles.push_back("freqs.dat");
  }
  if (std::filesystem::exists("hessian.dat")) {
    returnFiles.push_back("hessian.dat");
  }
 
  return returnFiles;
}

Member Data Documentation

PREFACTOR_PRODUCT

std::string_view eonc::PrefactorJob::PREFACTOR_PRODUCT {"product"}

staticconstexpr

Definition at line 29 of file PrefactorJob.h.

{"product"};

PREFACTOR_REACTANT

std::string_view eonc::PrefactorJob::PREFACTOR_REACTANT {"reactant"}

staticconstexpr

Definition at line 27 of file PrefactorJob.h.

{"reactant"};

PREFACTOR_SADDLE

std::string_view eonc::PrefactorJob::PREFACTOR_SADDLE {"saddle"}

staticconstexpr

Definition at line 28 of file PrefactorJob.h.

{"saddle"};

---

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

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