SymOp.hh

Go to the documentation of this file.

#ifndef SYMOP_HH
#define SYMOP_HH
 
#include <cmath>
#include <iostream>
 
#include "casm/symmetry/SymOpRepresentation.hh"
 
namespace CASM {
 
class Log;
 
class MasterSymGroup;
 
class SymOp : public SymOpRepresentation {
 public:
  typedef Eigen::Matrix3d matrix_type;
  typedef Eigen::Vector3d vector_type;
 
  static SymOp translation(const Eigen::Ref<const vector_type> &_tau) {
    return SymOp(matrix_type::Identity(), _tau, false, TOL, 0, nullptr);
  }
 
  static SymOp time_reversal_op() {
    return SymOp(matrix_type::Identity(), vector_type::Zero(), true, TOL, -1,
                 nullptr);
  }
 
  static SymOp point_op(const Eigen::Ref<const matrix_type> &_mat,
                        double _map_error = TOL) {
    return SymOp(_mat, vector_type::Zero(), false, _map_error, -1, nullptr);
  }
 
  SymOp() : SymOp(matrix_type::Identity(), vector_type::Zero(), false, TOL) {}
 
  SymOp(const Eigen::Ref<const matrix_type> &_mat,
        const Eigen::Ref<const vector_type> &_tau, bool _time_reversal,
        double _map_error)
      : SymOp(_mat, _tau, _time_reversal, _map_error, -1, nullptr) {}
 
  inline const matrix_type &matrix() const { return m_mat; }
 
  inline const vector_type &tau() const { return m_tau; }
 
  inline bool time_reversal() const { return m_time_reversal; }
 
  inline const vector_type &integral_tau() const {
    if (m_valid_integral_tau) {
      return m_integral_tau;
    }
 
    throw std::runtime_error("Error in SymOp::integral_tau(), not valid");
  }
 
  inline bool is_identity() const {
    return matrix().isIdentity(TOL) && !time_reversal();
  }
 
  void set_index(const MasterSymGroup &new_group, Index new_index);
 
  const double &map_error() const;
  void set_map_error(const double &value);
 
  // Routines that relate symmetry options:
  SymOp operator*(const SymOp &RHS) const;
 
  SymOp &operator+=(const Eigen::Ref<const vector_type> &RHS);
  SymOp &operator-=(const Eigen::Ref<const vector_type> &RHS);
 
  SymOp inverse() const;
 
  SymOp no_trans() const;
 
  bool operator==(const SymOp &RHS) const;
 
  SymOp &apply_sym(const SymOp &op);
 
  double character() const override { return matrix().trace(); }
 
  void print(std::ostream &stream, const Eigen::Ref<const matrix_type> &c2fmat =
                                       matrix_type::Identity()) const;
 
  void print_short(std::ostream &stream,
                   const Eigen::Ref<const matrix_type> &c2fmat =
                       matrix_type::Identity()) const;
 
  SymOpRepresentation *copy() const override { return new SymOp(*this); }
 
  SymOp unregistered_copy() const {
    return SymOp(matrix(), tau(), time_reversal(), map_error());
  }
 
 private:
  SymOp(const Eigen::Ref<const matrix_type> &_mat,
        const Eigen::Ref<const vector_type> &_tau, bool _time_reversal,
        double _map_error, Index _op_index, MasterSymGroup const *_master_ptr)
      : SymOpRepresentation(_master_ptr, SymGroupRepID(), _op_index),
        m_mat(_mat),
        m_tau(_tau),
        m_time_reversal(_time_reversal),
        m_map_error(_map_error) {
    _set_integral_tau();
  }
 
  /*** Inherited from SymOpRepresentation ***/
  /*
  Index m_op_index;
 
  SymGroupRepID m_rep_ID;
 
  MasterSymGroup const *m_master_group;
  */
 
  // its MasterSymGroup correspondent
  void _set_integral_tau() override;
 
  matrix_type m_mat;
 
  vector_type m_tau;
 
  bool m_time_reversal;
 
  mutable vector_type m_integral_tau;
 
  bool m_valid_integral_tau;
 
  double m_map_error;
};
 
const SymOp::matrix_type &get_matrix(const SymOp &op);
const SymOp::vector_type &get_translation(const SymOp &op);
bool get_time_reversal(const SymOp &op);
 
void print_matrix_tau_col(Log &log, const SymOp &op, Index prec);
 
namespace adapter {
 
template <typename ToType, typename FromType>
struct Adapter;
 
template <typename FromType>
struct Adapter<SymOp, FromType> {
  SymOp operator()(const FromType &adaptable) {
    // TODO: How to get mapping error tol?
    return SymOp(get_matrix(adaptable), get_translation(adaptable),
                 get_time_reversal(adaptable), CASM::TOL);
  }
};
 
template <>
struct Adapter<SymOp, SymOp> {
  SymOp const &operator()(SymOp const &adaptable) const { return adaptable; }
 
  SymOp &operator()(SymOp &adaptable) const { return adaptable; }
};
}  // namespace adapter
 
}  // namespace CASM
#endif