VASP Class Reference

#include <VASP.h>

Inheritance diagram for VASP:

Public Member Functions
	VASP (const Parameters &p)
	~VASP ()
void	initialize ()
void	cleanMemory (void)
void	force (long N, const double *R, const int *atomicNrs, double *F, double *U, double *variance, const double *box)
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)
	Potential (PotType a_ptype, const Parameters &)
	Potential (const Parameters &a_params)
virtual	~Potential ()
std::tuple< double, AtomMatrix >	get_ef (const AtomMatrix &pos, const VectorXi &atmnrs, const Matrix3d &box)
PotType	getType () const
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	isSharedInstanceThreadSafe () const noexcept
	Conservative gate for sharing one Potential instance across threads.
virtual bool	supportsBatchEvaluation () const noexcept
	Whether this potential supports batched evaluation of 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)
	Evaluate forces for N systems in a single call.

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 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 Parameters & p )

inline

Definition at line 19 of file VASP.h.

      : Potential(p) {
    vaspRunCount++;
  }

~VASP()

VASP::~VASP ( )

inline

Definition at line 23 of file VASP.h.

{ cleanMemory(); }

Member Function Documentation

cleanMemory()

void VASP::cleanMemory

(

void

)

Definition at line 128 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 104 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 )

virtual

Implements eonc::Potential.

Definition at line 215 of file VASP.cpp.

                                                                 {
  variance = nullptr;
  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 24 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 30 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 33 of file VASP.h.

readFU()

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

private

Definition at line 306 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 116 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 146 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) {
    fprintf(stderr, "error forking for vasp: %s\n", strerror(errno));
    exit(1);
  }
 
  if (vaspPID) {
    /* We are the parent */
    setvbuf(stdout, (char *)NULL, _IONBF, 0); // non-buffered output
  } else {
    /* We are the child */
    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);
    }
    execl(scriptPath.c_str(), scriptPath.c_str(), (char *)NULL);
    // 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);
 
  if (pid) {
    fprintf(stderr, "vasp died unexpectedly!\n");
    exit(1);
  }
 
  return true;
}

writePOSCAR()

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

private

Definition at line 246 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 56 of file VASP.h.

vaspPID

pid_t VASP::vaspPID = 0

staticprivate

Definition at line 58 of file VASP.h.

vaspRunCount

long VASP::vaspRunCount = 0

staticprivate

Definition at line 57 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