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 293 of file GPSurrogateJob.cpp.

                                                    {
  Eigen::VectorXd predEnergies{Eigen::VectorXd::Zero(matobjs.size())};
  Eigen::VectorXd trueEnergies{Eigen::VectorXd::Zero(matobjs.size())};
  Eigen::VectorXd accuracy{Eigen::VectorXd::Zero(matobjs.size())};
  for (auto idx{0}; idx < predEnergies.size(); idx++) {
    predEnergies[idx] = matobjs[idx]->getPotentialEnergy();
    matobjs[idx]->setPotential(true_pot);
    trueEnergies[idx] = matobjs[idx]->getPotentialEnergy();
 
    accuracy[idx] = std::sqrt(predEnergies[idx] * predEnergies[idx] -
                              trueEnergies[idx] * trueEnergies[idx]);
  }
  Eigen::VectorXd difference = predEnergies - trueEnergies;
  auto mae = difference.array()
                 .abs()
                 .maxCoeff(); //.squaredNorm() / predEnergies.size();
  std::ostringstream oss;
  oss << "predicted\n"
      << predEnergies << "\ntrue\n"
      << trueEnergies << "\ndifference\n"
      << difference << "\n MAE: " << mae;
  EONC_LOG_TRACE("{}", oss.str());
  return mae < 0.05;
}

get_features() [1/2]

MatrixXd eonc::helpers::surrogate::get_features

(

const std::vector< Matter > &

matobjs

)

Definition at line 188 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 201 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 214 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].getForcesFree().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 232 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]->getForcesFree().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 272 of file GPSurrogateJob.cpp.

                                                                   {
  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);
  // EONC_LOG_TRACE("Uncertainty along path
  // is {}\nmax_index: {}, maxVal: {}",
  //              fmt::streamed(pathUncertainty), maxIndex, maxUnc);
  return std::make_pair(maxUnc, maxIndex);
}

getMidSlice()

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

(

const std::vector< Matter > &

matobjs

)

Definition at line 248 of file GPSurrogateJob.cpp.

                                                                {
  // Used to get the initial data slice, endpoints and the midpoint
  std::vector<Matter> res;
  res.reserve(3);
  res.push_back(matobjs.front());
  // BUG: THIS ISN'T THE MIDDLE!!!!
  // XXX: Why does this have to be in the same order?
  // front mid back doesn't work
  // front back mid works
  res.push_back(matobjs.back());
  res.push_back(matobjs[((matobjs.size() - 2) * 2.0 / 3.0) + 1]);
  return res;
}

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 286 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 261 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;
  // EONC_LOG_TRACE("Generated Target:\n{}",
  // fmt::streamed(target));
  return target;
}