Cluster.hh

Go to the documentation of this file.

#ifndef CLUSTER_HH
#define CLUSTER_HH

#include <iostream>
#include <complex>
#include <cmath>

#include "casm/crystallography/Lattice.hh"
#include "casm/crystallography/Coordinate.hh"
#include "casm/symmetry/SymGroupRep.hh"

namespace CASM {

  class Lattice;
  template < typename CoordType >
  class BasicStructure;

  template < typename ClustType >
  class GenericOrbitree;

  template < typename CoordType >
  class GenericCluster;

  //Begin Cluster class definition:
  template < typename CoordType >
  class GenericCluster : public Array<CoordType> {
  public:
    using Array<CoordType> :: size;
    using Array<CoordType> :: at;
    using Array<CoordType> :: back;
    using Array<CoordType> :: operator[];
    using Array<CoordType> :: contains;
    using Array<CoordType> :: find;

    typedef CoordType WhichCoordType;

    //GenericCluster() : m_min_length(0.0), m_max_length(0.0), clust_group(LOCAL) {}
    GenericCluster(const Lattice &init_home);

    const Lattice &home() const {
      return *m_lat_ptr;
    }

    const SymGroup &clust_group() const {
      return m_clust_group;
    }

    const SymGroupRep::RemoteHandle &permute_rep() const {
      return m_permute_rep;
    }

    void set_clust_group(const Array<SymOp> &new_group) {
      _clust_group() = new_group;
    }

    void set_permute_rep(SymGroupRepID perm_rep_ID) {
      if(clust_group().size() == 0) {
        std::cerr << "CRITICAL ERROR: In GenericCluster<>::set_permute_rep(), Cluster::clust_group() has not yet been initialized!\n"
                  << "                Groups must always be initialized before their representations. Exiting...\n";
        assert(0);
        exit(1);
      }
      _permute_rep().set_rep(clust_group(), perm_rep_ID);
    }

    void set_lattice(const Lattice &new_home, COORD_TYPE mode);

    void push_back(const CoordType &new_coord);

    void within(Index pivot_ind = 0);

    void within(Index pivot_ind, Coordinate &trans);

    void all_within();

    void update_data_members(const BasicStructure<CoordType> &ref_struc);

    bool image_check(const Lattice &cell, int nV = 0) const;

    GenericCluster &permute(const Array<Index> &perm);
    GenericCluster &permute(const Permutation &perm);

    GenericCluster &apply_sym(const SymOp &op);
    GenericCluster &apply_sym_no_trans(const SymOp &op);

    void generate_clust_group(const SymGroup &super_group, std::vector<Permutation> *perm_array_ptr = nullptr, double tol = TOL);

    std::vector<Permutation> clust_group_permutations(double tol) const;

    void calc_properties();  //Alex do this
    void calc_properties(GenericCluster<CoordType> phenom_clust);

    double max_length() const {
      return m_max_length;
    }

    double min_length() const {
      return m_min_length;
    }

    Coordinate geometric_center() const;

    void prepare_prototype() {}

    bool contains(const GenericCluster &test_cluster) const;

    bool contains_periodic(const CoordType &test_coord, double tol) const;

    Index find(const CoordType &test_elem, double tol) const;

    bool find(const GenericCluster &test_cluster, Array<Index> &index, double tol) const;

    bool map_onto_subcluster(const GenericCluster &pivot, double tol = TOL);
    bool map_onto_subcluster(const GenericCluster &pivot, int num_maps, double tol = TOL);

    void collect_basis_info(const Array<CoordType> &basis);
    void collect_basis_info(const Array<CoordType> &basis, const Coordinate &shift);


    void read(std::istream &stream, int num_sites, COORD_TYPE mode, bool SD_is_on);
    void read(std::istream &stream, COORD_TYPE mode); //Modified by Ivy

    void print(std::ostream &stream, char delim = '\n', COORD_TYPE mode = COORD_DEFAULT) const;
    void print_shifted(std::ostream &stream, const Coordinate &shift, char delim = '\n', COORD_TYPE mode = COORD_DEFAULT) const;
    void print_sites(std::ostream &stream, int space, char delim = '\n', COORD_TYPE mode = COORD_DEFAULT) const;
    void print_basis_info(std::ostream &stream, int space, char delim = '\n', COORD_TYPE mode = COORD_DEFAULT) const;
    void print_decorated_sites(std::ostream &stream, int space, char delim = '\n', COORD_TYPE mode = COORD_DEFAULT) const;

    void merge(const GenericCluster &RHS);
    void merge(const CoordType &RHS);

    GenericCluster &operator+=(const Coordinate &RHS);
    GenericCluster &operator-=(const Coordinate &RHS);

    GenericCluster operator+(const GenericCluster &RHS);

    bool operator==(const GenericCluster &RHS) const;

    bool is_equivalent(const GenericCluster &test_clust) const;

    bool is_equivalent(const GenericCluster &test_clust, Coordinate &trans) const;

    bool map_onto(const GenericCluster &test_clust, double tol);

    bool map_onto(const GenericCluster &test_clust, Coordinate &trans, double tol);

    jsonParser &to_json(jsonParser &json) const;
    void from_json(const jsonParser &json);

  protected:
    SymGroup &_clust_group() {
      return m_clust_group;
    }

    SymGroupRep::RemoteHandle &_permute_rep() {
      return m_permute_rep;
    }

  private:
    Lattice const *m_lat_ptr;
    double m_min_length, m_max_length;
    SymGroup m_clust_group;
    SymGroupRep::RemoteHandle m_permute_rep;
  };

  template <typename CoordType>
  GenericCluster<CoordType> operator*(const SymOp &LHS, const GenericCluster<CoordType> &RHS);

  template <typename CoordType>
  GenericCluster<CoordType> operator+(const GenericCluster<CoordType> &LHS, const Coordinate &RHS);

  template <typename CoordType>
  GenericCluster<CoordType> operator-(const GenericCluster<CoordType> &LHS, const Coordinate &RHS);

  template <typename CoordType>
  bool almost_equal(const GenericCluster<CoordType> &LHS, const GenericCluster<CoordType> &RHS, double tol);



  template<typename CoordType>
  jsonParser &GenericCluster<CoordType>::to_json(jsonParser &json) const {

    json.put_obj();

    // members not included:
    //   Lattice const *m_lat_ptr;


    // inherits: public Array<CoordType>
    const Array<CoordType> &coord_array_ref = *this;
    // std::cout << "coord_array_ref:" << coord_array_ref.size() << std::endl;
    // std::cout << coord_array_ref << std::endl;
    json["coordtype"] = coord_array_ref;

    // members included:

    // double m_min_length, m_max_length;
    json["min_length"] = m_min_length;
    json["max_length"] = m_max_length;

    //Turning off the printing of cluster symmetry
    //TODO: Come up with some way of enabling this
    // // SymGroup clust_group;
    // if(clust_group.size() > 0)
    //   json["clust_group"] = clust_group;

    return json;
  }

  // Read from json. Lattice must be set previously. Assumes CoordType::CoordType(Lattice) exists.
  template<typename CoordType>
  void GenericCluster<CoordType>::from_json(const jsonParser &json) {
    try {

      // members not read:
      //   Lattice const *m_lat_ptr;

      // inherits: public Array<CoordType>

      //std::cout<<"Number of coordinates: "<<json["coordtype"].size()<<std::endl;
      //this->resize(json["coordtype"].size(), coord);
      for(int i = 0; i < json["coordtype"].size(); i++) {
        CoordType coord(home());
        CASM::from_json(coord, json["coordtype"][i]);
        (*this).push_back(coord);
      }
      //std::cout<<"Read in the coordinates"<<std::endl;

      // double m_min_length, m_max_length;
      //   Read these, because if local clusters they were generated from phenom_clust
      CASM::from_json(m_min_length, json["min_length"]);
      CASM::from_json(m_max_length, json["max_length"]);
      //std::cout<<"Read in the min and max lengths"<<std::endl;


      // // SymGroup clust_group;
      // //This is a hack to initialize the appropriate SymOp
      // Coordinate temp_coord(Vector3<double>(0.0,0.0,0.0),home());
      // SymOp temp_symOp(temp_coord);
      // if(clust_group.size()!=0)
      //   std::cerr<<"WARNING in Cluster::from_json. Your clust_group "
      //            <<"is not empty. Clearing anyways"<<std::endl;
      // clust_group.clear();
      // clust_group.push_back(temp_symOp);
      // //std::cout<<"Reading the clust_group"<<std::endl;
      // if(json.contains("clust_group"))
      //   CASM::from_json(clust_group, json["clust_group"]);

    }
    catch(...) {
      throw;
    }
  }


  template<typename T>
  jsonParser &to_json(const GenericCluster<T> &clust, jsonParser &json) {
    return clust.to_json(json);
  }

  template<typename T>
  void from_json(GenericCluster<T> &clust, const jsonParser &json) {
    clust.from_json(json);
  }

};

#include "casm/clusterography/Cluster_impl.hh"

#endif