eonc::TestJob Class Reference

#include <TestJob.h>

Inheritance diagram for eonc::TestJob:

Public Member Functions
	TestJob (std::unique_ptr< Parameters > params, Runtime &rt)
	~TestJob ()=default
std::vector< std::string >	run ()
	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 Member Functions
void	checkFullSearch ()
void	checkPotentials ()
double	getEnergyDiff (const std::string &potTag, double refEnergy)
double	getForceDiff (const std::string &potTag, double refForce)

Private Attributes
double	tolerance {0.01}

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 22 of file TestJob.h.

Constructor & Destructor Documentation

TestJob()

eonc::TestJob::TestJob ( std::unique_ptr< Parameters > params, Runtime & rt )

inline

Definition at line 24 of file TestJob.h.

      : Job(std::move(params), rt),
        tolerance{0.01} {}

~TestJob()

eonc::TestJob::~TestJob ( )

default

Member Function Documentation

checkFullSearch()

void eonc::TestJob::checkFullSearch ( )

private

Definition at line 41 of file TestJob.cpp.

                              {
  // Historical saddle self-test needs reactant_test.con / displacement_test.con
  // which the tree does not ship. Keep the hook.
}

checkPotentials()

void eonc::TestJob::checkPotentials ( )

private

Definition at line 46 of file TestJob.cpp.

                              {
  const std::array<PotRef, 8> cases{{
      {"lj", eonc::PotType::LJ, -1475.984331, 2.007213},
      {"emt", eonc::PotType::EMT, 46.086312, 0.357493},
      {"edip", eonc::PotType::EDIP, -1033.250950, 7.080115},
      {"tersoff_si", eonc::PotType::TERSOFF_SI, -1035.809985, 11.145002},
      {"sw_si", eonc::PotType::SW_SI, -1449.795645, 2.530904},
      {"lenosky_si", eonc::PotType::LENOSKY_SI, -1410.679106, 2.320168},
      {"eam_al", eonc::PotType::EAM_AL, -1206.825825, 0.000246},
      {"tip4p", eonc::PotType::TIP4P, 4063.865115, 73.655248},
  }};
 
  std::ofstream out("results.dat");
  for (const auto &c : cases) {
    try {
      const double de = getEnergyDiff(c.tag, c.energy);
      if (std::abs(de) > tolerance) {
        out << "FAIL " << c.tag << " energy_diff " << de << "\n";
        continue;
      }
      const double df = getForceDiff(c.tag, c.max_force);
      if (std::abs(df) > tolerance) {
        out << "FAIL " << c.tag << " force_diff " << df << "\n";
        continue;
      }
      out << "OK " << c.tag << "\n";
    } catch (const std::exception &e) {
      out << "SKIP " << c.tag << " " << e.what() << "\n";
    }
  }
}

getEnergyDiff()

double eonc::TestJob::getEnergyDiff ( const std::string & potTag, double refEnergy )

private

Definition at line 78 of file TestJob.cpp.

                                                                       {
  auto type = magic_enum::enum_cast<eonc::PotType>(
      potTag, magic_enum::case_insensitive);
  if (!type) {
    throw std::invalid_argument("unknown pot " + potTag);
  }
  Parameters p = params;
  ParametersLoadAccess::potential_options(p).potential = *type;
  auto potHandle = eonc::helpers::makePotential(*type, p);
  Matter pos(potHandle, p);
  if (!eonc::io::io_ok(pos.con2matter(std::string("pos_test.con")))) {
    throw std::runtime_error("no pos_test.con");
  }
  return pos.getPotentialEnergy() - refEnergy;
}

getForceDiff()

double eonc::TestJob::getForceDiff ( const std::string & potTag, double refForce )

private

Definition at line 94 of file TestJob.cpp.

                                                                     {
  auto type = magic_enum::enum_cast<eonc::PotType>(
      potTag, magic_enum::case_insensitive);
  if (!type) {
    throw std::invalid_argument("unknown pot " + potTag);
  }
  Parameters p = params;
  ParametersLoadAccess::potential_options(p).potential = *type;
  auto potHandle = eonc::helpers::makePotential(*type, p);
  Matter pos(potHandle, p);
  if (!eonc::io::io_ok(pos.con2matter(std::string("pos_test.con")))) {
    throw std::runtime_error("no pos_test.con");
  }
  return pos.maxForce() - refForce;
}

run()

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

virtual

Virtual run; used solely for dynamic dispatch.

Implements eonc::Job.

Definition at line 35 of file TestJob.cpp.

                                  {
  checkPotentials();
  checkFullSearch();
  return {"results.dat"};
}

Member Data Documentation

tolerance

double eonc::TestJob::tolerance {0.01}

private

Definition at line 31 of file TestJob.h.

{0.01};

---

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

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