OccCandidate.cc

Go to the documentation of this file.

#include "casm/monte_carlo/OccCandidate.hh"
 
#include "casm/casm_io/json/jsonParser.hh"
#include "casm/clex/Supercell.hh"
#include "casm/crystallography/UnitCellCoord.hh"
#include "casm/monte_carlo/Conversions.hh"
 
namespace CASM {
 
Monte::OccCandidate jsonConstructor<Monte::OccCandidate>::from_json(
    const jsonParser &json, const Monte::Conversions &convert) {
  return Monte::OccCandidate(
      json["asym"].get<Index>(),
      convert.species_index(json["spec"].get<std::string>()));
}
 
Monte::OccSwap jsonConstructor<Monte::OccSwap>::from_json(
    const jsonParser &json, const Monte::Conversions &convert) {
  return Monte::OccSwap(
      jsonConstructor<Monte::OccCandidate>::from_json(json[0], convert),
      jsonConstructor<Monte::OccCandidate>::from_json(json[1], convert));
}
 
}  // namespace CASM
 
namespace CASM {
namespace Monte {
 
jsonParser &to_json(const OccCandidate &cand, const Conversions &convert,
                    jsonParser &json) {
  json.put_obj();
  json["asym"] = cand.asym;
  json["spec"] = convert.species_name(cand.species_index);
  return json;
}
 
std::ostream &operator<<(
    std::ostream &sout,
    std::pair<const OccCandidate &, const Conversions &> value) {
  sout << "(" << value.second.species_name(value.first.species_index) << ", "
       << value.first.asym << ")";
  return sout;
}
 
jsonParser &to_json(const OccSwap &swap, const Conversions &convert,
                    jsonParser &json) {
  jsonParser tmp;
  json.put_array();
  json.push_back(to_json(swap.cand_a, convert, tmp));
  json.push_back(to_json(swap.cand_b, convert, tmp));
  return json;
}
 
std::ostream &operator<<(
    std::ostream &sout, std::pair<const OccSwap &, const Conversions &> value) {
  sout << std::pair<const OccCandidate &, const Conversions &>(
              value.first.cand_a, value.second)
       << " <-> "
       << std::pair<const OccCandidate &, const Conversions &>(
              value.first.cand_b, value.second);
  return sout;
}
 
OccCandidateList::OccCandidateList(const Conversions &convert) {
  // create set of 'candidate' asym / species pairs
  m_candidate.clear();
  for (Index asym = 0; asym < convert.asym_size(); ++asym) {
    // hard code allowed sublattices: >1 allowed occupant
    if (convert.occ_size(asym) < 2) {
      continue;
    }
 
    // add candidates
    for (Index i = 0; i < convert.occ_size(asym); ++i) {
      m_candidate.push_back(OccCandidate(asym, convert.species_index(asym, i)));
    }
  }
 
  // create lookup table of asym, species_index -> candidate index,
  //   will return {Nasym, Nspecies} if {asym, species_index} not allowed
  Index Nspecies = convert.species_size();
  Index Nasym = convert.asym_size();
  m_end = m_candidate.size();
  std::vector<Index> unallowed(Nspecies, m_end);
  m_species_to_cand_index = std::vector<std::vector<Index> >(Nasym, unallowed);
 
  Index index = 0;
  for (const auto &cand : m_candidate) {
    m_species_to_cand_index[cand.asym][cand.species_index] = index;
    ++index;
  }
 
  // make canonical and grand canonical swaps
  _make_possible_swaps(convert);
}
 
void OccCandidateList::_make_possible_swaps(const Conversions &convert) {
  // construct canonical and grand canonical swaps
  m_canonical_swap.clear();
  m_grand_canonical_swap.clear();
 
  // check that species are different and allowed on both sites
  auto allowed_canonical_swap = [&](OccCandidate cand_a, OccCandidate cand_b) {
    return cand_a.species_index != cand_b.species_index &&
           convert.species_allowed(cand_a.asym, cand_b.species_index) &&
           convert.species_allowed(cand_b.asym, cand_a.species_index);
  };
 
  // check that asym is the same and species_index is different
  auto allowed_grand_canonical_swap = [&](OccCandidate cand_a,
                                          OccCandidate cand_b) {
    return cand_a.asym == cand_b.asym &&
           cand_a.species_index != cand_b.species_index;
  };
 
  // for each pair of candidates, check if they are allowed to swap
  for (const auto &cand_a : m_candidate) {
    for (const auto &cand_b : m_candidate) {
      // don't repeat a->b, b->a
      // and check that cand_b's species is allowed on cand_a's sublat && vice
      // versa
      if (cand_a < cand_b && allowed_canonical_swap(cand_a, cand_b)) {
        m_canonical_swap.push_back(OccSwap(cand_a, cand_b));
      }
 
      // allow a->b, b->a
      // check that asym is the same and species_index is different
      if (allowed_grand_canonical_swap(cand_a, cand_b)) {
        m_grand_canonical_swap.push_back(OccSwap(cand_a, cand_b));
      }
    }
  }
}
 
jsonParser &to_json(const OccCandidateList &list, const Conversions &convert,
                    jsonParser &json) {
  jsonParser tmp;
 
  json.put_obj();
 
  json["candidate"].put_array();
  for (auto it = list.begin(); it != list.end(); ++it) {
    json["candidate"].push_back(to_json(*it, convert, tmp));
  }
 
  json["canonical_swap"].put_array();
  for (auto it = list.canonical_swap().begin();
       it != list.canonical_swap().end(); ++it) {
    json["candidate_swap"].push_back(to_json(*it, convert, tmp));
  }
 
  json["grand_canonical_swap"].put_array();
  for (auto it = list.canonical_swap().begin();
       it != list.canonical_swap().end(); ++it) {
    json["grand_candidate_swap"].push_back(to_json(*it, convert, tmp));
  }
 
  return json;
}
 
std::ostream &operator<<(
    std::ostream &sout,
    std::pair<const OccCandidateList &, const Conversions &> value) {
  typedef std::pair<const OccCandidate &, const Conversions &> cand_pair;
  typedef std::pair<const OccSwap &, const Conversions &> swap_pair;
  const Conversions &convert = value.second;
  const OccCandidateList &list = value.first;
 
  sout << "Unit cell for determining equivalent swaps: \n"
       << convert.unit_scel().transf_mat() << "\n\n";
 
  sout << "Asymmetric Unit: " << std::endl;
  for (Index asym = 0; asym != convert.asym_size(); ++asym) {
    sout << "  " << asym << ": ";
    for (Index i = 0; i != convert.occ_size(asym); ++i) {
      sout << convert.species_name(convert.species_index(asym, i)) << " ";
    }
    sout << "\n";
 
    const auto &set = convert.asym_to_unitl(asym);
    for (auto it = set.begin(); it != set.end(); ++it) {
      sout << "    " << convert.unitl_to_bijk(*it) << "\n";
    }
  }
  sout << "\n";
 
  sout << "Candidates: (Species, AsymUnit)" << std::endl;
  for (auto it = list.begin(); it != list.end(); ++it) {
    sout << "  " << cand_pair(*it, convert) << "\n";
  }
  sout << "\n";
 
  sout << "Canonical swaps: " << std::endl;
  for (auto it = list.canonical_swap().begin();
       it != list.canonical_swap().end(); ++it) {
    sout << "  " << swap_pair(*it, convert) << "\n";
  }
  sout << "\n";
 
  sout << "Grand canonical swaps: " << std::endl;
  for (auto it = list.grand_canonical_swap().begin();
       it != list.grand_canonical_swap().end(); ++it) {
    sout << "  " << cand_pair(it->cand_a, convert) << " -> "
         << cand_pair(it->cand_b, convert) << "\n";
  }
  sout << "\n";
  return sout;
}
 
}  // namespace Monte
}  // namespace CASM