OccCandidate.hh

Go to the documentation of this file.

#ifndef CASM_OccCandidate_HH
#define CASM_OccCandidate_HH
 
#include <tuple>
#include <utility>
#include <vector>
 
#include "casm/global/definitions.hh"
#include "casm/misc/Comparisons.hh"
 
namespace CASM {
 
class jsonParser;
template <typename T>
struct jsonConstructor;
 
}  // namespace CASM
 
namespace CASM {
namespace Monte {
 
class Conversions;
struct OccCandidate;
class OccSwap;
 
}  // namespace Monte
}  // namespace CASM
 
namespace CASM {
 
template <>
struct jsonConstructor<Monte::OccCandidate> {
  static Monte::OccCandidate from_json(const jsonParser &json,
                                       const Monte::Conversions &convert);
};
 
template <>
struct jsonConstructor<Monte::OccSwap> {
  static Monte::OccSwap from_json(const jsonParser &json,
                                  const Monte::Conversions &convert);
};
}  // namespace CASM
 
namespace CASM {
namespace Monte {
 
struct OccCandidate : public Comparisons<CRTPBase<OccCandidate>> {
  OccCandidate(Index _asym, Index _species_index)
      : asym(_asym), species_index(_species_index) {}
 
  Index asym;
  Index species_index;
 
  bool operator<(OccCandidate B) const {
    if (asym != B.asym) {
      return asym < B.asym;
    }
    return species_index < B.species_index;
  }
};
 
jsonParser &to_json(const OccCandidate &cand, const Conversions &convert,
                    jsonParser &json);
 
std::ostream &operator<<(
    std::ostream &sout,
    std::pair<const OccCandidate &, const Conversions &> value);
 
class OccSwap : public Comparisons<CRTPBase<OccSwap>> {
 public:
  OccSwap(const OccCandidate &_cand_a, const OccCandidate &_cand_b)
      : cand_a(_cand_a), cand_b(_cand_b) {}
 
  OccCandidate cand_a;
  OccCandidate cand_b;
 
  void reverse() {
    using std::swap;
    std::swap(cand_a, cand_b);
  }
 
  OccSwap &sort() {
    OccSwap B(*this);
    B.reverse();
 
    if (B._lt(*this)) {
      *this = B;
    }
    return *this;
  }
 
  OccSwap sorted() const {
    OccSwap res(*this);
    res.sort();
    return res;
  }
 
  bool operator<(const OccSwap &B) const {
    return this->sorted()._lt(B.sorted());
  }
 
 private:
  bool _lt(const OccSwap &B) const { return this->tuple() < B.tuple(); }
 
  typedef std::tuple<OccCandidate, OccCandidate> tuple_type;
 
  tuple_type tuple() const { return std::make_tuple(cand_a, cand_b); }
};
 
jsonParser &to_json(const OccSwap &swap, const Conversions &convert,
                    jsonParser &json);
 
std::ostream &operator<<(std::ostream &sout,
                         std::pair<const OccSwap &, const Conversions &> value);
 
class OccCandidateList {
 public:
  typedef std::vector<OccCandidate>::const_iterator const_iterator;
 
  OccCandidateList() {}
 
  OccCandidateList(const Conversions &convert);
 
  Index index(const OccCandidate &cand) const {
    return m_species_to_cand_index[cand.asym][cand.species_index];
  }
 
  Index index(Index asym, Index species_index) const {
    return m_species_to_cand_index[asym][species_index];
  }
 
  const OccCandidate &operator[](Index candidate_index) const {
    return m_candidate[candidate_index];
  }
 
  const_iterator begin() const { return m_candidate.begin(); }
 
  const_iterator end() const { return m_candidate.end(); }
 
  Index size() const { return m_end; }
 
  const std::vector<OccSwap> &canonical_swap() const {
    return m_canonical_swap;
  }
 
  const std::vector<OccSwap> &grand_canonical_swap() const {
    return m_grand_canonical_swap;
  }
 
 private:
  void _make_possible_swaps(const Conversions &convert);
 
  std::vector<std::vector<Index>> m_species_to_cand_index;
 
  std::vector<OccCandidate> m_candidate;
 
  Index m_end;
 
  std::vector<OccSwap> m_canonical_swap;
 
  std::vector<OccSwap> m_grand_canonical_swap;
};
 
jsonParser &to_json(const OccCandidateList &list, const Conversions &convert,
                    jsonParser &json);
 
std::ostream &operator<<(
    std::ostream &sout,
    std::pair<const OccCandidateList &, const Conversions &> value);
 
}  // namespace Monte
}  // namespace CASM
 
#endif