eonc::FiniteDifferenceJob Class Reference

#include <FiniteDifferenceJob.h>

Inheritance diagram for eonc::FiniteDifferenceJob:

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

Constructor & Destructor Documentation

FiniteDifferenceJob()

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

inline

Definition at line 20 of file FiniteDifferenceJob.h.

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

~FiniteDifferenceJob()

eonc::FiniteDifferenceJob::~FiniteDifferenceJob ( void )

default

Member Function Documentation

run()

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

overridevirtual

Virtual run; used solely for dynamic dispatch.

Implements eonc::Job.

Definition at line 29 of file FiniteDifferenceJob.cpp.

                                                  {
  auto reactant = std::make_unique<Matter>(pot, params);
  const std::string posFile = eonc::helpers::getRelevantFile("pos.con");
  if (!eonc::io::io_ok(reactant->con2matter(posFile))) {
    EONC_LOG_CRITICAL("Failed to load {}", posFile);
    throw std::runtime_error("failed to load " + posFile);
  }
  AtomMatrix posA = reactant->getPositions();
 
  constexpr std::array<double, 9> dRs = {1e-7, 1e-6, 1e-5, 1e-4, 1e-3,
                                         5e-3, 0.01, 0.05, 0.1};
 
  AtomMatrix forceA = reactant->getForces();
 
  const double cutoff = params.structure_comparison_options().neighbor_cutoff;
  long epicenter =
      eonc::EpiCenters::minCoordinatedEpiCenter(reactant.get(), cutoff);
  AtomMatrix displacement;
  displacement.resize(reactant->numberOfAtoms(), 3);
  displacement.setZero();
  std::string displaced;
  for (int i = 0; i < reactant->numberOfAtoms(); i++) {
    if (reactant->distance(epicenter, i) <= cutoff) {
      // getFixed(atom) is true only when every axis is fixed. A column-4
      // mask that freezes one axis must not enter the step or its norm.
      if (!displaced.empty()) {
        displaced.push_back(' ');
      }
      displaced += std::to_string(i);
      for (int j = 0; j < 3; j++) {
        if (reactant->getFixed(i, j)) {
          continue;
        }
        displacement(i, j) = eonc::rng::randomDouble(1.0);
      }
    }
  }
  EONC_LOG_INFO("displacing atoms: {}", displaced);
  const double dispNorm = displacement.norm();
  if (!(dispNorm > 0.0)) {
    throw std::runtime_error(
        "FiniteDifferenceJob: no free atoms in the epicenter neighborhood");
  }
  displacement /= dispNorm;
 
  auto env = JobResultEnvelope::fromMinimization(
      RunStatus::GOOD, params.potential_options().potential,
      PotRegistry::get().total_force_calls(), false, 0.0);
  env.job_type = "finite_difference";
 
  std::ofstream table("curvature.dat");
  table << std::format("{:>14s}    {:>14s}\n", "dR", "curvature");
  EONC_LOG_INFO("{:>14}    {:>14}", "dR", "curvature");
  AtomMatrix posB;
  AtomMatrix forceB;
  double curvature = 0.0;
  for (size_t dRi = 0; dRi < dRs.size(); ++dRi) {
    posB = posA + displacement * dRs[dRi];
    reactant->setPositions(posB);
    forceB = reactant->getForces();
    curvature = matDot(forceB - forceA, displacement) / dRs[dRi];
    table << std::format("{:14.8f}    {:14.8f}\n", dRs[dRi], curvature);
    env.extras.emplace_back(std::format("dR_{}", dRi), dRs[dRi]);
    env.extras.emplace_back(std::format("curvature_{}", dRi), curvature);
    EONC_LOG_INFO("{:14.8f}    {:14.8f}", dRs[dRi], curvature);
    table.flush();
  }
 
  env.force_calls = PotRegistry::get().total_force_calls();
  env.writeResultsDat("results.dat");
  std::vector<std::string> returnFiles;
  returnFiles.push_back("results.dat");
  returnFiles.push_back("curvature.dat");
  return returnFiles;
}

---

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

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