eonc::helpers::surrogate Namespace Reference

Functions
MatrixXd	get_features (const std::vector< Matter > &matobjs)
MatrixXd	get_features (const std::vector< std::shared_ptr< Matter > > &matobjs)
MatrixXd	get_targets (std::vector< Matter > &matobjs, std::shared_ptr< Potential > true_pot)
MatrixXd	get_targets (std::vector< std::shared_ptr< Matter > > &matobjs, std::shared_ptr< Potential > true_pot)
std::vector< Matter >	getMidSlice (const std::vector< Matter > &matobjs)
Eigen::VectorXd	make_target (Matter &m1, std::shared_ptr< Potential > true_pot)
std::pair< double, Eigen::VectorXd::Index >	getMaxUncertainty (const std::vector< std::shared_ptr< Matter > > &matobjs)
std::pair< Eigen::VectorXd, Eigen::VectorXd >	getNewDataPoint (const std::vector< std::shared_ptr< Matter > > &matobjs, std::shared_ptr< Potential > true_pot)
bool	accuratePES (std::vector< std::shared_ptr< Matter > > &matobjs, std::shared_ptr< Potential > true_pot)

Function Documentation

accuratePES()

bool eonc::helpers::surrogate::accuratePES	(	std::vector< std::shared_ptr< Matter > > &	matobjs,
		std::shared_ptr< Potential >	true_pot )

Definition at line 305 of file GPSurrogateJob.cpp.

                                                    {
  if (matobjs.empty()) {
    throw std::invalid_argument("accuratePES: empty path");
  }
  Eigen::VectorXd predEnergies{Eigen::VectorXd::Zero(matobjs.size())};
  Eigen::VectorXd trueEnergies{Eigen::VectorXd::Zero(matobjs.size())};
  for (auto idx{0}; idx < predEnergies.size(); idx++) {
    auto incoming = matobjs[idx]->getPotential();
    predEnergies[idx] = matobjs[idx]->getPotentialEnergy();
    matobjs[idx]->setPotential(true_pot);
    trueEnergies[idx] = matobjs[idx]->getPotentialEnergy();
    matobjs[idx]->setPotential(incoming);
  }
  Eigen::VectorXd difference = predEnergies - trueEnergies;
  const auto maxAbs = difference.array().abs().maxCoeff();
  std::ostringstream oss;
  oss << "predicted\n"
      << predEnergies << "\ntrue\n"
      << trueEnergies << "\ndifference\n"
      << difference << "\n maxAbs: " << maxAbs;
  EONC_LOG_TRACE("{}", oss.str());
  return maxAbs < 0.05;
}

get_features() [1/2]

MatrixXd eonc::helpers::surrogate::get_features

(

const std::vector< Matter > &

matobjs

)

Definition at line 202 of file GPSurrogateJob.cpp.

                                                        {
  // Calculate dimensions
  MatrixXd features(matobjs.size(), matobjs.front().numberOfFreeAtoms() * 3);
  EONC_LOG_TRACE("rows: {}, cols:{}", matobjs.size(),
                 matobjs.front().numberOfFreeAtoms() * 3);
  for (long idx{0}; idx < features.rows(); idx++) {
    features.row(idx) = matobjs[idx].getPositionsFreeV();
  }
  std::ostringstream oss;
  oss << features;
  EONC_LOG_TRACE("Features\n:{}", oss.str());
  return features;
}

get_features() [2/2]

MatrixXd eonc::helpers::surrogate::get_features

(

const std::vector< std::shared_ptr< Matter > > &

matobjs

)

Definition at line 215 of file GPSurrogateJob.cpp.

                                                                       {
  // Calculate dimensions
  MatrixXd features(matobjs.size(), matobjs.front()->numberOfFreeAtoms() * 3);
  EONC_LOG_TRACE("rows: {}, cols:{}\n", matobjs.size(),
                 matobjs.front()->numberOfFreeAtoms() * 3);
  for (long idx{0}; idx < features.rows(); idx++) {
    features.row(idx) = matobjs[idx]->getPositionsFreeV();
  }
  std::ostringstream oss;
  oss << features;
  EONC_LOG_TRACE("Features\n:{}", oss.str());
  return features;
}

get_targets() [1/2]

MatrixXd eonc::helpers::surrogate::get_targets	(	std::vector< Matter > &	matobjs,
		std::shared_ptr< Potential >	true_pot )

Definition at line 228 of file GPSurrogateJob.cpp.

                                                        {
  // Always with derivatives for now
  // Energy + Derivatives for each row
  const auto nrows = matobjs.size();
  const auto ncols = (matobjs.front().numberOfFreeAtoms() * 3) + 1;
  MatrixXd targets(nrows, ncols);
  for (long idx{0}; idx < targets.rows(); idx++) {
    matobjs[idx].setPotential(true_pot);
    targets.row(idx)[0] = matobjs[idx].getPotentialEnergy();
    targets.block(idx, 1, 1, ncols - 1) =
        matobjs[idx].getForcesFreeV().array() * -1;
  }
  std::ostringstream oss;
  oss << targets;
  EONC_LOG_TRACE("Targets\n:{}", oss.str());
  return targets;
}

get_targets() [2/2]

MatrixXd eonc::helpers::surrogate::get_targets	(	std::vector< std::shared_ptr< Matter > > &	matobjs,
		std::shared_ptr< Potential >	true_pot )

Definition at line 246 of file GPSurrogateJob.cpp.

                                                        {
  const auto nrows = matobjs.size();
  const auto ncols = (matobjs.front()->numberOfFreeAtoms() * 3) + 1;
  MatrixXd targets(nrows, ncols);
  for (long idx{0}; idx < targets.rows(); idx++) {
    matobjs[idx]->setPotential(true_pot);
    targets.row(idx)[0] = matobjs[idx]->getPotentialEnergy();
    targets.block(idx, 1, 1, ncols - 1) =
        matobjs[idx]->getForcesFreeV().array() * -1;
  }
  std::ostringstream oss;
  oss << targets;
  EONC_LOG_TRACE("Targets\n:{}", oss.str());
  return targets;
}

getMaxUncertainty()

std::pair< double, Eigen::VectorXd::Index > eonc::helpers::surrogate::getMaxUncertainty

(

const std::vector< std::shared_ptr< Matter > > &

matobjs

)

Definition at line 283 of file GPSurrogateJob.cpp.

                                                                   {
  if (matobjs.size() < 3) {
    throw std::invalid_argument(
        "getMaxUncertainty: need at least three images");
  }
  Eigen::VectorXd pathUncertainty{Eigen::VectorXd::Zero(matobjs.size() - 2)};
  for (auto idx{0}; idx < pathUncertainty.size(); idx++) {
    pathUncertainty[idx] = matobjs[idx + 1]->getEnergyVariance();
  }
  Eigen::VectorXd::Index maxIndex;
  double maxUnc{pathUncertainty.maxCoeff()};
  pathUncertainty.maxCoeff(&maxIndex);
  return std::make_pair(maxUnc, maxIndex);
}

getMidSlice()

std::vector< Matter > eonc::helpers::surrogate::getMidSlice

(

const std::vector< Matter > &

matobjs

)

Definition at line 262 of file GPSurrogateJob.cpp.

                                                                {
  // Initial GP slice: endpoints plus one interior sample. CatLearn
  // training is order-sensitive (front, back, interior). The interior
  // index is two-thirds along the movable images, not n/2.
  if (matobjs.size() < 3) {
    throw std::invalid_argument("getMidSlice: need at least three images");
  }
  const std::size_t n = matobjs.size();
  const std::size_t twoThirds =
      static_cast<std::size_t>(((n - 2) * 2.0 / 3.0) + 1.0);
  return {matobjs.front(), matobjs.back(), matobjs[twoThirds]};
}

getNewDataPoint()

std::pair< Eigen::VectorXd, Eigen::VectorXd > eonc::helpers::surrogate::getNewDataPoint	(	const std::vector< std::shared_ptr< Matter > > &	matobjs,
		std::shared_ptr< Potential >	true_pot )

Definition at line 298 of file GPSurrogateJob.cpp.

                                                   {
  auto [maxUnc, maxIndex] = getMaxUncertainty(matobjs);
  Matter candidate{*matobjs[maxIndex + 1]};
  return std::make_pair<Eigen::VectorXd, Eigen::VectorXd>(
      candidate.getPositionsFreeV(), make_target(candidate, true_pot));
}

make_target()

Eigen::VectorXd eonc::helpers::surrogate::make_target	(	Matter &	m1,
		std::shared_ptr< Potential >	true_pot )

Definition at line 274 of file GPSurrogateJob.cpp.

                                                                         {
  const auto ncols = (m1.numberOfFreeAtoms() * 3) + 1;
  Eigen::VectorXd target(ncols);
  m1.setPotential(true_pot);
  target(0) = m1.getPotentialEnergy();
  target.segment(1, ncols - 1) = m1.getForcesFreeV() * -1;
  return target;
}