AMS Class Reference

#include <AMS.h>

Inheritance diagram for AMS:

Public Member Functions
	AMS (const Parameters &p)
	~AMS ()
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)
	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	isThreadSafe () const noexcept
	Whether this potential's force() can be called from multiple threads on the SAME instance.
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 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.

Private Member Functions
void	passToSystem (long N, const double *R, const int *atomicNrs, const double *box)
	< Creates a script to run AMS
void	smallSys (long N, const double *R, const int *atomicNrs, const double *box)
	Flush, close and make the run script executable.
void	finishRunScript (std::ofstream &out)
	Copy 3N gradient components into the caller's force array.
void	copyForces (long N, const std::vector< double > &frc, double *F)
void	switchjob ()
void	write_restart ()
std::string	generate_run (const Parameters &p)
void	runAMS ()
void	updateCoord (long N, const double *R)
void	extract_rkf (long N, std::string key)
double	extract_scalar_rkf (std::string key)
std::vector< double >	extract_cartesian_rkf (std::string key)
bool	validate_order ()
std::string	readFile (std::filesystem::path path)
void	recieveFromSystem (long N, double *F, double *U)

Private Attributes
std::string	engine
std::string	forcefield
std::string	model
std::string	xc
std::string	resources
std::string	basis
std::string	engine_setup
std::string	engine_lower
boost::process::native_environment	nativenv
int	amsevals {0}
bool	first_run
bool	can_restart
std::string	cjob
std::string	pjob
std::ofstream	restartFrom
const double	forceConversion
const double	energyConversion = 27.2114
const double	lengthConversion = 1.88973

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 33 of file AMS.h.

Constructor & Destructor Documentation

AMS()

AMS::AMS

(

const Parameters &

p

)

Definition at line 24 of file AMS.cpp.

    : Potential(PotType::AMS, p) {
  // Get the values from the configuration
  // All the parameter values convert to lowercase in generate_run
  this->engine = p.ams_options.engine;
  this->forcefield = p.ams_options.forcefield;
  this->model = p.ams_options.model;
  this->xc = p.ams_options.xc;
  this->resources = p.ams_options.resources;
  this->basis = p.ams_options.basis;
  this->engine_setup = generate_run(p);
  // Environment
  // TODO: Add more checks for how this can be set
  if (p.ams_options.env.amshome.empty() &&
      p.ams_options.env.scm_tmpdir.empty() &&
      p.ams_options.env.scmlicense.empty() &&
      p.ams_options.env.scm_pythondir.empty() &&
      p.ams_options.env.amsbin.empty() &&
      p.ams_options.env.amsresources.empty()) {
    nativenv = boost::this_process::environment();
  } else {
    nativenv = boost::this_process::environment();
    // Some of these can derive from the others
    nativenv["AMSHOME"] = p.ams_options.env.amshome;
    nativenv["SCM_TMPDIR"] = p.ams_options.env.scm_tmpdir;
    nativenv["SCMLICENSE"] = p.ams_options.env.scmlicense;
    nativenv["SCM_PYTHONDIR"] = p.ams_options.env.scm_pythondir;
    nativenv["AMSBIN"] = p.ams_options.env.amsbin;
    nativenv["AMSRESOURCES"] = p.ams_options.env.amsresources;
    nativenv["PATH"] += p.ams_options.env.amsbin;
  }
  // Do not pass "" in the config files
  // std::cout<<nativenv["PATH"].to_string()<<std::endl;
  amsevals = 0;
  // TODO: Optimize and reuse existing files Currently each Matter will
  // recreate the folders It should instead figure out if results exist and
  // use them
  this->first_run = true;
  // Determine if the engine supports restarts
  if (engine == "MOPAC") {
    this->can_restart = false;
    this->cjob = "amsResults";
    this->pjob = "amsResults";
  } else {
    this->can_restart = true;
    this->cjob = "firstRun";
    this->pjob = "secondRun";
  }
  return;
}

~AMS()

AMS::~AMS

(

)

Definition at line 77 of file AMS.cpp.

{ cleanMemory(); }

Member Function Documentation

cleanMemory()

void AMS::cleanMemory

(

void

)

Definition at line 75 of file AMS.cpp.

{ return; }

copyForces()

void AMS::copyForces ( long N, const std::vector< double > & frc, double * F )

private

Definition at line 376 of file AMS.cpp.

                    {
    throw std::runtime_error("Could not write the restart block to "
                             "myrestart.in");
  }
  return;
}
 
void AMS::copyForces(long N, const std::vector<double> &frc, double *F) {

extract_cartesian_rkf()

std::vector< double > AMS::extract_cartesian_rkf ( std::string key )

private

Definition at line 211 of file AMS.cpp.

                                                          {
  std::string execString;
  std::vector<std::string> execDat, innerDat;
  boost::asio::io_context rkf;
  std::future<std::string> rkf_out_future, rkf_err_future;
  std::string rkfout, rkferr;
  double felem, x;
  std::vector<double> extracted;
  execString = std::format("dmpkf {}.results/{}.rkf AMSResults%{}", this->cjob,
                           this->engine_lower, key);
  // std::cout << execString << "\n";
 
  // Extract
  bp::child c(execString, nativenv,         // execute with the environment
              bp::std_in.close(),           // no input
              bp::std_out > rkf_out_future, // STDOUT
              bp::std_err > rkf_err_future, // STDERR
              rkf);
 
  rkf.run(); // this blocks until the end of the command
  // Populate the strings
  rkfout = rkf_out_future.get();
  rkferr = rkf_err_future.get();
 
  if (rkferr.find("ERROR") != std::string::npos) {
    throw std::runtime_error(std::format(
        "\n AMS error while extracting {}, got:\n {}", key, rkferr));
  } else {
    // std::cout << "Extracting " << key << std::endl;
  }
 
  execDat = absl::StrSplit(rkfout, '\n');
  // Assume gradients or some other x y z property
  for (int i = 3; i < execDat.size(); i++) {
    // There exist one per atom, the number of which equals N
    // The first three lines hold the header files as before
    std::vector<std::string> strrow = absl::StrSplit(execDat[i], ' ');
    for (auto elem : strrow) {
      // This loop uses an auto variable since some of the elements of strrow
      // often evaluate to ' '
      // TODO: Optimize, perhaps with a regex
      // [0] = ""
      // [1] = ""
      // [2] = ""
      // [3] = "0.798885933949825835E-004"
      // [4] = ""
      // [5] = "-0.755400038198822616E-004"
      // [6] = ""
      // [7] = ""
      // [8] = "0.457005740252359742E-004"
      if (!elem.empty() && absl::SimpleAtod(elem, &x)) {
        felem = x * this->forceConversion;
        // std::cout << std::format(
        //     "\n Gradient element={:.4f} Hartree/Bohr from AMS\n Force "
        //     "element={:.4f} eV/Angstrom\n", x, felem);
        extracted.emplace_back(felem);
      }
    }
  }
  // // Debug
  // int counter = 0;
  // for (int a = 0; a < N * 3; a++) {
  //   std::cout << std::format("{:.25e} ", forces[a]);
  //   counter++;
  //   if (counter % 3 == 0) {
  //     std::cout << std::endl;
  //   }
  // }
  return extracted;
}

extract_rkf()

void AMS::extract_rkf ( long N, std::string key )

private

extract_scalar_rkf()

double AMS::extract_scalar_rkf ( std::string key )

private

Definition at line 152 of file AMS.cpp.

                                            {
  // The logic here handles the extraction asynchronously, as we lack
  // interest in processing this output line by line, and would prefer to
  // have it all in one place
  std::string execString;
  std::vector<std::string> execDat;
  boost::asio::io_context rkf;
  std::future<std::string> rkf_out_future, rkf_err_future;
  std::string rkfout, rkferr;
  double xval, x;
  std::vector<double> extracted;
  execString = std::format("dmpkf {}.results/{}.rkf AMSResults%{}", this->cjob,
                           this->engine_lower, key);
  // std::cout << execString << "\n";
  // Extract
  bp::child c(execString, nativenv,         // execute with the environment
              bp::std_in.close(),           // no input
              bp::std_out > rkf_out_future, // STDOUT
              bp::std_err > rkf_err_future, // STDERR
              rkf);
 
  rkf.run(); // this blocks until the end of the command
  // Populate the strings
  rkfout = rkf_out_future.get();
  rkferr = rkf_err_future.get();
  if (rkferr.find("ERROR") != std::string::npos) {
    throw std::runtime_error(std::format(
        "\n AMS error while extracting {}, got:\n {}", key, rkferr));
  } else {
    // std::cout << "Extracting " << key << std::endl;
  }
 
  execDat = absl::StrSplit(rkfout, '\n');
  // Is energy or some other scalar property
  // First 3 lines hold the headers
  // [0] = "AMSResults                       "
  // [1] = "Energy                           "
  // [2] = "         1         1         2"
  // [3] = "   0.135012547958282714E+000"
  // [4] = ""
  if (execDat.size() < 4) {
    throw std::runtime_error(
        std::format("\n AMS returned {} lines for {}, too few to hold a value",
                    execDat.size(), key));
  }
  if (absl::SimpleAtod(execDat[3], &x)) {
    xval = x * this->energyConversion;
    // std::cout << std::format(
    //     "\n Got {:.4f} Hartree from AMS and converted to {:.4f} eV\n", x,
    //     xval);
    return xval;
  } else {
    throw std::runtime_error(
        std::format("\n Expected {}, got {} instead", key, execDat[3]));
  }
  // Never reach here
  throw std::runtime_error("Generic AMS dmpkf scalar error \n");
}

finishRunScript()

void AMS::finishRunScript ( std::ofstream & out )

private

Copy 3N gradient components into the caller's force array.

Definition at line 499 of file AMS.cpp.

force()

void AMS::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 389 of file AMS.cpp.

                                                  {
    throw std::runtime_error(
        std::format("\n AMS returned {} gradient components, expected {}",
                    frc.size(), 3 * N));
  }
  for (long i = 0; i < 3 * N; i++) {
    F[i] = frc[i];
  }
}
 
void AMS::force(long N, const double *R, const int *atomicNrs, double *F,
                double *U, double *variance, const double *box) {
  variance = nullptr;
  if (not can_restart or first_run) {
    // std::cout << std::format("\nCAN_RESTART:{}  FIRST_RUN:{}\n", can_restart,
    // first_run); This holds true for all engines with no restart Also if an
    // engine supports being restarted, the first run needs this
    passToSystem(N, R, atomicNrs, box);
    runAMS();
    copyForces(N, extract_cartesian_rkf("Gradients"), F);
    *U = extract_scalar_rkf("Energy");
    // Update, will still not matter for those without restarts
    if (can_restart) {
      first_run = false;
      // We need the "previous job" to pre-populate
      // clang-format off
      // std::cout<<std::format("\nMoving {} to {} before switching during the first job\n", cjob, pjob);
      const auto copyOptions = std::filesystem::copy_options::overwrite_existing
                             | std::filesystem::copy_options::recursive
                             ;
      // clang-format on
      std::filesystem::copy(std::format("./{}.results/", cjob),
                            std::format("./{}.results/", pjob), copyOptions);
    }
    return;
  } else {
    // std::cout << std::format("\nCAN_RESTART:{}  FIRST_RUN:{}\n", can_restart,
    // first_run);
    smallSys(N, R, atomicNrs, box); // writes run_AMS.sh

generate_run()

std::string AMS::generate_run ( const Parameters & p )

private

Definition at line 511 of file AMS.cpp.

            {
    throw std::runtime_error(
        std::format("Could not write the AMS input to {}", kRunScript));
  }
  if (chmod(kRunScript, S_IRWXU) != 0) {
    throw std::runtime_error(
        std::format("Could not make {} executable", kRunScript));
  }
}
 
std::string AMS::generate_run(const Parameters &p) {
  std::string engine_block; // Shadows the class variable
  // TODO: Use args everywhere, cleaner logic
  // Ensure capitals and existence
  engine.empty()
      ? throw std::runtime_error("AMS Engine is required \n")
      : std::transform(engine.begin(), engine.end(), engine.begin(), ::toupper);
  // engine functions uniquely, it serves as a filename, so we store
  // engine_lower as a lowercase version too
  engine_lower = engine;
  std::transform(engine.begin(), engine.end(), engine_lower.begin(), ::tolower);
  // Prepare the block
  if (engine == "MOPAC") {
    model.empty()
        ? throw std::runtime_error("MOPAC needs a model\n")
        : std::transform(model.begin(), model.end(), model.begin(), ::toupper);
    std::string engine_formatter = R"(
 Engine {}
  Model {}
 EndEngine
)";
    engine_block = std::format(engine_formatter, engine, model);
    return engine_block;
  } else if (engine == "ADF" || engine == "BAND") {
    basis.empty()
        ? throw std::runtime_error("ADF/BAND need a basis\n")
        : std::transform(basis.begin(), basis.end(), basis.begin(), ::toupper);
    xc.empty() ? throw std::runtime_error("ADF/BAND need a functional\n")
               : std::transform(xc.begin(), xc.end(), xc.begin(), ::toupper);
    std::string engine_formatter = R"(
   Engine {}
     Basis
       Type {}
     End
 
     XC
       {}
     End
   EndEngine
  )";
    engine_block = std::format(engine_formatter, engine, basis, xc);

initialize()

void AMS::initialize ( )

inline

Definition at line 38 of file AMS.h.

{};

passToSystem()

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

private

< Creates a script to run AMS

Definition at line 430 of file AMS.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 << std::format("export AMS_JOBNAME={}\n", cjob);
  out << "$AMSBIN/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",
                       atomicNumber2symbol(atomicNrs[i]), R[i * 3 + 0],
                       R[i * 3 + 1], R[i * 3 + 2]);
  }
  out << " End\n";
  if (not model.empty() || not 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 << engine_setup;

readFile()

std::string AMS::readFile ( std::filesystem::path path )

private

recieveFromSystem()

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

private

runAMS()

void AMS::runAMS ( )

private

Definition at line 122 of file AMS.cpp.

                 {
  boost::asio::io_context amsRun;
  std::future<std::string> run_out_future, run_err_future;
  std::string runout, runerr;
  if (chmod(kRunScript, S_IRWXU) != 0) {
    throw std::runtime_error(
        std::format("Could not make {} executable", kRunScript));
  }
  nativenv["AMS_JOBNAME"] = cjob;
  // assert(validate_order() == true);         // TODO: Debug only
  bp::child c(std::string(kRunScript),
              nativenv,                     // set the input
              bp::std_in.close(),           // no input
              bp::std_out > run_out_future, // STDOUT
              bp::std_err > run_err_future, // STDERR
              amsRun);
  amsRun.run();
  runout = run_out_future.get();
  runerr = run_err_future.get();
  if (runerr.find("ERROR") != std::string::npos) {
    bp::spawn("cat myrestart.in");
    bp::spawn("cat run_AMS.sh");
    throw std::runtime_error("\n AMS error while running");
  } else {
    this->amsevals = amsevals + 1;
    // std::cout << "Run completed normally" << std::endl;
    // std::cerr << "NORMAL TERMINATION\n";
  }
}

smallSys()

void AMS::smallSys ( long N, const double * R, const int * atomicNrs, const double * box )

private

Flush, close and make the run script executable.

Definition at line 474 of file AMS.cpp.

                                     {
    out << "@include myrestart.in\n";
  }
  out << "eor";
 
  finishRunScript(out);
  return;
}
 
void AMS::smallSys(long N, const double *R, const int *atomicNrs,
                   const double *box)
// Creating the truncated input file that the AMS driver reads
{
  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 << std::format("export AMS_JOBNAME={}\n", cjob);
  out << "$AMSBIN/ams --delete-old-results <<eor\n";

switchjob()

void AMS::switchjob ( )

private

Definition at line 344 of file AMS.cpp.

                    {
  std::string tmp;
  // std::cout << std::format("\nEntered Switch:\nCurrent:{}, Previous:{}\n",
  // cjob, pjob);
  tmp = this->cjob;
  this->cjob = this->pjob;
  this->pjob = tmp;
  // std::cout << std::format("\nSwitched\n Current:{}, Previous:{}\n", cjob,
  // pjob);
}

updateCoord()

void AMS::updateCoord ( long N, const double * R )

private

Definition at line 282 of file AMS.cpp.

                                             {
  // The logic used here requires us to update the PREVIOUS job, since that
  // functions as the one from which the calculation restarts
  // Only the third line presents vague complexity
  // https://www.scm.com/doc/Scripting/Commandline_Tools/KF_command_line_utilities.html
  std::ofstream updCoord;
  std::string execString, coordDump, newCoord;
  std::vector<std::string> execDat;
  boost::asio::io_context coordio;
  std::future<std::string> err, rdump;
  std::vector<double> gradients;
  // Prep new run
  // Get the previous run's coordinates
  execString = std::format("dmpkf {}.results/ams.rkf Molecule%Coords", pjob);
  // std::cout << execString << "\n";
  // Store Coordinates
  // TODO: Simplify this, we only need the first few lines
  bp::child cprog(execString, nativenv, bp::std_in.close(), bp::std_out > rdump,
                  bp::std_err > err, coordio);
  coordio.run();
  execDat = absl::StrSplit(rdump.get(), '\n');
  // Get the first three lines
  int counter = 0;
  for (auto j : execDat) {
    if (counter >= 3) {
      break;
    } else {
      absl::StrAppend(&newCoord, j, "\n");
    }
    counter++;
  }
  // Put the rest of the coordinates
  counter = 0;
  for (int a = 0; a < N * 3; a++) {
    absl::StrAppend(&newCoord, (R[a] * lengthConversion), "  ");
    counter++;
    if (counter % 3 == 0) {
      absl::StrAppend(&newCoord, "\n");
    }
  }
  coordDump = "#!/bin/sh\n udmpkf ";
  absl::StrAppend(&coordDump, pjob, ".results/ams.rkf <<EOF\n", newCoord,
                  "EOF");
  // std::cout << coordDump;
  updCoord.open("updCoord.sh", std::ios::trunc);
  if (!updCoord) {
    throw std::runtime_error("Could not open updCoord.sh for writing");
  }
  updCoord << coordDump;
  updCoord.close();
  if (!updCoord) {
    throw std::runtime_error("Could not write the coordinates to updCoord.sh");
  }
  // bp::spawn("chmod +x updCoord.sh");
  if (chmod("updCoord.sh", S_IRWXU) != 0) {
    throw std::runtime_error("Could not make updCoord.sh executable");
  }
  bp::child cuprog("updCoord.sh", nativenv, bp::std_err > bp::null);
  cuprog.wait();
  return;
}

validate_order()

bool AMS::validate_order ( )

private

write_restart()

void AMS::write_restart ( )

private

Definition at line 355 of file AMS.cpp.

                        {
  std::string restart_formatter;
  if (can_restart) {
    restart_formatter = R"(
   EngineRestart {0}.results/{1}.rkf
   LoadSystem
    File {0}.results/ams.rkf
    Section Molecule
   End
  )";
  } else {
    restart_formatter = R"(
   LoadSystem
    File {0}.results/ams.rkf
    Section Molecule
   End
  )";
  }
  std::string restart_data = std::format(restart_formatter, pjob, engine_lower);
  restartFrom.open("myrestart.in", std::ios::trunc);

Member Data Documentation

amsevals

int AMS::amsevals {0}

private

Definition at line 63 of file AMS.h.

{0};

basis

std::string AMS::basis

private

Definition at line 57 of file AMS.h.

can_restart

bool AMS::can_restart

private

Definition at line 64 of file AMS.h.

cjob

std::string AMS::cjob

private

Definition at line 65 of file AMS.h.

energyConversion

const double AMS::energyConversion = 27.2114

private

Definition at line 70 of file AMS.h.

engine

std::string AMS::engine

private

Definition at line 57 of file AMS.h.

engine_lower

std::string AMS::engine_lower

private

Definition at line 58 of file AMS.h.

engine_setup

std::string AMS::engine_setup

private

Definition at line 58 of file AMS.h.

first_run

bool AMS::first_run

private

Definition at line 64 of file AMS.h.

forceConversion

const double AMS::forceConversion

private

Initial value:

                         =
-51.4220862

Definition at line 67 of file AMS.h.

forcefield

std::string AMS::forcefield

private

Definition at line 57 of file AMS.h.

lengthConversion

const double AMS::lengthConversion = 1.88973

private

Definition at line 71 of file AMS.h.

model

std::string AMS::model

private

Definition at line 57 of file AMS.h.

nativenv

boost::process::native_environment AMS::nativenv

private

Definition at line 62 of file AMS.h.

pjob

std::string AMS::pjob

private

Definition at line 65 of file AMS.h.

resources

std::string AMS::resources

private

Definition at line 57 of file AMS.h.

restartFrom

std::ofstream AMS::restartFrom

private

Definition at line 66 of file AMS.h.

xc

std::string AMS::xc

private

Definition at line 57 of file AMS.h.

---

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

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