eonc::ReplicaDynamicsJob Class Reference

Base class for replica dynamics jobs (TAD, SafeHyper). More...

#include <ReplicaDynamicsJob.h>

Inheritance diagram for eonc::ReplicaDynamicsJob:

Classes
struct	PrdClock
	Clamped PRD clock: state_check, record, and buffer length are all >= 1. More...

Public Member Functions
	~ReplicaDynamicsJob () override=default
std::vector< std::string >	run () override
	Virtual run; used solely for dynamic dispatch.
std::shared_ptr< Matter >	runFromMatter (std::shared_ptr< Matter > initial)
	Matter-first entry: seed geometry, skip con2matter load.
	Job (std::unique_ptr< Parameters > parameters, Runtime &rt)
	Borrow: caller keeps Runtime alive (CLI stack / Python Session).
	Job (std::unique_ptr< Parameters > parameters, std::unique_ptr< Runtime > rt)
	Own a Runtime (one-shot makeJob / rvalue).
	Job (std::unique_ptr< Parameters > parameters)
	Own a default-constructed Runtime.
	Job (std::shared_ptr< Potential > potPassed, const Parameters &parameters)
Public Member Functions inherited from eonc::Job
void	adoptRuntime (std::unique_ptr< Runtime > rt)
	Take ownership of a Runtime previously passed as Runtime&.
	Job (std::unique_ptr< Parameters > parameters, Runtime &rt)
	Borrow: caller keeps Runtime alive (CLI stack / Python Session).
	Job (std::unique_ptr< Parameters > parameters, std::unique_ptr< Runtime > rt)
	Own a Runtime (one-shot makeJob / rvalue).
	Job (std::unique_ptr< Parameters > parameters)
	Own a default-constructed Runtime.
	Job (std::shared_ptr< Potential > potPassed, const Parameters &parameters)
virtual	~Job ()=default
JobType	getType ()
PotRegistry &	pots () noexcept
void	releasePotential ()
	Drop the Potential so on_destroyed is recorded before Runtime dies.

Protected Member Functions
bool	checkState (Matter *current, Matter *reactant)
	Minimize a copy of current and compare to reactant.
long	refine (const std::vector< std::shared_ptr< Matter > > &buff, Matter *reactant)
	Binary search for the transition frame in a snapshot buffer.
void	dephase ()
	Dephase the trajectory to ensure thermal independence.
PrdClock	prdClock () const
void	saveData (int status)
	Write results.dat and structure con files.
virtual void	initExtra ()
	Create any extra matter objects needed by the subclass.
virtual int	dynamics ()=0
	The accelerated dynamics loop. Returns status (1 = transition, 0 = none).
virtual void	reportResults ()
	Post-dynamics logging (override for job-specific messages).

Protected Attributes
std::shared_ptr< Matter >	current
std::shared_ptr< Matter >	reactant
std::shared_ptr< Matter >	saddle
std::shared_ptr< Matter >	product
std::shared_ptr< Matter >	finalState
std::shared_ptr< Matter >	finalStateTmp
bool	metaStateFlag {false}
bool	newStateFlag {false}
size_t	minimizeFCalls {0}
size_t	mdFCalls {0}
size_t	dephaseFCalls {0}
size_t	refineFCalls {0}
long	transitionStep {0}
double	time {0.0}
double	minCorrectedTime {1.0e200}
double	transitionTime {0.0}
std::vector< std::string >	returnFiles
eonc::log::Scoped	log
Protected Attributes inherited from eonc::Job
JobType	jtype
Parameters	params
std::unique_ptr< Runtime >	owned_runtime_
	Non-null when this Job owns the composition root (one-shot makeJob).
Runtime *	runtime_
	Always valid: either owned_runtime_.get() or a caller-owned Runtime.
std::shared_ptr< Potential >	pot

Detailed Description

Base class for replica dynamics jobs (TAD, SafeHyper).

Provides shared infrastructure: state checking via minimize-and-compare, binary search refinement of transition times, dephasing, and results I/O. Subclasses implement initExtra() for job-specific matter objects and dynamics() for the accelerated MD loop.

Definition at line 29 of file ReplicaDynamicsJob.h.

Constructor & Destructor Documentation

~ReplicaDynamicsJob()

eonc::ReplicaDynamicsJob::~ReplicaDynamicsJob ( )

overridedefault

Member Function Documentation

checkState()

bool eonc::ReplicaDynamicsJob::checkState ( Matter * current, Matter * reactant )

protected

Minimize a copy of current and compare to reactant.

Returns true if a transition (new state) was detected.

Definition at line 69 of file ReplicaDynamicsJob.cpp.

                                                               {
  Matter tmp(pot, params);
  tmp = *curr;
  tmp.relax(true);
  return !tmp.compare(*react);
}

dephase()

void eonc::ReplicaDynamicsJob::dephase ( )

protected

Dephase the trajectory to ensure thermal independence.

Definition at line 130 of file ReplicaDynamicsJob.cpp.

                                 {
  const double dt = params.dynamics_options().time_step;
  if (!(dt > 0.0)) {
    throw std::invalid_argument(
        "ReplicaDynamicsJob::dephase: time_step must be positive");
  }
  long DephaseSteps =
      static_cast<long>(params.parallel_replica_options().dephase_time / dt);
  Dynamics dephaseDynamics(current.get(), params);
  QUILL_LOG_DEBUG(log, "Dephasing for {:.2f} fs",
                  params.parallel_replica_options().dephase_time *
                      params.constants().timeUnit);
 
  long step = 0, loop = 0;
 
  while (step < DephaseSteps) {
    long dephaseBufferLength = DephaseSteps - step;
    if (dephaseBufferLength < 1) {
      break;
    }
    loop++;
    std::vector<std::shared_ptr<Matter>> dephaseBuffer(dephaseBufferLength);
 
    for (long i = 0; i < dephaseBufferLength; i++) {
      dephaseBuffer[i] = std::make_shared<Matter>(pot, params);
      dephaseDynamics.oneStep();
      *dephaseBuffer[i] = *current;
    }
 
    bool transitionFlag = checkState(current.get(), reactant.get());
 
    if (transitionFlag) {
      if (dephaseBuffer.size() < 2) {
        AtomMatrix velocity = current->getVelocities();
        velocity = velocity * (-1);
        current->setVelocities(velocity);
        continue;
      }
      long dephaseRefineStep = refine(dephaseBuffer, reactant.get());
      QUILL_LOG_DEBUG(log, "loop = {}; dephase refine step = {}", loop,
                      dephaseRefineStep);
      long ts = dephaseRefineStep - 1;
      ts = (ts > 0) ? ts : 0;
      QUILL_LOG_DEBUG(
          log,
          "Dephasing warning: in a new state, inverse the momentum and restart "
          "from step {}",
          step + ts);
      *current = *dephaseBuffer[ts];
      AtomMatrix velocity = current->getVelocities();
      velocity = velocity * (-1);
      current->setVelocities(velocity);
      step = step + ts;
    } else {
      step = step + dephaseBufferLength;
      QUILL_LOG_TRACE_L1(log, "Successful dephasing for {} steps", step);
    }
 
    const long loop_max = params.parallel_replica_options().dephase_loop_max;
    if (loop_max > 0 && loop >= loop_max) {
      QUILL_LOG_DEBUG(
          log,
          "Reach dephase loop maximum, stop dephasing! Dephased for {} steps",
          step);
      break;
    }
    QUILL_LOG_DEBUG(log, "Successfully Dephased for {:.2f} fs",
                    step * params.dynamics_options().time_step *
                        params.constants().timeUnit);
  }
}

dynamics()

virtual int eonc::ReplicaDynamicsJob::dynamics ( )

protectedpure virtual

The accelerated dynamics loop. Returns status (1 = transition, 0 = none).

Implemented in eonc::SafeHyperJob, and eonc::TADJob.

initExtra()

virtual void eonc::ReplicaDynamicsJob::initExtra ( )

inlineprotectedvirtual

Create any extra matter objects needed by the subclass.

Reimplemented in eonc::TADJob.

Definition at line 94 of file ReplicaDynamicsJob.h.

{}

Job() [1/4]

eonc::Job::Job ( std::shared_ptr< Potential > potPassed, const Parameters & parameters )

inline

Definition at line 91 of file Job.h.

      : jtype{parameters.main_options().job},
        params{parameters},
        owned_runtime_{std::make_unique<Runtime>()},
        runtime_{owned_runtime_.get()},
        pot{potPassed} {}

Job() [2/4]

eonc::Job::Job ( std::unique_ptr< Parameters > parameters )

inlineexplicit

Own a default-constructed Runtime.

Definition at line 89 of file Job.h.

      : Job(std::move(parameters), std::make_unique<Runtime>()) {}

Job() [3/4]

eonc::Job::Job ( std::unique_ptr< Parameters > parameters, Runtime & rt )

inline

Borrow: caller keeps Runtime alive (CLI stack / Python Session).

Definition at line 76 of file Job.h.

      : jtype{parameters->main_options().job},
        params{*std::move(parameters)},
        owned_runtime_{},
        runtime_{&rt},
        pot{helpers::makePotential(params.potential_options().potential, params,
                                   rt)} {}

Job() [4/4]

eonc::Job::Job ( std::unique_ptr< Parameters > parameters, std::unique_ptr< Runtime > rt )

inline

Own a Runtime (one-shot makeJob / rvalue).

Definition at line 84 of file Job.h.

      : Job(std::move(parameters), *rt) {
    adoptRuntime(std::move(rt));
  }

prdClock()

ReplicaDynamicsJob::PrdClock eonc::ReplicaDynamicsJob::prdClock ( ) const

protected

Definition at line 76 of file ReplicaDynamicsJob.cpp.

                                                              {
  const double dt = params.dynamics_options().time_step;
  auto to_steps = [&](double interval) -> long {
    if (!(dt > 0.0) || !(interval > 0.0)) {
      return 1;
    }
    const long n = static_cast<long>(interval / dt);
    return n < 1 ? 1 : n;
  };
  PrdClock c;
  c.state_check =
      to_steps(params.parallel_replica_options().state_check_interval);
  c.record = to_steps(params.parallel_replica_options().record_interval);
  if (c.record > c.state_check) {
    c.record = c.state_check;
  }
  c.buffer = c.state_check / c.record;
  if (c.buffer < 1) {
    c.buffer = 1;
  }
  return c;
}

refine()

long eonc::ReplicaDynamicsJob::refine ( const std::vector< std::shared_ptr< Matter > > & buff, Matter * reactant )

protected

Binary search for the transition frame in a snapshot buffer.

Returns an index in [1, buff.size()) so refineStep - 1 is in range.

Definition at line 99 of file ReplicaDynamicsJob.cpp.

                                                                 {
  QUILL_LOG_TRACE_L1(log, "Refining transition time.");
  const long n = static_cast<long>(buff.size());
  if (n <= 1) {
    throw std::runtime_error(
        "ReplicaDynamics refine: need at least two snapshots");
  }
 
  long lo = 0;
  long hi = n - 1;
 
  while ((hi - lo) > 1) {
    long mid = lo + (hi - lo) / 2;
    if (!checkState(buff[static_cast<size_t>(mid)].get(), react)) {
      lo = mid;
    } else {
      hi = mid;
    }
  }
 
  long idx = (lo + hi) / 2 + 1;
  if (idx < 1) {
    idx = 1;
  }
  if (idx >= n) {
    idx = n - 1;
  }
  return idx;
}

reportResults()

virtual void eonc::ReplicaDynamicsJob::reportResults ( )

inlineprotectedvirtual

Post-dynamics logging (override for job-specific messages).

Reimplemented in eonc::SafeHyperJob, and eonc::TADJob.

Definition at line 100 of file ReplicaDynamicsJob.h.

{}

run()

std::vector< std::string > eonc::ReplicaDynamicsJob::run ( )

overridevirtual

Virtual run; used solely for dynamic dispatch.

Implements eonc::Job.

Definition at line 24 of file ReplicaDynamicsJob.cpp.

                                             {
  auto seed = std::make_shared<Matter>(pot, params);
  std::string reactantFilename =
      eonc::helpers::getRelevantFile(params.main_options().conFilename);
  if (!eonc::io::io_ok(seed->con2matter(reactantFilename))) {
    QUILL_LOG_CRITICAL(log, "Failed to load {}", reactantFilename);
    throw std::runtime_error("failed to load " + reactantFilename);
  }
  (void)runFromMatter(std::move(seed));
  return returnFiles;
}

runFromMatter()

std::shared_ptr< Matter > eonc::ReplicaDynamicsJob::runFromMatter

(

std::shared_ptr< Matter >

initial

)

Matter-first entry: seed geometry, skip con2matter load.

Returns final trajectory Matter (current).

Definition at line 37 of file ReplicaDynamicsJob.cpp.

                                                               {
  if (!initial) {
    throw std::runtime_error("runFromMatter: initial Matter is null");
  }
  current = initial;
  current->setPotential(pot);
  reactant = std::make_shared<Matter>(pot, params);
  saddle = std::make_shared<Matter>(pot, params);
  product = std::make_shared<Matter>(pot, params);
  finalState = std::make_shared<Matter>(pot, params);
  finalStateTmp = std::make_shared<Matter>(pot, params);
 
  minimizeFCalls = mdFCalls = refineFCalls = dephaseFCalls = 0;
  time = 0.0;
 
  QUILL_LOG_DEBUG(log, "Minimizing initial reactant");
  {
    eonc::ForceCallTimer timer(minimizeFCalls);
    *reactant = *current;
    reactant->relax();
  }
 
  initExtra();
 
  int status = dynamics();
 
  saveData(status);
  reportResults();
 
  return current;
}

saveData()

void eonc::ReplicaDynamicsJob::saveData ( int status )

protected

Write results.dat and structure con files.

Definition at line 202 of file ReplicaDynamicsJob.cpp.

                                            {
  std::string resultsFilename("results.dat");
  returnFiles.push_back(resultsFilename);
  size_t totalFCalls = minimizeFCalls + mdFCalls + dephaseFCalls + refineFCalls;
 
  {
    std::ofstream out(resultsFilename, std::ios::binary);
    if (out) {
      out << std::format(
          "{} potential_type\n",
          magic_enum::enum_name<PotType>(params.potential_options().potential));
      out << std::format("{} random_seed\n", params.main_options().randomSeed);
      out << std::format("{:f} potential_energy_reactant\n",
                         reactant->getPotentialEnergy());
      out << std::format("{} total_force_calls\n", totalFCalls);
      out << std::format("{} force_calls_dephase\n", dephaseFCalls);
      out << std::format("{} force_calls_dynamics\n", mdFCalls);
      out << std::format("{} force_calls_minimize\n", minimizeFCalls);
      out << std::format("{} force_calls_refine\n", refineFCalls);
      out << std::format("{} transition_found\n", (newStateFlag) ? 1 : 0);
 
      if (newStateFlag) {
        out << std::format("{:e} transition_time_s\n",
                           minCorrectedTime * 1.0e-15 *
                               params.constants().timeUnit);
        out << std::format("{:f} potential_energy_product\n",
                           product->getPotentialEnergy());
        out << std::format("{:f} moved_distance\n",
                           product->distanceTo(*reactant));
      }
 
      out << std::format("{:e} simulation_time_s\n",
                         time * 1.0e-15 * params.constants().timeUnit);
      out << std::format("{:f} speedup\n",
                         time / params.dynamics_options().steps /
                             params.dynamics_options().time_step);
    }
  }
 
  std::string reactantFilename("reactant.con");
  returnFiles.push_back(reactantFilename);
  if (!eonc::io::io_ok(reactant->matter2con(reactantFilename))) {
    QUILL_LOG_ERROR(log, "Failed to write {}", reactantFilename);
  }
 
  if (newStateFlag) {
    std::string productFilename("product.con");
    returnFiles.push_back(productFilename);
    if (!eonc::io::io_ok(product->matter2con(productFilename))) {
      QUILL_LOG_ERROR(log, "Failed to write {}", productFilename);
    }
 
    if (params.parallel_replica_options().refine_transition) {
      std::string saddleFilename("saddle.con");
      returnFiles.push_back(saddleFilename);
      if (!eonc::io::io_ok(saddle->matter2con(saddleFilename))) {
        QUILL_LOG_ERROR(log, "Failed to write {}", saddleFilename);
      }
    }
  }
}

Member Data Documentation

current

std::shared_ptr<Matter> eonc::ReplicaDynamicsJob::current

protected

Definition at line 40 of file ReplicaDynamicsJob.h.

dephaseFCalls

size_t eonc::ReplicaDynamicsJob::dephaseFCalls {0}

protected

Definition at line 54 of file ReplicaDynamicsJob.h.

{0};

finalState

std::shared_ptr<Matter> eonc::ReplicaDynamicsJob::finalState

protected

Definition at line 44 of file ReplicaDynamicsJob.h.

finalStateTmp

std::shared_ptr<Matter> eonc::ReplicaDynamicsJob::finalStateTmp

protected

Definition at line 45 of file ReplicaDynamicsJob.h.

log

eonc::log::Scoped eonc::ReplicaDynamicsJob::log

protected

Definition at line 64 of file ReplicaDynamicsJob.h.

mdFCalls

size_t eonc::ReplicaDynamicsJob::mdFCalls {0}

protected

Definition at line 53 of file ReplicaDynamicsJob.h.

{0};

metaStateFlag

bool eonc::ReplicaDynamicsJob::metaStateFlag {false}

protected

Definition at line 48 of file ReplicaDynamicsJob.h.

{false};

minCorrectedTime

double eonc::ReplicaDynamicsJob::minCorrectedTime {1.0e200}

protected

Definition at line 60 of file ReplicaDynamicsJob.h.

{1.0e200};

minimizeFCalls

size_t eonc::ReplicaDynamicsJob::minimizeFCalls {0}

protected

Definition at line 52 of file ReplicaDynamicsJob.h.

{0};

newStateFlag

bool eonc::ReplicaDynamicsJob::newStateFlag {false}

protected

Definition at line 49 of file ReplicaDynamicsJob.h.

{false};

product

std::shared_ptr<Matter> eonc::ReplicaDynamicsJob::product

protected

Definition at line 43 of file ReplicaDynamicsJob.h.

reactant

std::shared_ptr<Matter> eonc::ReplicaDynamicsJob::reactant

protected

Definition at line 41 of file ReplicaDynamicsJob.h.

refineFCalls

size_t eonc::ReplicaDynamicsJob::refineFCalls {0}

protected

Definition at line 55 of file ReplicaDynamicsJob.h.

{0};

returnFiles

std::vector<std::string> eonc::ReplicaDynamicsJob::returnFiles

protected

Definition at line 63 of file ReplicaDynamicsJob.h.

saddle

std::shared_ptr<Matter> eonc::ReplicaDynamicsJob::saddle

protected

Definition at line 42 of file ReplicaDynamicsJob.h.

time

double eonc::ReplicaDynamicsJob::time {0.0}

protected

Definition at line 59 of file ReplicaDynamicsJob.h.

{0.0};

transitionStep

long eonc::ReplicaDynamicsJob::transitionStep {0}

protected

Definition at line 58 of file ReplicaDynamicsJob.h.

{0};

transitionTime

double eonc::ReplicaDynamicsJob::transitionTime {0.0}

protected

Definition at line 61 of file ReplicaDynamicsJob.h.

{0.0};

---

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

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