eonc::SafeHyperJob Class Reference

#include <SafeHyperJob.h>

Inheritance diagram for eonc::SafeHyperJob:

Public Member Functions
	~SafeHyperJob ()=default
Public Member Functions inherited from eonc::ReplicaDynamicsJob
	~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.

Private Member Functions
int	dynamics () override
	The accelerated dynamics loop. Returns status (1 = transition, 0 = none).
void	reportResults () override
	Post-dynamics logging (override for job-specific messages).

Private Attributes
double	transitionPot {0.0}
std::vector< double >	timeBuffer
std::vector< double >	biasBuffer

Additional Inherited Members
Protected Member Functions inherited from eonc::ReplicaDynamicsJob
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.
Protected Attributes inherited from eonc::ReplicaDynamicsJob
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

Definition at line 19 of file SafeHyperJob.h.

Constructor & Destructor Documentation

~SafeHyperJob()

eonc::SafeHyperJob::~SafeHyperJob ( )

default

Member Function Documentation

dynamics()

int eonc::SafeHyperJob::dynamics ( )

overrideprivatevirtual

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

Implements eonc::ReplicaDynamicsJob.

Definition at line 33 of file SafeHyperJob.cpp.

                           {
  bool transitionFlag = false, recordFlag = true, stopFlag = false,
       firstTransitFlag = false;
  long nFreeCoord = reactant->numberOfFreeAtoms() * 3;
  long mdBufferLength;
  long step = 0, refineStep, newStateStep = 0;
  long nCheck = 0, nRecord = 0, nBoost = 0, nState = 0;
  long StateCheckInterval, RecordInterval;
  double kinE, kinT, avgT, varT;
  double kB = params.constants().kB;
  double correctedTime = 0.0, sumCorrectedTime = 0.0, firstTransitionTime = 0.0;
  double Temp = 0.0, sumT = 0.0, sumT2 = 0.0;
  double sumboost = 0.0, boost = 1.0, boostPotential = 0.0;
  double transitionTime_current = 0.0, transitionTime_pre = 0.0;
  AtomMatrix velocity;
 
  minCorrectedTime = 1.0e200;
  const auto clock = prdClock();
  StateCheckInterval = clock.state_check;
  RecordInterval = clock.record;
  Temp = params.main_options().temperature;
  newStateFlag = metaStateFlag = false;
 
  mdBufferLength = clock.buffer;
  std::vector<std::shared_ptr<Matter>> mdBuffer(mdBufferLength);
  for (long i = 0; i < mdBufferLength; i++) {
    mdBuffer[i] = std::make_shared<Matter>(pot, params);
  }
  timeBuffer.resize(mdBufferLength);
  biasBuffer.resize(mdBufferLength);
 
  Dynamics safeHyper(current.get(), params);
  BondBoost bondBoost(current.get(), params);
 
  if (params.hyperdynamics_options().bias_potential ==
      Hyperdynamics::BOND_BOOST) {
    bondBoost.initialize();
    current->setBiasPotential(&bondBoost);
  }
 
  safeHyper.setThermalVelocity();
 
  {
    eonc::ForceCallTimer timer(dephaseFCalls);
    dephase();
  }
 
  QUILL_LOG_DEBUG(
      log,
      "Starting MD run\nTemperature: {:.2f} Kelvin\n"
      "Total Simulation Time: {:.2f} fs\nTime Step: {:.2f} fs\nTotal Steps: {}",
      Temp,
      params.dynamics_options().steps * params.dynamics_options().time_step *
          params.constants().timeUnit,
      params.dynamics_options().time_step * params.constants().timeUnit,
      params.dynamics_options().steps);
  QUILL_LOG_DEBUG(log, "MD buffer length: {}", mdBufferLength);
 
  long tenthSteps = params.dynamics_options().steps / 10;
  if (tenthSteps == 0) {
    tenthSteps = params.dynamics_options().steps;
  }
 
  while (!stopFlag) {
    boost = 1.0;
    boostPotential = 0.0;
    if ((params.hyperdynamics_options().bias_potential ==
         Hyperdynamics::BOND_BOOST) &&
        !newStateFlag) {
      bondBoost.advance();
      boostPotential = bondBoost.boost();
      QUILL_LOG_TRACE_L1(log, "step= {} , boost = {:.5f}", step,
                         boostPotential);
      if (Temp > 0.0 && kB > 0.0) {
        boost = std::exp(boostPotential / kB / Temp);
      } else {
        boost = 1.0;
      }
      if (boost > 1.0) {
        sumboost += boost;
        nBoost++;
      }
    }
    time += params.dynamics_options().time_step * boost;
 
    kinE = current->getKineticEnergy();
    kinT = (2.0 * kinE / nFreeCoord / kB);
    sumT += kinT;
    sumT2 += kinT * kinT;
    QUILL_LOG_TRACE_L1(log, "steps = {:10} temp = {:10.5f}", step, kinT);
 
    safeHyper.oneStep();
    mdFCalls++;
 
    nCheck++;
    step++;
    QUILL_LOG_TRACE_L1(log, "step = {:4}, time = {:10.4f}", step, time);
 
    if (params.parallel_replica_options().refine_transition && recordFlag &&
        !newStateFlag) {
      if (nCheck % RecordInterval == 0) {
        *mdBuffer[nRecord] = *current;
        timeBuffer[nRecord] = time;
        biasBuffer[nRecord] = boostPotential;
        nRecord++;
      }
    }
 
    if ((nCheck == StateCheckInterval) && !newStateFlag) {
      nCheck = 0;
      nRecord = 0;
      {
        eonc::ForceCallTimer timer(minimizeFCalls);
        transitionFlag = checkState(current.get(), reactant.get());
      }
      if (transitionFlag) {
        nState++;
        QUILL_LOG_DEBUG(log, "New State {}: ", nState);
        *finalStateTmp = *current;
        transitionTime = time;
        newStateStep = step;
        transitionStep = newStateStep;
        firstTransitFlag = 1;
      }
    }
 
    if (transitionFlag) {
      QUILL_LOG_TRACE_L1(log, "Refining transition time.");
      const bool can_refine =
          params.parallel_replica_options().refine_transition && nRecord >= 2;
      if (can_refine) {
        eonc::ForceCallTimer timer(refineFCalls);
        refineStep = refine(mdBuffer, reactant.get());
        transitionStep =
            newStateStep - StateCheckInterval + refineStep * RecordInterval;
        transitionTime_current = timeBuffer[static_cast<size_t>(refineStep)];
        transitionPot = biasBuffer[static_cast<size_t>(refineStep)];
        const long prev = refineStep > 0 ? refineStep - 1 : 0;
        *current = *mdBuffer[static_cast<size_t>(prev)];
      } else {
        refineStep = 0;
        transitionTime_current = time;
        transitionPot = boostPotential;
      }
      transitionTime = transitionTime_current - transitionTime_pre;
      transitionTime_pre = transitionTime_current;
      correctedTime =
          (Temp > 0.0 && kB > 0.0)
              ? transitionTime * std::exp((-1) * transitionPot / kB / Temp)
              : transitionTime;
      sumCorrectedTime += correctedTime;
      if (nState == 1) {
        firstTransitionTime = transitionTime;
      }
      velocity = current->getVelocities();
      velocity = velocity * (-1);
      current->setVelocities(velocity);
 
      if (correctedTime < minCorrectedTime) {
        minCorrectedTime = correctedTime;
        if (can_refine) {
          *saddle = *mdBuffer[static_cast<size_t>(refineStep)];
        } else {
          *saddle = *current;
        }
        *finalState = *finalStateTmp;
      }
      QUILL_LOG_DEBUG(log,
                      "tranisitonTime= {:.3e} s, biasPot= {:.3f} eV, "
                      "correctedTime= {:.3e} s, "
                      "sumCorrectedTime= {:.3e} s, minCorTime= {:.3e} s",
                      transitionTime * 1e-15 * params.constants().timeUnit,
                      transitionPot,
                      correctedTime * 1e-15 * params.constants().timeUnit,
                      sumCorrectedTime * 1e-15 * params.constants().timeUnit,
                      minCorrectedTime * 1.0e-15 * params.constants().timeUnit);
 
      transitionFlag = false;
    }
 
    if (firstTransitFlag && sumCorrectedTime > firstTransitionTime) {
      stopFlag = true;
      newStateFlag = true;
    }
 
    if ((step % tenthSteps == 0) || (step == params.dynamics_options().steps)) {
      double maxAtomDistance = current->perAtomNorm(*reactant);
      QUILL_LOG_DEBUG(
          log, "progress: {:.0f}%, max displacement: {:.3f}, step {} / {}",
          static_cast<double>(100.0 * step / params.dynamics_options().steps),
          maxAtomDistance, step, params.dynamics_options().steps);
    }
 
    // Honor dynamics step budget (parity with TADJob); without this the
    // loop only exits on a confidence-gated transition and can run forever.
    if (step >= params.dynamics_options().steps) {
      stopFlag = true;
    }
  }
 
  avgT = sumT / step;
  varT = sumT2 / step - avgT * avgT;
 
  if (nBoost > 0) {
    QUILL_LOG_DEBUG(log,
                    "Temperature : Average = {:.6f} ; Stddev = {:.6f} ; "
                    "Factor = {:.6f}; Boost = {:.6f}",
                    avgT, std::sqrt(varT), varT / avgT / avgT * nFreeCoord / 2,
                    sumboost / nBoost);
  } else {
    QUILL_LOG_DEBUG(
        log,
        "Temperature : Average = {:.6f} ; Stddev = {:.6f} ; Factor = {:.6f}",
        avgT, std::sqrt(varT), varT / avgT / avgT * nFreeCoord / 2);
  }
  if (std::isfinite(avgT) == 0) {
    QUILL_LOG_DEBUG(log, "Infinite average temperature, something went wrong!");
    newStateFlag = false;
  }
 
  // finalState is only filled on transition; keep product valid otherwise.
  current->setBiasPotential(nullptr);
 
  if (newStateFlag && finalState) {
    *product = *finalState;
  } else if (current) {
    *product = *current;
  }
 
  if (newStateFlag) {
    return 1;
  } else {
    return 0;
  }
}

reportResults()

void eonc::SafeHyperJob::reportResults ( )

overrideprivatevirtual

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

Reimplemented from eonc::ReplicaDynamicsJob.

Definition at line 21 of file SafeHyperJob.cpp.

                                 {
  if (newStateFlag) {
    QUILL_LOG_DEBUG(log, "Transition time: {:.2e} s",
                    minCorrectedTime * 1.0e-15 * params.constants().timeUnit);
  } else {
    QUILL_LOG_DEBUG(log,
                    "No new state was found in {} dynamics steps ({:.3e} s)",
                    params.dynamics_options().steps,
                    time * 1.0e-15 * params.constants().timeUnit);
  }
}

Member Data Documentation

biasBuffer

std::vector<double> eonc::SafeHyperJob::biasBuffer

private

Definition at line 30 of file SafeHyperJob.h.

timeBuffer

std::vector<double> eonc::SafeHyperJob::timeBuffer

private

Definition at line 29 of file SafeHyperJob.h.

transitionPot

double eonc::SafeHyperJob::transitionPot {0.0}

private

Definition at line 28 of file SafeHyperJob.h.

{0.0};

---

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

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