SymOpRepresentation.hh

Go to the documentation of this file.

#ifndef SYMOPREPRESENTATION_HH
#define SYMOPREPRESENTATION_HH

#include <iostream>
#include <cmath>

#include "casm/CASM_global_definitions.hh"
#include "casm/container/Array.hh"
#include "casm/symmetry/SymGroupRepID.hh"

namespace CASM {
  class MasterSymGroup;
  class Permutation;
  class UnitCellCoord;
  class SymBasisPermute;

  class SymOpRepresentation {
  public:
    SymOpRepresentation() : m_master_group(nullptr), m_op_index(-1) {}

    SymOpRepresentation(const MasterSymGroup &_master_group, SymGroupRepID _rep_ID, Index _op_index) :
      SymOpRepresentation(&_master_group, _rep_ID, _op_index) {}

    virtual ~SymOpRepresentation() {} // = 0;

    virtual SymOpRepresentation *copy() const = 0;

    virtual double character() const {
      return NAN;
    }

    virtual Permutation  const *get_permutation() const {
      return nullptr;
    }

    virtual Eigen::MatrixXd const *get_MatrixXd() const {
      return nullptr;
    }

    virtual SymBasisPermute const *get_ucc_permutation() const {
      return nullptr;
    }


    Eigen::MatrixXd const *get_matrix_rep(SymGroupRepID _rep_ID) const;

    Permutation const *get_permutation_rep(SymGroupRepID _rep_ID) const;

    SymBasisPermute const *get_basis_permute_rep(SymGroupRepID _rep_ID) const;

    Array<Eigen::MatrixXd const * > get_matrix_reps(Array<SymGroupRepID> _rep_IDs) const;

    void set_rep(SymGroupRepID _rep_ID, const SymOpRepresentation &op_rep) const;

    void set_identifiers(const MasterSymGroup &new_group, SymGroupRepID new_rep_ID);

    void set_identifiers(const MasterSymGroup &new_group, SymGroupRepID new_rep_ID, Index new_op_index);

    const MasterSymGroup &master_group() const {
      assert(m_master_group);
      return *m_master_group;
    }

    bool has_valid_master() const {
      return m_master_group != nullptr;
    }

    void invalidate_index() {
      m_op_index = -1;
    }

    Index index()const {
      return m_op_index;
    }

    SymGroupRepID rep_ID()const {
      return m_rep_ID;
    }

    Index ind_inverse()const;

    Index ind_prod(const SymOpRepresentation &RHS)const;

    virtual jsonParser &to_json(jsonParser &json) const = 0;
    virtual void from_json(const jsonParser &json) = 0;

  protected:
    SymOpRepresentation(MasterSymGroup const *_master_group_ptr, SymGroupRepID _rep_ID, Index _op_index) :
      m_master_group(_master_group_ptr), m_rep_ID(_rep_ID), m_op_index(_op_index) {}

    MasterSymGroup const *m_master_group;

    SymGroupRepID m_rep_ID;

    Index m_op_index;
  };

  struct SymRepIndexCompare {

    SymRepIndexCompare() {}

    bool operator()(const SymOpRepresentation &A, const SymOpRepresentation &B) const {
      return A.index() < B.index();
    }
  };

  jsonParser &to_json(const SymOpRepresentation *rep, jsonParser &json);
  void from_json(SymOpRepresentation *rep, const jsonParser &json);

}
#endif