eonc::ReplicaDynamicsJob Class Reference

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

#include <ReplicaDynamicsJob.h>

Inheritance diagram for eonc::ReplicaDynamicsJob:

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)
	Job (std::shared_ptr< Potential > potPassed, const Parameters &parameters)
Public Member Functions inherited from eonc::Job
	Job (std::unique_ptr< Parameters > parameters)
	Job (std::shared_ptr< Potential > potPassed, const Parameters &parameters)
virtual	~Job ()=default
JobType	getType ()

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.
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::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 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 67 of file ReplicaDynamicsJob.cpp.

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

dephase()

void ReplicaDynamicsJob::dephase ( )

protected

Dephase the trajectory to ensure thermal independence.

Definition at line 93 of file ReplicaDynamicsJob.cpp.

                                 {
  long DephaseSteps =
      static_cast<long>(params.parallel_replica_options.dephase_time /
                        params.dynamics_options.time_step);
  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;
    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) {
      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);
    }
 
    if ((params.parallel_replica_options.dephase_loop_stop) &&
        (loop > params.parallel_replica_options.dephase_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, eonc::TADJob, SafeHyperJob, and TADJob.

initExtra()

virtual void eonc::ReplicaDynamicsJob::initExtra ( )

inlineprotectedvirtual

Create any extra matter objects needed by the subclass.

Reimplemented in eonc::TADJob, and TADJob.

Definition at line 85 of file ReplicaDynamicsJob.h.

{}

Job() [1/2]

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

inline

Definition at line 63 of file Job.h.

      : jtype{parameters.main_options.job},
        params{parameters},
        pot{potPassed} {}

Job() [2/2]

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

inline

Definition at line 58 of file Job.h.

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

refine()

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

protected

Binary search for the transition frame in a snapshot buffer.

Definition at line 74 of file ReplicaDynamicsJob.cpp.

                                                                 {
  QUILL_LOG_TRACE_L1(log, "Refining transition time.");
 
  long lo = 0;
  long hi = static_cast<long>(buff.size()) - 1;
 
  while ((hi - lo) > 1) {
    long mid = lo + (hi - lo) / 2;
    if (!checkState(buff[mid].get(), react)) {
      lo = mid;
    } else {
      hi = mid;
    }
  }
 
  return (lo + hi) / 2 + 1;
}

reportResults()

virtual void eonc::ReplicaDynamicsJob::reportResults ( )

inlineprotectedvirtual

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

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

Definition at line 91 of file ReplicaDynamicsJob.h.

{}

run()

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

overridevirtual

Virtual run; used solely for dynamic dispatch.

Implements eonc::Job.

Definition at line 22 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 > ReplicaDynamicsJob::runFromMatter

(

std::shared_ptr< Matter >

initial

)

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

Returns final trajectory Matter (current).

Definition at line 35 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 ReplicaDynamicsJob::saveData ( int status )

protected

Write results.dat and structure con files.

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