eonc::StructureComparisonJob Class Reference

#include <StructureComparisonJob.h>

Inheritance diagram for eonc::StructureComparisonJob:

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

Constructor & Destructor Documentation

StructureComparisonJob()

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

inline

Definition at line 21 of file StructureComparisonJob.h.

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

~StructureComparisonJob()

eonc::StructureComparisonJob::~StructureComparisonJob ( void )

default

Member Function Documentation

run()

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

overridevirtual

Virtual run; used solely for dynamic dispatch.

Implements eonc::Job.

Definition at line 27 of file StructureComparisonJob.cpp.

                                                 {
  std::vector<std::string> returnFiles;
  const std::string file1 = eonc::helpers::getRelevantFile("matter1.con");
  const std::string file2 = eonc::helpers::getRelevantFile("matter2.con");
 
  auto matter1 = std::make_unique<Matter>(pot, params);
  if (!eonc::io::io_ok(matter1->con2matter(file1))) {
    EONC_LOG_CRITICAL("Failed to load {}", file1);
    throw std::runtime_error("failed to load " + file1);
  }
  auto matter2 = std::make_unique<Matter>(pot, params);
  if (!eonc::io::io_ok(matter2->con2matter(file2))) {
    EONC_LOG_CRITICAL("Failed to load {}", file2);
    throw std::runtime_error("failed to load " + file2);
  }
 
  // Matter::compare can translate the left operand. Probe on a copy.
  Matter probe(*matter1);
  const bool match = probe.compare(
      *matter2, params.structure_comparison_options().indistinguishable_atoms);
 
  double distance = std::numeric_limits<double>::quiet_NaN();
  double perAtom = std::numeric_limits<double>::quiet_NaN();
  if (matter1->numberOfAtoms() == matter2->numberOfAtoms()) {
    distance = matter1->distanceTo(*matter2);
    perAtom = matter1->perAtomNorm(*matter2);
  }
 
  const double e1 = matter1->getPotentialEnergy();
  const double e2 = matter2->getPotentialEnergy();
 
  const std::string resultsFilename("results.dat");
  std::ofstream out(resultsFilename, std::ios::binary);
  if (!out) {
    EONC_LOG_CRITICAL("Failed to open {}", resultsFilename);
    throw std::runtime_error("failed to open " + resultsFilename);
  }
  out << std::format("{} termination_reason\n",
                     static_cast<int>(RunStatus::GOOD));
  out << std::format("{} termination_reason_text\n",
                     magic_enum::enum_name<RunStatus>(RunStatus::GOOD));
  out << "structure_comparison job_type\n";
  out << std::format("{} match\n", match ? 1 : 0);
  out << std::format("{:.12f} distance\n", distance);
  out << std::format("{:.12f} per_atom_norm\n", perAtom);
  out << std::format("{:.12f} energy_1\n", e1);
  out << std::format("{:.12f} energy_2\n", e2);
  out << std::format("{:.12f} energy_abs_diff\n", std::abs(e1 - e2));
  out.close();
  if (!out) {
    throw std::runtime_error("failed to write " + resultsFilename);
  }
  returnFiles.push_back(resultsFilename);
  return returnFiles;
}

---

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

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