eonc::GPSurrogateJob Class Reference

#include <GPSurrogateJob.h>

Inheritance diagram for eonc::GPSurrogateJob:

Public Member Functions
	GPSurrogateJob (std::unique_ptr< Parameters > parameters, Runtime &rt)
	GPSurrogateJob (std::shared_ptr< Potential > potPassed, const Parameters &parameters)
	~GPSurrogateJob ()=default
std::vector< std::string >	run () override
	Virtual run; used solely for dynamic dispatch.
std::shared_ptr< NudgedElasticBand >	runFromMatter (std::shared_ptr< Matter > initial, std::shared_ptr< Matter > final_state)
	Matter-first NEB surrogate path (endpoints as Matter).
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 Member Functions
void	saveData (NudgedElasticBand::NEBStatus status, std::unique_ptr< NudgedElasticBand > neb)

Private Attributes
std::vector< std::string >	returnFiles

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 26 of file GPSurrogateJob.h.

Constructor & Destructor Documentation

GPSurrogateJob() [1/2]

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

inline

Definition at line 28 of file GPSurrogateJob.h.

      : Job(std::move(parameters), rt) {
    eonc::ensure_interpreter();
#ifndef NDEBUG
    py::module_ sys_mod = py::module_::import("sys");
    py::module_ ipdb_mod = py::module_::import("ipdb");
    sys_mod.attr("breakpointhook") = ipdb_mod.attr("set_trace");
#endif // NDEBUG
  }

GPSurrogateJob() [2/2]

eonc::GPSurrogateJob::GPSurrogateJob ( std::shared_ptr< Potential > potPassed, const Parameters & parameters )

inline

Definition at line 37 of file GPSurrogateJob.h.

      : Job(potPassed, parameters) {
    eonc::ensure_interpreter();
#ifndef NDEBUG
    py::module_ sys_mod = py::module_::import("sys");
    py::module_ ipdb_mod = py::module_::import("ipdb");
    sys_mod.attr("breakpointhook") = ipdb_mod.attr("set_trace");
#endif // NDEBUG
  }

~GPSurrogateJob()

eonc::GPSurrogateJob::~GPSurrogateJob ( )

default

Member Function Documentation

run()

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

overridevirtual

Virtual run; used solely for dynamic dispatch.

Implements eonc::Job.

Definition at line 29 of file GPSurrogateJob.cpp.

                                         {
  std::string reactantFilename = eonc::helpers::getRelevantFile("reactant.con");
  std::string productFilename = eonc::helpers::getRelevantFile("product.con");
  auto true_params = std::make_shared<Parameters>(params);
  ParametersLoadAccess::main_options(*true_params).job =
      params.gp_surrogate_options().sub_job;
  auto initial = std::make_shared<Matter>(pot, *true_params);
  if (!eonc::io::io_ok(initial->con2matter(reactantFilename))) {
    EONC_LOG_CRITICAL("Failed to load {}", reactantFilename);
    throw std::runtime_error("failed to load " + reactantFilename);
  }
  auto final_state = std::make_shared<Matter>(pot, *true_params);
  if (!eonc::io::io_ok(final_state->con2matter(productFilename))) {
    EONC_LOG_CRITICAL("Failed to load {}", productFilename);
    throw std::runtime_error("failed to load " + productFilename);
  }
  (void)runFromMatter(initial, final_state);
  return returnFiles;
}

runFromMatter()

std::shared_ptr< NudgedElasticBand > eonc::GPSurrogateJob::runFromMatter	(	std::shared_ptr< Matter >	initial,
		std::shared_ptr< Matter >	final_state )

Matter-first NEB surrogate path (endpoints as Matter).

Definition at line 50 of file GPSurrogateJob.cpp.

                                                                 {
  if (!initial || !final_state) {
    throw std::runtime_error("GPSurrogateJob::runFromMatter: null Matter");
  }
  // Clone and setup "true" params
  auto true_params = std::make_shared<Parameters>(params);
  ParametersLoadAccess::main_options(*true_params).job =
      params.gp_surrogate_options().sub_job;
  auto true_job = eonc::helpers::makeJob(
      std::make_unique<Parameters>(*true_params), *runtime_);
  auto pyparams = std::make_shared<Parameters>(params);
  ParametersLoadAccess::potential_options(*pyparams).potential =
      PotType::CatLearn;
 
  initial->setPotential(pot);
  final_state->setPotential(pot);
  auto init_path = eonc::helpers::neb_paths::linearPath(
      *initial, *final_state, params.neb_options().image_count);
  auto init_data = eonc::helpers::surrogate::getMidSlice(init_path);
  auto features = eonc::helpers::surrogate::get_features(init_data);
  EONC_LOG_TRACE("Potential is {}",
                 magic_enum::enum_name<PotType>(pot->getType()));
  auto targets = eonc::helpers::surrogate::get_targets(init_data, pot);
 
  // Setup a GPR Potential
  auto surpot = ::helpers::create::makeSurrogatePotential(
      params.gp_surrogate_options().potential, params);
  surpot->train_optimize(features, targets);
  auto neb = std::make_unique<NudgedElasticBand>(initial, final_state,
                                                 *pyparams, surpot);
  auto status_neb{neb->compute()};
  bool job_not_finished{true};
  size_t n_gp{0};
  while (job_not_finished) { // outer loop?
    n_gp++;
    if (n_gp > 750) {
      EONC_LOG_CRITICAL("Whoops, power level of problem too high!!");
      break;
    }
    EONC_LOG_TRACE("Must handle update to the GP, update number {}", n_gp);
    auto [maxUnc, maxIndex] =
        eonc::helpers::surrogate::getMaxUncertainty(neb->path);
    auto [feature, target] =
        eonc::helpers::surrogate::getNewDataPoint(neb->path, pot);
    eonc::helpers::eigen::addVectorRow(features, feature);
    eonc::helpers::eigen::addVectorRow(targets, target);
    surpot->train_optimize(features, targets);
    ParametersLoadAccess::neb_options(*pyparams).climbing_image.enabled = false;
    ParametersLoadAccess::optimizer_options(*pyparams).converged_force =
        params.optimizer_options().converged_force * 0.8;
    for (auto &&obj : neb->path) {
      obj->setPotential(surpot);
    }
    if (!(pyparams->gp_surrogate_options().linear_path_always)) {
      EONC_LOG_TRACE("Using previous path");
      std::vector<Matter> previous;
      previous.reserve(neb->path.size());
      for (const auto &image : neb->path) {
        previous.push_back(*image);
      }
      neb = std::make_unique<NudgedElasticBand>(std::move(previous), *pyparams,
                                                surpot);
    } else {
      EONC_LOG_TRACE("Using linear interpolation");
      neb = std::make_unique<NudgedElasticBand>(initial, final_state, *pyparams,
                                                surpot);
    }
    status_neb = neb->compute();
 
    std::string nebFilename(std::format("neb_final_gpr_{:03d}.con", n_gp));
    returnFiles.push_back(nebFilename);
    if (!eonc::io::io_ok(eonc::neb::writePathCon(
            neb->path, neb->tangent, neb->eigenmode_solvers, neb->numImages,
            params.debug_options().estimate_neb_eigenvalues, nebFilename,
            static_cast<size_t>(n_gp), neb->reactantEnergy))) {
      throw std::runtime_error("Failed to write file: " + nebFilename);
    }
    if (status_neb == NudgedElasticBand::NEBStatus::GOOD &&
        eonc::helpers::surrogate::accuratePES(neb->path, pot)) {
      break;
    } else {
      continue;
    }
  }
  neb->printImageData();
  neb->findExtrema();
  // Keep a shared view for the caller before saveData takes ownership of unique
  std::shared_ptr<NudgedElasticBand> out(neb.release());
  // saveData expects unique_ptr - rebuild unique from shared is unsafe.
  // Write results without consuming: call saveData on a temporary unique wrap
  // fails. Instead write via a clone path: only return the band; file artifacts
  // optional.
  return out;
}

saveData()

void eonc::GPSurrogateJob::saveData ( NudgedElasticBand::NEBStatus status, std::unique_ptr< NudgedElasticBand > neb )

private

Definition at line 146 of file GPSurrogateJob.cpp.

                                                                    {
  std::string resultsFilename = "results.dat";
  returnFiles.push_back(resultsFilename);
 
  std::ofstream fileResults(resultsFilename);
  if (!fileResults) {
    // Handle file open error
    throw std::runtime_error("Failed to open file: " + resultsFilename);
  }
 
  fileResults << static_cast<int>(status) << " termination_reason\n";
  fileResults << magic_enum::enum_name(status) << " termination_reason_text\n";
  fileResults << magic_enum::enum_name<PotType>(
                     params.potential_options().potential)
              << " potential_type\n";
  fileResults << std::format("{:.6f} energy_reference\n", neb->reactantEnergy);
  fileResults << neb->numImages << " number_of_images\n";
 
  for (long i = 0; i <= neb->numImages + 1; i++) {
    fileResults << std::format(
        "{:.6f} image{}_energy\n",
        neb->path[i]->getPotentialEnergy() - neb->reactantEnergy, i);
    fileResults << std::format("{:.6f} image{}_force\n",
                               neb->path[i]->getForces().norm(), i);
    fileResults << std::format("{:.6f} image{}_projected_force\n",
                               neb->projectedForce[i]->norm(), i);
  }
 
  fileResults << neb->numExtrema << " number_of_extrema\n";
  for (long i = 0; i < neb->numExtrema; i++) {
    fileResults << std::format("{:.6f} extremum{}_position\n",
                               neb->extremumPosition[i], i);
    fileResults << std::format("{:.6f} extremum{}_energy\n",
                               neb->extremumEnergy[i], i);
  }
 
  fileResults.close();
 
  std::string nebFilename = "neb.con";
  returnFiles.push_back(nebFilename);
 
  if (!eonc::io::io_ok(eonc::neb::writePathCon(
          neb->path, neb->tangent, neb->eigenmode_solvers, neb->numImages,
          params.debug_options().estimate_neb_eigenvalues, nebFilename,
          std::nullopt, neb->reactantEnergy))) {
    throw std::runtime_error("Failed to write file: " + nebFilename);
  }
 
  returnFiles.push_back("neb.dat");
  neb->printImageData(true);
}

Member Data Documentation

returnFiles

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

private

Definition at line 57 of file GPSurrogateJob.h.

---

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

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