eonc::FiniteDifferenceJob Class Reference

#include <FiniteDifferenceJob.h>

Inheritance diagram for eonc::FiniteDifferenceJob:

Public Member Functions
	FiniteDifferenceJob (std::unique_ptr< Parameters > parameters)
	~FiniteDifferenceJob (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 ()

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

inline

Definition at line 20 of file FiniteDifferenceJob.h.

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

~FiniteDifferenceJob()

eonc::FiniteDifferenceJob::~FiniteDifferenceJob ( void )

default

Member Function Documentation

run()

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

virtual

Virtual run; used solely for dynamic dispatch.

Implements eonc::Job.

Definition at line 25 of file FiniteDifferenceJob.cpp.

                                                  {
  auto reactant = std::make_unique<Matter>(pot, params);
  if (!eonc::io::io_ok(reactant->con2matter("pos.con"))) {
    EONC_LOG_CRITICAL("Failed to load pos.con");
    throw std::runtime_error("failed to load pos.con");
  }
  AtomMatrix posA = reactant->getPositions();
 
  double dRs[] = {1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 5e-3, 0.01, 0.05, 0.1, -1};
 
  AtomMatrix forceA = reactant->getForces();
 
  long epicenter = eonc::EpiCenters::minCoordinatedEpiCenter(
      reactant.get(), params.structure_comparison_options.neighbor_cutoff);
  AtomMatrix displacement;
  displacement.resize(reactant->numberOfAtoms(), 3);
  displacement.setZero();
  printf("displacing atoms:");
  for (int i = 0; i < reactant->numberOfAtoms(); i++) {
    if (reactant->distance(epicenter, i) <= 3.3) {
      printf(" %i", i);
      for (int j = 0; j < 3; j++) {
        if (!reactant->getFixed(i)) {
          displacement(i, j) = randomDouble(1.0);
        }
      }
    }
  }
  printf("\n");
  displacement.normalize();
 
  std::ofstream results("results.dat");
  results << "0 termination_reason\n";
  results << "GOOD termination_reason_text\n";
  results << "finite_difference job_type\n";
  results << std::format("{} total_force_calls\n",
                         PotRegistry::get().total_force_calls());
 
  std::ofstream table("curvature.dat");
  table << std::format("{:>14s}    {:>14s}\n", "dR", "curvature");
  printf("%14s    %14s\n", "dR", "curvature");
  AtomMatrix posB;
  AtomMatrix forceB;
  double curvature = 0.0;
  for (int dRi = 0; dRs[dRi] != -1; 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);
    results << std::format("{:.12e} dR_{}\n", dRs[dRi], dRi);
    results << std::format("{:.12e} curvature_{}\n", curvature, dRi);
    printf("%14.8f    %14.8f\n", dRs[dRi], curvature);
    table.flush();
  }
 
  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