AMS_IO Class Reference

#include <AMS_IO.h>

Inheritance diagram for AMS_IO:

Public Member Functions
	AMS_IO (const eonc::Parameters &p)
	~AMS_IO ()
void	initialize ()
void	cleanMemory (void)
void	force (long N, const double *R, const int *atomicNrs, double *F, double *U, double *variance, const double *box)
Public Member Functions inherited from eonc::Potential
	Potential (PotType a_ptype)
	Production default: construction-scope registry, else PotRegistry::get().
	Potential (PotType a_ptype, IPotRegistry &registry)
	Test seam: injected registry, no process-default get() counters.
	Potential (PotType a_ptype, const Parameters &p)
	Potential (const Parameters &a_params)
virtual	~Potential ()
void	force (std::span< const double > positions, std::span< const int > atomicNrs, std::span< double > forces, double *energy, double *variance, std::span< const double > box)
	C++ call site: size-checked view over the raw FFI force().
virtual void	setFixedMask (long nAtoms, const double *isFixed)
	Optional frozen-atom mask (nAtoms*3, 1.0 = fixed).
std::tuple< double, AtomMatrix >	get_ef (const AtomMatrix &pos, const VectorXi &atmnrs, const Matrix3d &box)
PotType	getType () const
virtual double	finiteCutoff () const noexcept
	Finite interaction range in position length units.
virtual bool	isSurrogate () const noexcept
	Whether this is a surrogate (GP) potential.
virtual bool	requiresIsolatedMoleculeLayout () const noexcept
	True for molecular QM / non-PBC backends (NWChem socket, ASE ORCA/NWChem, …).
virtual bool	isThreadSafe () const noexcept
	Whether this potential's force() can be called from multiple threads on the SAME instance.
virtual unsigned	layoutFlags () const noexcept
virtual bool	isSharedInstanceThreadSafe () const noexcept
	Conservative gate for sharing one Potential instance across threads.
virtual bool	needsPerImageInstance () const noexcept
	Whether NEB should create separate Potential instances per image for true parallel force evaluation.
virtual std::shared_ptr< Potential >	clonePotential () const
	Independent instance that does not reload from disk.
virtual bool	supportsBatchEvaluation () const noexcept
	Whether this potential supports batched evaluation of N systems in a single call.
virtual bool	computesStress () const noexcept
	True when force() leaves a Cauchy stress that cauchyStress() can read until the next force() on this instance.
virtual Matrix3d	cauchyStress () const
	Cauchy stress in eV/Angstrom^3.
virtual void	forceBatchOwned (long nSystems, long nAtoms, const double *const *positions, const int *const *atomicNrs, double *const *forces, double *energies, double *variances, const double *const *boxes, const long *owners)
	Evaluate forces for N systems in a single call.
virtual void	forceBatch (long nSystems, long nAtoms, const double *const *positions, const int *const *atomicNrs, double *const *forces, double *energies, double *variances, const double *const *boxes)

Private Member Functions
void	passToSystem (long N, const double *R, const int *atomicNrs, const double *box)
void	recieveFromSystem (long N, double *F, double *U)

Private Attributes
std::string	engine
std::string	model
std::string	forcefield
std::string	xc

Additional Inherited Members
Public Types inherited from eonc::Potential
enum class	PotLayout : unsigned { InProcess = 1u << 0 , NeedsWorkingDirectory = 1u << 1 , Subprocess = 1u << 2 }
	How the pot is executed. Combine with bitwise or. More...
Public Attributes inherited from eonc::Potential
std::atomic< size_t >	forceCallCounter
Protected Attributes inherited from eonc::Potential
PotType	ptype

Detailed Description

Definition at line 19 of file AMS_IO.h.

Constructor & Destructor Documentation

AMS_IO()

AMS_IO::AMS_IO

(

const eonc::Parameters &

p

)

Definition at line 51 of file AMS_IO.cpp.

    : eonc::Potential(eonc::PotType::AMS_IO, p) {
  engine = p.ams_options().engine;
  forcefield = p.ams_options().forcefield;
  model = p.ams_options().model;
  xc = p.ams_options().xc;
  return;
}

~AMS_IO()

AMS_IO::~AMS_IO

(

)

Definition at line 62 of file AMS_IO.cpp.

{ cleanMemory(); }

Member Function Documentation

cleanMemory()

void AMS_IO::cleanMemory

(

void

)

Definition at line 60 of file AMS_IO.cpp.

{ return; }

force()

void AMS_IO::force ( long N, const double * R, const int * atomicNrs, double * F, double * U, double * variance, const double * box )

virtual

Implements eonc::Potential.

Definition at line 75 of file AMS_IO.cpp.

                                                                   {
  variance = nullptr;
  passToSystem(N, R, atomicNrs, box);
  // Run a single point AMS_IO calculation and write the results into
  // ams_output
  eonc::pot::runOrThrow(kRunCommand);
  recieveFromSystem(N, F, U);
  return;
}

initialize()

void AMS_IO::initialize ( )

inline

Definition at line 24 of file AMS_IO.h.

{};

passToSystem()

void AMS_IO::passToSystem ( long N, const double * R, const int * atomicNrs, const double * box )

private

Definition at line 86 of file AMS_IO.cpp.

{
  std::ofstream out(kRunScript, std::ios::trunc);
  if (!out) {
    throw std::runtime_error(
        std::format("Could not open {} for writing", kRunScript));
  }
 
  out << "#!/bin/sh\n";
  out << "ams --delete-old-results <<eor\n";
  out << "Task SinglePoint\n";
  out << "System\n";
  out << " Atoms\n";
  for (long i = 0; i < N; i++) {
    out << std::format("  {}\t{:.19f}\t{:.19f}\t{:.19f}\n",
                       symbol_for_z(atomicNrs[i]), R[i * 3 + 0], R[i * 3 + 1],
                       R[i * 3 + 2]);
  }
  out << " End\n";
  if (!model.empty() || !forcefield.empty()) {
    out << " Lattice\n";
    for (int i = 0; i < 3; i++) {
      out << std::format("  {:.19f}\t{:.19f}\t{:.19f}\n", box[i * 3 + 0],
                         box[i * 3 + 1], box[i * 3 + 2]);
    }
    out << " End\n";
  }
  out << "End\n";
  out << std::format("Engine {}\n", engine);
  if (!forcefield.empty()) {
    out << std::format("     Forcefield {}\n", forcefield);
  }
  if (!model.empty()) {
    out << std::format("     Model {}\n", model);
  }
  if (!xc.empty()) {
    out << std::format("xc {}\n", xc);
    // basis set not specified (default = DZ)
    out << std::format("     hybrid {}\n", xc);
    out << "end\n";
  }
  out << "EndEngine\n";
  out << "Properties\n";
  out << " Gradients\n";
  out << "End\n";
  out << "eor";
 
  out.close();
  if (!out) {
    throw std::runtime_error(
        std::format("Could not write the AMS input to {}", kRunScript));
  }
 
#ifndef _WIN32
  if (chmod(kRunScript, S_IRWXU) != 0) {
    throw std::runtime_error(
        std::format("Could not make {} executable", kRunScript));
  }
#endif
  return;
}

recieveFromSystem()

void AMS_IO::recieveFromSystem ( long N, double * F, double * U )

private

Definition at line 150 of file AMS_IO.cpp.

                                                           {
  std::ifstream in(kOutputFile);
  if (!in) {
    throw std::runtime_error(
        std::format("Could not open {}; AMS left no output", kOutputFile));
  }
 
  bool haveEnergy = false;
  bool haveGradients = false;
  std::string line;
 
  while (std::getline(in, line)) {
 
    if (line == kEnergyMarker) { // Finding the Energy in the output file
      std::string junk;
      if (!(in >> junk >> junk >> junk >> *U)) {
        throw std::runtime_error(
            std::format("Could not read the energy following \"{}\" in {}",
                        kEnergyMarker, kOutputFile));
      }
      *U = *U * kHartreeToEv; // Energy in hartree to eV
      haveEnergy = true;
    }
 
    if (line == kGradientMarker) { // Finding the forces
      double index;
      std::string symbol;
      for (long i = 0; i < N; i++) {
        if (!(in >> index >> symbol >> F[i * 3 + 0] >> F[i * 3 + 1] >>
              F[i * 3 + 2])) {
          throw std::runtime_error(
              std::format("{} holds gradients for {} atoms, expected {}",
                          kOutputFile, i, N));
        }
        // AMS_IO gives gradients, not forces, hence the change.
        F[i * 3 + 0] = -F[i * 3 + 0];
        F[i * 3 + 1] = -F[i * 3 + 1];
        F[i * 3 + 2] = -F[i * 3 + 2];
      }
      haveGradients = true;
    }
  }
 
  if (!haveEnergy || !haveGradients) {
    throw std::runtime_error(std::format(
        "{} holds no {}", kOutputFile,
        !haveEnergy
            ? (!haveGradients ? "energy and no gradient block" : "energy")
            : "gradient block"));
  }
 
  for (long i = 0; i < 3 * N; i++) {
    F[i] = F[i] * kHartreeBohrToEvAngstrom; // Forces from hartree/bohr to
                                            // eV/Angstrom
  }
  return;
}

Member Data Documentation

engine

std::string AMS_IO::engine

private

Definition at line 35 of file AMS_IO.h.

forcefield

std::string AMS_IO::forcefield

private

Definition at line 37 of file AMS_IO.h.

model

std::string AMS_IO::model

private

Definition at line 36 of file AMS_IO.h.

xc

std::string AMS_IO::xc

private

Definition at line 38 of file AMS_IO.h.

---

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

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