ConfigDoFValues.cc

Go to the documentation of this file.

#include "casm/clex/ConfigDoFValues.hh"
 
namespace CASM {
 
ConfigDoFValues::ConfigDoFValues(DoF::BasicTraits const &_traits,
                                 Index _n_sublat, Index _n_vol)
    : m_type(_traits.name()), m_n_sublat(_n_sublat), m_n_vol(_n_vol) {}
 
std::string const &ConfigDoFValues::type_name() const { return m_type; }
 
Index ConfigDoFValues::n_vol() const { return m_n_vol; }
 
Index ConfigDoFValues::n_sublat() const { return m_n_sublat; }
 
LocalDiscreteConfigDoFValues::LocalDiscreteConfigDoFValues(
    DoF::BasicTraits const &_traits, Index _n_sublat, Index _n_vol,
    std::vector<SymGroupRepID> const &_symrep_IDs)
    : ConfigDoFValues(_traits, _n_sublat, _n_vol),
      m_vals(Eigen::VectorXi::Zero(_n_sublat * _n_vol)),
      m_symrep_IDs(_symrep_IDs) {}
 
int &LocalDiscreteConfigDoFValues::occ(Index i) { return m_vals(i); }
 
void LocalDiscreteConfigDoFValues::set_values(
    Eigen::Ref<ValueType const> const &_values) {
  _throw_if_invalid_size(_values);
  m_vals = _values;
}
 
void LocalDiscreteConfigDoFValues::setZero() { m_vals.setZero(); }
 
Eigen::VectorXi const &LocalDiscreteConfigDoFValues::values() const {
  return m_vals;
}
 
LocalDiscreteConfigDoFValues::SublatReference
LocalDiscreteConfigDoFValues::sublat(Index b) {
  return m_vals.segment(b * n_vol(), n_vol());
}
 
LocalDiscreteConfigDoFValues::ConstSublatReference
LocalDiscreteConfigDoFValues::sublat(Index b) const {
  return m_vals.segment(b * n_vol(), n_vol());
}
 
std::vector<SymGroupRepID> const &LocalDiscreteConfigDoFValues::symrep_IDs()
    const {
  return m_symrep_IDs;
}
 
void LocalDiscreteConfigDoFValues::_throw_if_invalid_size(
    Eigen::Ref<ValueType const> const &_values) const {
  if (_values.size() != n_vol() * n_sublat()) {
    std::stringstream msg;
    msg << "Invalid size in LocalDiscreteConfigDoFValues: "
        << "Expected size=" << n_vol() * n_sublat()
        << ", received size=" << _values.size();
    throw std::runtime_error(msg.str());
  }
}
 
Index LocalContinuousConfigDoFValues::matrix_dim(
    std::vector<DoFSetInfo> const &_info) {
  Index dim = 0;
  for (auto const &_dof_set_info : _info) {
    dim = max(dim, _dof_set_info.dim());
  }
  return dim;
}
 
LocalContinuousConfigDoFValues::LocalContinuousConfigDoFValues(
    DoF::BasicTraits const &_traits, Index _n_sublat, Index _n_vol,
    std::vector<DoFSetInfo> const &_info)
    : ConfigDoFValues(_traits, _n_sublat, _n_vol),
      m_dim(matrix_dim(_info)),
      m_info(_info),
      m_vals(Eigen::MatrixXd::Zero(m_dim, _n_sublat * _n_vol)) {
  _throw_if_invalid_size(m_vals);
}
 
Index LocalContinuousConfigDoFValues::dim() const { return m_dim; }
 
void LocalContinuousConfigDoFValues::set_values(
    Eigen::Ref<const ValueType> const &_values) {
  _throw_if_invalid_size(_values);
  m_vals = _values;
}
 
void LocalContinuousConfigDoFValues::setZero() { m_vals.setZero(); }
 
Eigen::MatrixXd const &LocalContinuousConfigDoFValues::values() const {
  return m_vals;
}
 
void LocalContinuousConfigDoFValues::from_standard_values(
    Eigen::Ref<const Eigen::MatrixXd> const &_standard_values) {
  if (_standard_values.rows() != info().front().basis().rows() ||
      _standard_values.cols() != n_vol() * n_sublat()) {
    std::stringstream msg;
    msg << "Invalid standard values input size in "
           "LocalContinuousConfigDoFValues: "
        << "Expected rows=" << info().front().basis().rows()
        << ", received rows=" << _standard_values.rows()
        << ", expected cols=" << n_vol() * n_sublat()
        << ", received cols=" << _standard_values.cols();
    throw std::runtime_error(msg.str());
  }
  for (Index b = 0; b < n_sublat(); ++b)
    sublat(b).topRows(info()[b].dim()) =
        info()[b].inv_basis() *
        _standard_values.block(0, b * n_vol(), m_vals.rows(), n_vol());
}
 
Eigen::MatrixXd LocalContinuousConfigDoFValues::standard_values() const {
  Index rows = m_info.front().basis().rows();
  Eigen::MatrixXd result(rows, m_vals.cols());
  for (Index b = 0; b < n_sublat(); ++b) {
    result.block(0, b * n_vol(), rows, n_vol()) =
        info()[b].basis() * sublat(b).topRows(info()[b].dim());
  }
  return result;
}
 
LocalContinuousConfigDoFValues::SiteReference
LocalContinuousConfigDoFValues::site_value(Index l) {
  return m_vals.col(l);
}
 
LocalContinuousConfigDoFValues::ConstSiteReference
LocalContinuousConfigDoFValues::site_value(Index l) const {
  return m_vals.col(l);
}
 
LocalContinuousConfigDoFValues::SublatReference
LocalContinuousConfigDoFValues::sublat(Index b) {
  return m_vals.block(0, b * n_vol(), m_vals.rows(), n_vol());
}
 
LocalContinuousConfigDoFValues::ConstSublatReference
LocalContinuousConfigDoFValues::sublat(Index b) const {
  return m_vals.block(0, b * n_vol(), m_vals.rows(), n_vol());
}
 
std::vector<DoFSetInfo> const &LocalContinuousConfigDoFValues::info() const {
  return m_info;
}
 
void LocalContinuousConfigDoFValues::_throw_if_invalid_size(
    Eigen::Ref<ValueType const> const &_values) const {
  if (_values.rows() != dim() || _values.cols() != n_vol() * n_sublat()) {
    std::stringstream msg;
    msg << "Invalid size in LocalContinuousConfigDoFValues: "
        << "Expected rows=" << dim() << ", received rows=" << _values.rows()
        << ", expected cols=" << n_vol() * n_sublat()
        << ", received cols=" << _values.cols();
    throw std::runtime_error(msg.str());
  }
}
 
GlobalContinuousConfigDoFValues::GlobalContinuousConfigDoFValues(
    DoF::BasicTraits const &_traits, Index _n_sublat, Index _n_vol,
    DoFSetInfo const &_info)
    : ConfigDoFValues(_traits, _n_sublat, _n_vol),
      m_info(_info),
      m_vals(Eigen::VectorXd::Zero(m_info.dim())) {
  _throw_if_invalid_size(m_vals);
}
 
Index GlobalContinuousConfigDoFValues::dim() const { return m_vals.rows(); }
 
void GlobalContinuousConfigDoFValues::set_values(
    Eigen::Ref<const Eigen::MatrixXd> const &_values) {
  _throw_if_invalid_size(_values);
  m_vals = _values;
}
 
void GlobalContinuousConfigDoFValues::setZero() { m_vals.setZero(); }
 
Eigen::VectorXd const &GlobalContinuousConfigDoFValues::values() const {
  return m_vals;
}
 
void GlobalContinuousConfigDoFValues::from_standard_values(
    Eigen::Ref<const Eigen::MatrixXd> const &_standard_values) {
  if (_standard_values.size() != m_info.basis().rows()) {
    std::stringstream msg;
    msg << "Invalid standard values input size in "
           "GlobalContinuousConfigDoFValues: "
        << "Expected size=" << m_info.basis().rows()
        << ", received size=" << _standard_values.size();
    throw std::runtime_error(msg.str());
  }
  m_vals = info().inv_basis() * _standard_values;
}
 
Eigen::MatrixXd GlobalContinuousConfigDoFValues::standard_values() const {
  return m_info.basis() * m_vals;
}
 
DoFSetInfo const &GlobalContinuousConfigDoFValues::info() const {
  return m_info;
}
 
void GlobalContinuousConfigDoFValues::_throw_if_invalid_size(
    Eigen::Ref<ValueType const> const &_values) const {
  if (_values.size() != m_info.basis().cols()) {
    std::stringstream msg;
    msg << "Invalid size in LocalContinuousConfigDoFValues: "
        << "Expected size=" << m_info.basis().cols()
        << ", received size=" << _values.size();
    throw std::runtime_error(msg.str());
  }
}
 
}  // namespace CASM