eonc::MinimizationJob Class Reference

#include <MinimizationJob.h>

Inheritance diagram for eonc::MinimizationJob:

Public Member Functions
	MinimizationJob (std::unique_ptr< Parameters > parameters, Runtime &rt)
	~MinimizationJob (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.

Private Attributes
RunStatus	status {RunStatus::GOOD}
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

Definition at line 20 of file MinimizationJob.h.

Constructor & Destructor Documentation

MinimizationJob()

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

inline

Definition at line 22 of file MinimizationJob.h.

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

~MinimizationJob()

eonc::MinimizationJob::~MinimizationJob ( void )

default

Member Function Documentation

run()

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

overridevirtual

Virtual run; used solely for dynamic dispatch.

Implements eonc::Job.

Definition at line 29 of file MinimizationJob.cpp.

                                          {
  std::string posInFilename("pos.con");
  std::string posOutFilename("min.con");
 
  if (params.main_options().checkpoint) {
    if (std::filesystem::exists("pos_cp.con")) {
      posInFilename = "pos_cp.con";
      QUILL_LOG_DEBUG(log, "[Minimization] Resuming from checkpoint");
    } else {
      QUILL_LOG_DEBUG(log, "[Minimization] No checkpoint files found");
    }
  }
 
  std::vector<std::string> returnFiles;
  returnFiles.push_back(posOutFilename);
 
  auto pos = std::make_shared<Matter>(pot, params);
  if (!eonc::io::io_ok(pos->con2matter(posInFilename))) {
    QUILL_LOG_CRITICAL(log, "Failed to load {}", posInFilename);
    throw std::runtime_error("failed to load " + posInFilename);
  }
 
  QUILL_LOG_DEBUG(log, "\nBeginning minimization of {}", posInFilename);
 
  bool converged;
  try {
    converged =
        pos->relax(false, params.debug_options().write_movies,
                   params.main_options().checkpoint, "minimization", "pos");
    if (converged) {
      status = RunStatus::GOOD;
      QUILL_LOG_DEBUG(log, "Minimization converged within tolerence");
    } else {
      status = RunStatus::FAIL_MAX_ITERATIONS;
      QUILL_LOG_DEBUG(log, "Minimization did not converge to tolerence!"
                           "Maybe try to increase max_iterations?");
    }
  } catch (int e) {
    if (e == 100) {
      status = RunStatus::FAIL_POTENTIAL_FAILED;
    } else {
      throw e;
    }
  } catch (const std::exception &e) {
    QUILL_LOG_ERROR(log, "Minimization potential failed: {}", e.what());
    status = RunStatus::FAIL_POTENTIAL_FAILED;
  }
 
  QUILL_LOG_DEBUG(log, "Saving result to {}", posOutFilename);
  if (!eonc::io::io_ok(pos->matter2con(posOutFilename))) {
    QUILL_LOG_ERROR(log, "Failed to write {}", posOutFilename);
  }
  if (status != RunStatus::FAIL_POTENTIAL_FAILED) {
    QUILL_LOG_DEBUG(log, "Final Energy: {}", pos->getPotentialEnergy());
  }
 
  std::filesystem::path resultsFilename("results.dat");
  returnFiles.push_back(resultsFilename.string());
 
  const bool hasE = status != RunStatus::FAIL_POTENTIAL_FAILED;
  const double energy = hasE ? pos->getPotentialEnergy() : 0.0;
  auto env = JobResultEnvelope::fromMinimization(
      status, params.potential_options().potential,
      this->pot->forceCallCounter.load(), hasE, energy);
  env.tags.emplace_back("optimizer", std::string(magic_enum::enum_name(
                                         params.optimizer_options().method)));
  if (params.optimizer_options().method == OptType::XTSCI) {
    env.tags.emplace_back("xtsci_method",
                          params.optimizer_options().xtsci.method);
  }
  if (!xtsci_eindir::provenance().empty()) {
    env.tags.emplace_back("eindir_abi", xtsci_eindir::provenance());
  }
  env.writeResultsDat(resultsFilename.string());
 
  return returnFiles;
}

Member Data Documentation

log

eonc::log::Scoped eonc::MinimizationJob::log

private

Definition at line 29 of file MinimizationJob.h.

status

RunStatus eonc::MinimizationJob::status {RunStatus::GOOD}

private

Definition at line 28 of file MinimizationJob.h.

{RunStatus::GOOD};

---

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

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