Conversions.cc

Go to the documentation of this file.

#include "casm/monte_carlo/Conversions.hh"
 
#include "casm/clex/Configuration.hh"
#include "casm/clex/PrimClex.hh"
#include "casm/clex/Supercell.hh"
#include "casm/crystallography/BasicStructure.hh"
#include "casm/crystallography/Structure.hh"
#include "casm/database/ScelDatabase.hh"
#include "casm/misc/algorithm.hh"
 
namespace CASM {
namespace Monte {
 
namespace {
Configuration default_prim_config(const PrimClex &primclex) {
  const Supercell &scel = *primclex.db<Supercell>()
                               .emplace(&primclex, Eigen::Matrix3l::Identity())
                               .first;
  Configuration res(scel);
  res.init_occupation();
  return res;
}
}  // namespace
 
Conversions::Conversions(const Supercell &mc_scel)
    : Conversions(default_prim_config(mc_scel.primclex()), mc_scel) {}
 
Conversions::Conversions(const Configuration &unit_config,
                         const Supercell &mc_scel)
    : m_unit_scel(&unit_config.supercell()),
      m_mc_scel(&mc_scel),
      m_struc_mol(xtal::struc_molecule(m_mc_scel->prim())),
      m_struc_molname(xtal::struc_molecule_name(m_mc_scel->prim())) {
  // make m_unitl_to_asym, m_Nasym
  Index asym = 0;
  Index unit_Nsites = m_unit_scel->num_sites();
  m_unitl_to_asym.resize(unit_Nsites, -1);
  std::vector<PermuteIterator> fg = unit_config.factor_group();
  for (Index unitl = 0; unitl < unit_Nsites; ++unitl) {
    if (m_unitl_to_asym[unitl] == -1) {
      for (auto it = fg.begin(); it != fg.end(); ++it) {
        // permutation defined by: after[i] = before[it->permute_ind(i)]
        m_unitl_to_asym[it->permute_ind(unitl)] = asym;
      }
      ++asym;
    }
  }
  m_Nasym = asym;
 
  // make m_asym_to_unitl & m_asym_to_b
  m_asym_to_unitl.resize(m_Nasym);
  m_asym_to_b.resize(m_Nasym);
  for (Index unitl = 0; unitl < unit_Nsites; ++unitl) {
    Index asym = m_unitl_to_asym[unitl];
    m_asym_to_unitl[asym].insert(unitl);
    m_asym_to_b[asym].insert(unitl_to_b(unitl));
  }
 
  // make m_occ_to_species and m_species_to_occ
 
  // [b][occ] -> species
  auto index_converter =
      make_index_converter(m_mc_scel->prim(), m_struc_molname);
 
  // [b][species] -> occ, index_converter[b].size() if not allowed
  auto index_converter_inv =
      make_index_converter_inverse(m_mc_scel->prim(), m_struc_molname);
 
  m_occ_to_species.resize(m_Nasym);
  m_species_to_occ.resize(m_Nasym);
  for (Index asym = 0; asym < m_Nasym; ++asym) {
    Index b = *(m_asym_to_b[asym].begin());
    m_occ_to_species[asym] = index_converter[b];
    m_species_to_occ[asym] = index_converter_inv[b];
  }
}
 
Index Conversions::l_to_b(Index l) const { return m_mc_scel->sublat(l); }
UnitCell Conversions::l_to_ijk(Index l) const {
  return m_mc_scel->uccoord(l).unitcell();
}
UnitCellCoord Conversions::l_to_bijk(Index l) const {
  return m_mc_scel->uccoord(l);
}
Index Conversions::l_to_unitl(Index l) const {
  return bijk_to_unitl(l_to_bijk(l));
}
Index Conversions::l_to_asym(Index l) const {
  return m_unitl_to_asym[l_to_unitl(l)];
}
 
Index Conversions::bijk_to_l(const UnitCellCoord &bijk) const {
  return m_mc_scel->linear_index(bijk);
}
Index Conversions::bijk_to_unitl(const UnitCellCoord &bijk) const {
  return m_unit_scel->linear_index(bijk);
}
Index Conversions::bijk_to_asym(const UnitCellCoord &bijk) const {
  return l_to_asym(bijk_to_l(bijk));
}
 
Index Conversions::unitl_to_b(Index unitl) const {
  return m_unit_scel->sublat(unitl);
}
UnitCellCoord Conversions::unitl_to_bijk(Index unitl) const {
  return m_unit_scel->uccoord(unitl);
}
Index Conversions::unitl_to_asym(Index unitl) const {
  return m_unitl_to_asym[unitl];
}
 
Index Conversions::asym_size() const { return m_Nasym; }
const std::set<Index> &Conversions::asym_to_b(Index asym) const {
  return m_asym_to_b[asym];
}
const std::set<Index> &Conversions::asym_to_unitl(Index asym) const {
  return m_asym_to_unitl[asym];
}
 
const Supercell &Conversions::unit_scel() const { return *m_unit_scel; }
const Supercell &Conversions::mc_scel() const { return *m_mc_scel; }
 
Index Conversions::occ_size(Index asym) const {
  return m_occ_to_species[asym].size();
}
Index Conversions::species_index(Index asym, Index occ_index) const {
  return m_occ_to_species[asym][occ_index];
}
Index Conversions::occ_index(Index asym, Index species_index) const {
  // returns occ_size(asym) if species not allowed
  return m_species_to_occ[asym][species_index];
}
bool Conversions::species_allowed(Index asym, Index species_index) const {
  return occ_index(asym, species_index) != occ_size(asym);
}
 
Index Conversions::species_size() const { return m_struc_mol.size(); }
Index Conversions::species_index(std::string species_name) const {
  return find_index(m_struc_molname, species_name);
}
const Molecule &Conversions::species_to_mol(Index species_index) const {
  return m_struc_mol[species_index];
}
const std::string &Conversions::species_name(Index species_index) const {
  return m_struc_molname[species_index];
}
Index Conversions::components_size(Index species_index) const {
  return species_to_mol(species_index).size();
}
 
}  // namespace Monte
}  // namespace CASM