VASP Class Reference

#include <VASP.h>

Inheritance diagram for VASP:

Public Member Functions
	VASP (const eonc::Parameters &p)
	~VASP ()
void	initialize ()
void	cleanMemory ()
void	force (long N, const double *R, const int *atomicNrs, double *F, double *U, double *variance, const double *box) override
bool	isThreadSafe () const noexcept override
	force() writes POSCAR, signals through NEWCAR and waits on FU, all at fixed names in the working directory, so two threads in it swap results.
bool	needsPerImageInstance () const noexcept override
	Every instance drives the one VASP process named by the static vaspPID through the one set of files, so a second instance buys no parallelism.
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 unsigned	layoutFlags () const noexcept
virtual bool	isSharedInstanceThreadSafe () const noexcept
	Conservative gate for sharing one Potential instance across threads.
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)

Static Public Member Functions
static void	removeStaleFiles ()

Private Member Functions
void	writePOSCAR (long N, const double *R, const int *atomicNrs, const double *box)
void	readFU (long N, double *F, double *U)
void	spawnVASP ()
bool	vaspRunning ()

Static Private Member Functions
static void	clearHandshakeFiles ()

Static Private Attributes
static bool	firstRun = true
static long	vaspRunCount = 0
static pid_t	vaspPID = 0

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 16 of file VASP.h.

Constructor & Destructor Documentation

VASP()

VASP::VASP ( const eonc::Parameters & p )

inline

Definition at line 19 of file VASP.h.

: eonc::Potential(p) { vaspRunCount++; }

~VASP()

VASP::~VASP ( )

inline

Definition at line 20 of file VASP.h.

{ cleanMemory(); }

Member Function Documentation

cleanMemory()

void VASP::cleanMemory

(

void

)

Definition at line 126 of file VASP.cpp.

                           {
  vaspRunCount--;
  if (vaspRunCount < 1) {
    // Runs from a destructor, so it reports rather than throws.
    std::ofstream stopcar(kStopCarFile, std::ios::trunc);
    if (!stopcar) {
      EONC_LOG_WARNING("Could not open {} to stop VASP", kStopCarFile);
      return;
    }
    stopcar << "LABORT = .TRUE.\n";
    stopcar.close();
    if (!stopcar) {
      EONC_LOG_WARNING("Could not write {} to stop VASP", kStopCarFile);
    }
  }
  return;
}

clearHandshakeFiles()

void VASP::clearHandshakeFiles ( )

staticprivate

Definition at line 102 of file VASP.cpp.

                               {
  for (const char *name : kHandshakeFiles) {
    std::error_code ec;
    if (std::filesystem::remove(name, ec)) {
      EONC_LOG_INFO("VASP cleared leftover {}", name);
    } else if (ec) {
      EONC_LOG_WARNING("VASP could not clear leftover {}: {}", name,
                       ec.message());
    }
  }
}

force()

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

overridevirtual

Implements eonc::Potential.

Definition at line 219 of file VASP.cpp.

                                                                 {
  if (variance != nullptr) {
    *variance = 0.0;
  }
  writePOSCAR(N, R, atomicNrs, box);
 
  if (!vaspRunning()) {
    spawnVASP();
  }
 
  // access() succeeds the moment VASP creates FU, not when it finishes
  // writing it, so this can observe a partial file. readFU treats a short
  // read as an error rather than absorbing it, which turns the race into a
  // failure instead of wrong forces. Closing it properly needs a completion
  // signal from runvasp.sh, such as writing to a temporary name and renaming
  // it once the write completes.
  while (access(kForceFile, F_OK) == -1) {
    sleep(1);
    vaspRunning();
  }
  readFU(N, F, U);
 
  std::error_code ec;
  if (!std::filesystem::remove(kForceFile, ec) || ec) {
    // Leaving it behind means the next call reads this call's numbers.
    throw std::runtime_error(std::format("Could not remove {}: {}", kForceFile,
                                         ec ? ec.message() : "already gone"));
  }
  vaspRunCount++;
  return;
}

initialize()

void VASP::initialize ( )

inline

Definition at line 21 of file VASP.h.

{};

isThreadSafe()

bool VASP::isThreadSafe ( ) const

inlinenodiscardoverridevirtualnoexcept

force() writes POSCAR, signals through NEWCAR and waits on FU, all at fixed names in the working directory, so two threads in it swap results.

Reimplemented from eonc::Potential.

Definition at line 27 of file VASP.h.

{ return false; }

needsPerImageInstance()

bool VASP::needsPerImageInstance ( ) const

inlinenodiscardoverridevirtualnoexcept

Every instance drives the one VASP process named by the static vaspPID through the one set of files, so a second instance buys no parallelism.

Delete the results and restart files VASP writes into the working directory, so a calculation starts from an empty one.

Destructive, and nothing in the client calls it: a caller invokes it when it means to discard an earlier calculation's output. A caller that means to restart from WAVECAR or CHGCAR must not, and neither must one that wants the earlier OUTCAR. The examples/akmc-vasp-slurm scripts do the same removals in shell, at the point where the user asks for them.

Reimplemented from eonc::Potential.

Definition at line 30 of file VASP.h.

readFU()

void VASP::readFU ( long N, double * F, double * U )

private

Definition at line 312 of file VASP.cpp.

                                              {
  std::ifstream fu(kForceFile);
  if (!fu) {
    throw std::runtime_error(
        std::format("Could not open {}; VASP left no result", kForceFile));
  }
 
  if (!(fu >> *U)) {
    throw std::runtime_error(
        std::format("Could not read the energy from {}", kForceFile));
  }
 
  for (long i = 0; i < N; i++) {
    if (!(fu >> F[i * 3 + 0] >> F[i * 3 + 1] >> F[i * 3 + 2])) {
      throw std::runtime_error(std::format(
          "{} holds forces for {} atoms, expected {}", kForceFile, i, N));
    }
  }
  return;
}

removeStaleFiles()

void VASP::removeStaleFiles ( )

static

Definition at line 114 of file VASP.cpp.

                            {
  for (const char *name : kStaleFiles) {
    std::error_code ec;
    if (std::filesystem::remove(name, ec)) {
      EONC_LOG_INFO("VASP removed leftover {}", name);
    } else if (ec) {
      EONC_LOG_WARNING("VASP could not remove leftover {}: {}", name,
                       ec.message());
    }
  }
}

spawnVASP()

void VASP::spawnVASP ( )

private

Definition at line 144 of file VASP.cpp.

                     {
  // Runs once per client, since vaspPID stays set for the life of the
  // process. The POSCAR eOn just wrote stays, and the first call writes no
  // NEWCAR, so nothing here discards a signal this run has sent.
  clearHandshakeFiles();
 
  // execlp resolves a relative path against whatever directory the process
  // last changed to, which under the MPI dispatcher is not necessarily the
  // one holding the run. Resolve it in the parent, where a failure can still
  // be reported.
  std::error_code ec;
  const std::filesystem::path script =
      std::filesystem::absolute(kVaspScript, ec);
  if (ec) {
    throw std::runtime_error(
        std::format("Could not resolve {}: {}", kVaspScript, ec.message()));
  }
  if (!std::filesystem::exists(script, ec) || ec) {
    throw std::runtime_error(
        std::format("{} does not exist; VASP needs it in the working directory",
                    script.string()));
  }
  const std::string scriptPath = script.string();
 
  if ((vaspPID = fork()) == -1) {
    throw std::runtime_error(
        std::format("error forking for vasp: {}", std::strerror(errno)));
  }
 
  if (vaspPID != 0) {
    setvbuf(stdout, nullptr, _IONBF, 0);
  } else {
    // The child must not throw: that would run the parent's destructors.
    int outFd = open("vaspout", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (outFd == -1) {
      fprintf(stderr, "error opening vaspout: %s\n", strerror(errno));
      _exit(1);
    }
    if (dup2(outFd, 1) == -1 || dup2(outFd, 2) == -1) {
      fprintf(stderr, "error redirecting vasp output: %s\n", strerror(errno));
      _exit(1);
    }
    if (outFd > 2) {
      close(outFd);
    }
    execl(scriptPath.c_str(), scriptPath.c_str(), nullptr);
    // Only reached when the exec failed; _exit keeps the child out of the
    // parent's exit handlers.
    fprintf(stderr, "error spawning vasp: %s\n", strerror(errno));
    _exit(1);
  }
}

vaspRunning()

bool VASP::vaspRunning ( )

private

Remove the files eOn and VASP signal each other through, so a run does not inherit the handshake of one that ended in this directory.

Definition at line 197 of file VASP.cpp.

                       {
  pid_t pid;
  int status;
 
  if (vaspPID == 0) {
    return false;
  }
 
  pid = waitpid(vaspPID, &status, WNOHANG);
  // EINTR means the child is still running. Treating it as death aborts a
  // live VASP job.
  if (pid < 0 && errno == EINTR) {
    return true;
  }
 
  if (pid != 0) {
    throw std::runtime_error("vasp died unexpectedly");
  }
 
  return true;
}

writePOSCAR()

void VASP::writePOSCAR ( long N, const double * R, const int * atomicNrs, const double * box )

private

Definition at line 252 of file VASP.cpp.

                                          {
  // Positions are scaled
  const std::vector<SpeciesRun> runs = speciesRuns(N, atomicNrs);
 
  std::ofstream poscar("POSCAR", std::ios::trunc);
  if (!poscar) {
    throw std::runtime_error("Could not open POSCAR for writing");
  }
 
  // header line (treated as a comment)
  for (const auto &run : runs) {
    poscar << std::format("{} ", run.first);
  }
  poscar << ": Atomic numbers\n";
 
  // boundary box
  poscar << "1.0\n";
  for (int i = 0; i < 3; i++) {
    poscar << std::format(" {:.8f}\t{:.8f}\t{:.8f}\n", box[i * 3 + 0],
                          box[i * 3 + 1], box[i * 3 + 2]);
  }
 
  // the number of atoms of each different atomic type
  for (std::size_t i = 0; i < runs.size(); i++) {
    poscar << std::format("{}{}", runs[i].second,
                          i + 1 == runs.size() ? "\n" : " ");
  }
 
  // coordinates for all atoms
  poscar << "Cartesian\n";
  for (long i = 0; i < N; i++) {
    poscar << std::format("{:.19f}\t{:.19f}\t{:.19f}\t T T T\n", R[i * 3 + 0],
                          R[i * 3 + 1], R[i * 3 + 2]);
  }
 
  poscar.close();
  if (!poscar) {
    throw std::runtime_error("Could not write the structure to POSCAR");
  }
 
  if (firstRun) {
    firstRun = false;
  } else {
    // An empty NEWCAR tells the running VASP that a new POSCAR is ready.
    std::ofstream newcar(kNewCarFile, std::ios::trunc);
    if (!newcar) {
      throw std::runtime_error(
          std::format("Could not open {} to signal VASP", kNewCarFile));
    }
    newcar.close();
    if (!newcar) {
      throw std::runtime_error(
          std::format("Could not write {} to signal VASP", kNewCarFile));
    }
  }
 
  return;
}

Member Data Documentation

firstRun

bool VASP::firstRun = true

staticprivate

Definition at line 53 of file VASP.h.

vaspPID

pid_t VASP::vaspPID = 0

staticprivate

Definition at line 55 of file VASP.h.

vaspRunCount

long VASP::vaspRunCount = 0

staticprivate

Definition at line 54 of file VASP.h.

---

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

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