eonc::TADJob Class Reference

#include <TADJob.h>

Inheritance diagram for eonc::TADJob:

Public Member Functions
	~TADJob ()=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	initExtra () override
	Create any extra matter objects needed by the subclass.
void	reportResults () override
	Post-dynamics logging (override for job-specific messages).

Private Attributes
std::shared_ptr< Matter >	crossing
double	barrier {0.0}
std::vector< double >	timeBuffer

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.
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 17 of file TADJob.h.

Constructor & Destructor Documentation

~TADJob()

eonc::TADJob::~TADJob ( )

default

Member Function Documentation

dynamics()

int eonc::TADJob::dynamics ( )

overrideprivatevirtual

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

Implements eonc::ReplicaDynamicsJob.

Definition at line 43 of file TADJob.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, nState = 0;
  long StateCheckInterval, RecordInterval;
  double kinE, kinT, avgT, varT;
  double kB = params.constants().kB;
  double correctedTime = 0.0;
  double stopTime = 0.0, sumSimulatedTime = 0.0;
  double Temp = 0.0, sumT = 0.0, sumT2 = 0.0;
  double correctionFactor = 1.0;
  double transitionTime_current = 0.0, transitionTime_previous = 0.0;
  double delta, minmu, factor, highT, lowT;
 
  AtomMatrix velocity;
 
  minCorrectedTime = 1.0e200;
  lowT = params.tad_options().low_temperature;
  highT = params.main_options().temperature;
  delta = params.tad_options().confidence;
  minmu = params.tad_options().min_prefactor;
  factor = std::log(1.0 / delta) / minmu;
  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);
 
  Dynamics TAD(current.get(), params);
  TAD.setThermalVelocity();
 
  {
    eonc::ForceCallTimer timer(dephaseFCalls);
    dephase();
  }
 
  QUILL_LOG_DEBUG(
      log,
      "Starting MD run\nTemperature: {:.2f} Kelvin"
      "Total Simulation Time: {:.2f} fs\nTime Step: {:.2f} fs\nTotal Steps: "
      "{}\n",
      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) {
    kinE = current->getKineticEnergy();
    kinT = (2.0 * kinE / nFreeCoord / kB);
    sumT += kinT;
    sumT2 += kinT * kinT;
    QUILL_LOG_TRACE_L1(log, "steps = {:10d} temp = {:10.5f} ", step, kinT);
 
    TAD.oneStep();
    mdFCalls++;
 
    time += params.dynamics_options().time_step;
    nCheck++;
    step++;
    QUILL_LOG_TRACE_L1(log, "step = {:4d}, time= {:10.4f}", step, time);
 
    if (params.parallel_replica_options().refine_transition && recordFlag &&
        !newStateFlag) {
      if (nCheck % RecordInterval == 0) {
        *mdBuffer[nRecord] = *current;
        timeBuffer[nRecord] = time;
        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());
      } else {
        refineStep = 0;
      }
 
      if (can_refine) {
        transitionStep =
            newStateStep - StateCheckInterval + refineStep * RecordInterval;
        transitionTime_current = timeBuffer[static_cast<size_t>(refineStep)];
        *crossing = *mdBuffer[static_cast<size_t>(refineStep)];
        const long prev = refineStep > 0 ? refineStep - 1 : 0;
        *current = *mdBuffer[static_cast<size_t>(prev)];
      } else {
        *crossing = *current;
        transitionTime_current = time;
      }
      transitionTime = transitionTime_current - transitionTime_previous;
      transitionTime_previous = transitionTime_current;
      barrier = crossing->getPotentialEnergy() - reactant->getPotentialEnergy();
      QUILL_LOG_DEBUG(log, "barrier= {:.3f}", barrier);
      correctionFactor = std::exp(barrier / kB * (1.0 / lowT - 1.0 / highT));
      correctedTime = transitionTime * correctionFactor;
      sumSimulatedTime += transitionTime;
      velocity = current->getVelocities();
      velocity = velocity * (-1);
      current->setVelocities(velocity);
 
      if (correctedTime < minCorrectedTime) {
        minCorrectedTime = correctedTime;
        *saddle = *crossing;
        *finalState = *finalStateTmp;
      }
      stopTime = factor * std::pow(minCorrectedTime / factor, lowT / highT);
      QUILL_LOG_DEBUG(
          log,
          "tranisitonTime= {:.3e} s, Barrier= {:.3f} eV, correctedTime= {:.3e} "
          "s, "
          "SimulatedTime= {:.3e} s, minCorTime= {:.3e} s, stopTime= {:.3e} s",
          transitionTime * 1e-15 * params.constants().timeUnit, barrier,
          correctedTime * 1e-15 * params.constants().timeUnit,
          sumSimulatedTime * 1e-15 * params.constants().timeUnit,
          minCorrectedTime * 1.0e-15 * params.constants().timeUnit,
          stopTime * 1.0e-15 * params.constants().timeUnit);
 
      transitionFlag = false;
    }
 
    if (firstTransitFlag && sumSimulatedTime >= stopTime) {
      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);
    }
 
    if (step == params.dynamics_options().steps) {
      stopFlag = true;
      if (firstTransitFlag) {
        QUILL_LOG_DEBUG(log, "Detected one transition");
      } else {
        QUILL_LOG_DEBUG(log, "Failed to detect any transition");
      }
    }
  }
 
  avgT = sumT / step;
  varT = sumT2 / step - avgT * avgT;
 
  QUILL_LOG_DEBUG(log,
                  "Temperature : Average = {} ; Stddev = {} ; Factor = {}; "
                  "Average_Boost = {}",
                  avgT, std::sqrt(varT), varT / avgT / avgT * nFreeCoord / 2,
                  minCorrectedTime / step /
                      params.dynamics_options().time_step);
  if (std::isfinite(avgT) == 0) {
    QUILL_LOG_DEBUG(log, "Infinite average temperature, something went wrong!");
    newStateFlag = false;
  }
 
  if (newStateFlag && finalState && finalState->numberOfAtoms() > 0) {
    *product = *finalState;
  } else if (current) {
    *product = *current;
  }
 
  if (newStateFlag) {
    return 1;
  } else {
    return 0;
  }
}

initExtra()

void eonc::TADJob::initExtra ( )

overrideprivatevirtual

Create any extra matter objects needed by the subclass.

Reimplemented from eonc::ReplicaDynamicsJob.

Definition at line 20 of file TADJob.cpp.

                       {
  crossing = std::make_shared<Matter>(pot, params);
 
  QUILL_LOG_DEBUG(log, "Temperature Accelerated Dynamics, running");
  QUILL_LOG_DEBUG(log,
                  "High temperature MD simulation running at {:.2f} K to "
                  "simulate dynamics at {:.2f} K",
                  params.main_options().temperature,
                  params.tad_options().low_temperature);
}

reportResults()

void eonc::TADJob::reportResults ( )

overrideprivatevirtual

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

Reimplemented from eonc::ReplicaDynamicsJob.

Definition at line 31 of file TADJob.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

barrier

double eonc::TADJob::barrier {0.0}

private

Definition at line 28 of file TADJob.h.

{0.0};

crossing

std::shared_ptr<Matter> eonc::TADJob::crossing

private

Definition at line 27 of file TADJob.h.

timeBuffer

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

private

Definition at line 29 of file TADJob.h.

---

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

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