#include <AMS.h>

Inheritance diagram for AMS:

Public Member Functions
	AMS (const eonc::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)
	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)
	< 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 eonc::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)
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 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 33 of file AMS.h.

Constructor & Destructor Documentation

◆ AMS()

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

Definition at line 29 of file AMS.cpp.

    : eonc::Potential(eonc::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
  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 81 of file AMS.cpp.

81{ cleanMemory(); }

AMS::cleanMemory

void cleanMemory(void)

Definition AMS.cpp:79

Member Function Documentation

◆ cleanMemory()

void AMS::cleanMemory ( void )

Definition at line 79 of file AMS.cpp.

79{ return; }

◆ copyForces()

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

private

Definition at line 321 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 177 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);
 
  // 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));
  }
 
  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;
        extracted.emplace_back(felem);
      }
    }
  }
  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 124 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);
  // 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));
  }
 
  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;
    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 440 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 334 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) {
    // 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
      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 {
    smallSys(N, R, atomicNrs, box); // writes run_AMS.sh

◆ generate_run()

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

private

Definition at line 452 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 eonc::Parameters &p) {
  std::string engine_block; // Shadows the class variable
  // TODO: Use args everywhere, cleaner logic
  // Ensure capitals and existence
  if (engine.empty()) {
    throw std::runtime_error("AMS Engine is required \n");
  }
  std::ranges::transform(engine, engine.begin(), [](unsigned char c) {
    return static_cast<char>(std::toupper(c));
  });
  // engine functions uniquely, it serves as a filename, so we store
  // engine_lower as a lowercase version too
  engine_lower = engine;
  std::ranges::transform(engine, engine_lower.begin(), [](unsigned char c) {
    return static_cast<char>(std::tolower(c));
  });
  // Prepare the block
  if (engine == "MOPAC") {
    if (model.empty()) {
      throw std::runtime_error("MOPAC needs a model\n");
    }
    std::ranges::transform(model, model.begin(), [](unsigned char c) {
      return static_cast<char>(std::toupper(c));
    });
    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") {
    if (basis.empty()) {
      throw std::runtime_error("ADF/BAND need a basis\n");
    }
    std::ranges::transform(basis, basis.begin(), [](unsigned char c) {
      return static_cast<char>(std::toupper(c));
    });
    if (xc.empty()) {
      throw std::runtime_error("ADF/BAND need a functional\n");
    }
    std::ranges::transform(xc, xc.begin(), [](unsigned char c) {
      return static_cast<char>(std::toupper(c));
    });
    std::string engine_formatter = R"(
   Engine {}
     Basis
       Type {}
     End
 
     XC
       {}
     End
   EndEngine
  )";
    engine_block = std::format(engine_formatter, engine, basis, xc);
    return engine_block;
  } else if (engine == "DFTB") {
    if (resources.empty()) {
      throw std::runtime_error("DFTB need resources\n");
    }
    std::ranges::transform(resources, resources.begin(), [](unsigned char c) {

◆ initialize()

void AMS::initialize ( )

inline

Definition at line 38 of file AMS.h.

38{};

◆ 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 371 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",
                       symbol_for_z(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;

◆ recieveFromSystem()

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

private

◆ runAMS()

void AMS::runAMS ( )

private

Definition at line 97 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;
  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;
  }
}

◆ 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 415 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 293 of file AMS.cpp.

                    {
  std::string tmp;
  tmp = this->cjob;
  this->cjob = this->pjob;
  this->pjob = tmp;
}

◆ updateCoord()

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

private

Definition at line 233 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);
  // 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");
  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;
}

◆ write_restart()

void AMS::write_restart ( )

private

Definition at line 300 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.

63{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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ AMS()

◆ ~AMS()

Member Function Documentation

◆ cleanMemory()

◆ copyForces()

◆ extract_cartesian_rkf()

◆ extract_rkf()

◆ extract_scalar_rkf()

◆ finishRunScript()

◆ force()

◆ generate_run()

◆ initialize()

◆ passToSystem()

◆ recieveFromSystem()

◆ runAMS()

◆ smallSys()

◆ switchjob()

◆ updateCoord()

◆ write_restart()

Member Data Documentation

◆ amsevals

◆ basis

◆ can_restart

◆ cjob

◆ energyConversion

◆ engine

◆ engine_lower

◆ engine_setup

◆ first_run

◆ forceConversion

◆ forcefield

◆ lengthConversion

◆ model

◆ nativenv

◆ pjob

◆ resources

◆ restartFrom

◆ xc