SymOp.hh

Go to the documentation of this file.

#ifndef SYMOP_HH
#define SYMOP_HH

#include <iostream>
#include <cmath>

#include "casm/symmetry/SymOpRepresentation.hh"


namespace CASM {

  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, TOL, 0, nullptr);
    }

    SymOp(const Eigen::Ref<const matrix_type> &_mat = matrix_type::Identity(),
          const Eigen::Ref<const vector_type> &_tau = vector_type::Zero(),
          double _map_error = TOL) :
      SymOp(_mat, _tau, _map_error, -1, nullptr) {
    }

    SymOp(const Eigen::Ref<const matrix_type> &_mat,
          double _map_error) :
      SymOp(_mat, vector_type::Zero(), _map_error) {

    }

    inline
    const matrix_type &matrix() const {
      return m_mat;
    }

    inline
    const vector_type &tau() const {
      return m_tau;
    }

    inline
    bool is_identity() const {
      return matrix().isIdentity(TOL);
    }

    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(), map_error());
    }

    jsonParser &to_json(jsonParser &json) const override;

    void from_json(const jsonParser &json) override;

  private:
    SymOp(const Eigen::Ref<const matrix_type> &_mat,
          const Eigen::Ref<const vector_type> &_tau,
          double _map_error,
          Index _op_index,
          MasterSymGroup const *_master_ptr) :
      SymOpRepresentation(_master_ptr, SymGroupRepID(), _op_index),
      m_mat(_mat),
      m_tau(_tau),
      m_map_error(_map_error) {
    }

    /*** Inherited from SymOpRepresentation ***/
    /*
    Index m_op_index;

    SymGroupRepID m_rep_ID;

    MasterSymGroup const *m_master_group;
    */

    matrix_type m_mat;

    vector_type m_tau;

    double m_map_error;

  };


  jsonParser &to_json(const SymOp &sym, jsonParser &json);
  void from_json(SymOp &sym, const jsonParser &json);

  //std::istream& operator>> (std::istream &stream, SymOp &op){op.read(stream); return stream;};
  //std::ostream& operator<< (std::ostream &stream, SymOp &op){op.print(stream); return stream;};

}
#endif