eonc::HessianJob Class Reference

#include <HessianJob.h>

Inheritance diagram for eonc::HessianJob:

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

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 18 of file HessianJob.h.

Constructor & Destructor Documentation

HessianJob()

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

inline

Definition at line 20 of file HessianJob.h.

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

~HessianJob()

eonc::HessianJob::~HessianJob ( void )

default

Member Function Documentation

run()

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

overridevirtual

Virtual run; used solely for dynamic dispatch.

Implements eonc::Job.

Definition at line 31 of file HessianJob.cpp.

                                         {
  std::string matter_in = eonc::helpers::getRelevantFile("pos.con");
 
  std::vector<std::string> returnFiles;
 
  auto matter = std::make_unique<Matter>(pot, params);
 
  if (!eonc::io::io_ok(matter->con2matter(matter_in))) {
    EONC_LOG_CRITICAL("Failed to load {}", matter_in);
    throw std::runtime_error("failed to load " + matter_in);
  }
 
  Hessian hessian(params, matter.get());
 
  // [Hessian] phva_atoms = PHVA mobile/active set (displaced in FD). free/fixed
  // is the optimizer mask; resolveMobileAtoms intersects the list with free.
  const VectorXi mobile = eonc::resolveMobileAtoms(
      matter.get(), params.hessian_options().phva_atoms);
  const bool no_mobile = mobile.size() == 0;
  bool freqs_ok = false;
  bool modes_ok = false;
  if (!no_mobile) {
    const VectorXd freqs = hessian.getFreqs(matter.get(), mobile);
    freqs_ok = freqs.size() > 0;
    if (freqs_ok && params.hessian_options().write_modes) {
      modes_ok = writeNormalModes(*matter, mobile, freqs, hessian.getModes(),
                                  "modes.con");
      if (!modes_ok) {
        EONC_LOG_ERROR("[Hessian] failed to write modes.con");
      }
    }
  }
 
  std::string results_file("results.dat");
  returnFiles.push_back(results_file);
 
  const auto status =
      freqs_ok ? RunStatus::GOOD : RunStatus::FAIL_POTENTIAL_FAILED;
  auto env = JobResultEnvelope::fromMinimization(
      status, params.potential_options().potential,
      PotRegistry::get().total_force_calls(), false, 0.0);
  env.job_type = "hessian";
  env.extras.emplace_back("force_calls", static_cast<double>(env.force_calls));
  env.writeResultsDat(results_file);
  if (std::filesystem::exists("hessian.dat")) {
    returnFiles.push_back("hessian.dat");
  }
  if (modes_ok) {
    returnFiles.push_back("modes.con");
  }
 
  return returnFiles;
}

---

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

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