MinimizationJob Class Reference

#include <MinimizationJob.h>

Inheritance diagram for MinimizationJob:

Public Member Functions
	MinimizationJob (std::unique_ptr< Parameters > parameters)
	~MinimizationJob (void)=default
std::vector< std::string >	run (void)
	Virtual run; used solely for dynamic dispatch.
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 Attributes
size_t	fcalls
RunStatus	status
eonc::log::Scoped	log

Additional Inherited Members
Protected Attributes inherited from eonc::Job
JobType	jtype
Parameters	params
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 )

inline

Definition at line 22 of file MinimizationJob.h.

      : Job(std::move(parameters)),
        fcalls{0} {}

~MinimizationJob()

eonc::MinimizationJob::~MinimizationJob ( void )

default

Member Function Documentation

run()

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

virtual

Virtual run; used solely for dynamic dispatch.

Implements eonc::Job.

Definition at line 24 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;
    }
  }
 
  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());
 
  std::ofstream fileResults(resultsFilename, std::ios::binary);
 
  if (!fileResults.is_open()) {
    std::cerr << "Error opening file " << resultsFilename << ": "
              << std::strerror(errno) << std::endl;
    throw std::runtime_error("Failed to open results file: " +
                             std::string(std::strerror(errno)));
    return returnFiles;
  }
 
  fileResults << static_cast<int>(status) << " termination_reason\n";
  fileResults << magic_enum::enum_name<RunStatus>(status)
              << " termination_reason_text\n";
  fileResults << "minimization job_type\n";
  fileResults << magic_enum::enum_name<PotType>(
                     params.potential_options.potential)
              << " potential_type\n";
  fileResults << this->pot->forceCallCounter.load() << " total_force_calls\n";
 
  if (status != RunStatus::FAIL_POTENTIAL_FAILED) {
    fileResults << std::format("{:.12e} potential_energy\n",
                               pos->getPotentialEnergy());
  }
 
  // No explicit fclose needed; RAII handles it.
  if (!fileResults.good()) {
    std::cerr << "Error writing to file " << resultsFilename
              << ": May be incomplete." << std::endl;
    // Consider throwing, depending on the severity.
  }
 
  return returnFiles;
}

Member Data Documentation

fcalls

size_t eonc::MinimizationJob::fcalls

private

Definition at line 29 of file MinimizationJob.h.

log

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

private

Definition at line 31 of file MinimizationJob.h.

status

RunStatus eonc::MinimizationJob::status

private

Definition at line 30 of file MinimizationJob.h.

---

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