CompositionConverter.hh

Go to the documentation of this file.

#ifndef CASM_CompositionConverter_HH
#define CASM_CompositionConverter_HH
 
#include <map>
#include <vector>
 
#include "casm/clex/ParamComposition.hh"
#include "casm/global/eigen.hh"
 
namespace CASM {
class CompositionConverter {
 public:
  typedef unsigned int size_type;
 
  CompositionConverter() {}
 
  template <typename ComponentIterator, typename... EndMembers>
  CompositionConverter(ComponentIterator begin, ComponentIterator end,
                       Eigen::VectorXd _origin, EndMembers... _end_members);
 
  template <typename ComponentIterator>
  CompositionConverter(ComponentIterator begin, ComponentIterator end,
                       Eigen::VectorXd _origin, Eigen::MatrixXd _end_members);
 
  size_type independent_compositions() const;
 
  static std::string comp_var(size_type i);
 
  std::vector<std::string> components() const;
 
  Eigen::VectorXd origin() const;
 
  Eigen::VectorXd end_member(size_type i) const;
 
  Eigen::MatrixXd dparam_dmol() const;
 
  Eigen::MatrixXd dmol_dparam() const;
 
  Eigen::VectorXd param_composition(const Eigen::VectorXd &n) const;
 
  Eigen::VectorXd dparam_composition(const Eigen::VectorXd &dn) const;
 
  Eigen::VectorXd mol_composition(const Eigen::VectorXd &x) const;
 
  Eigen::VectorXd dmol_composition(const Eigen::VectorXd &dx) const;
 
  Eigen::VectorXd param_chem_pot(const Eigen::VectorXd chem_pot) const;
 
  Eigen::VectorXd chem_pot(const Eigen::VectorXd param_chem_pot) const;
 
  std::string mol_formula() const;
 
  std::string param_formula() const;
 
  std::string origin_formula() const;
 
  std::string end_member_formula(size_type i) const;
 
  std::string comp_formula(size_type i) const;
 
  std::string comp_n_formula(size_type i) const;
 
  std::string param_chem_pot_formula(size_type i) const;
 
 private:
  void _add_end_member(Eigen::VectorXd _end_member);
 
  template <typename... EndMembers>
  void _add_end_member(Eigen::VectorXd _end_member, EndMembers... _others);
 
  void _check_size(const Eigen::MatrixXd &vec) const;
 
  void _calc_conversion_matrices();
 
  std::string _n_formula(const Eigen::VectorXd &vec) const;
 
  std::vector<std::string> m_components;
 
  Eigen::VectorXd m_origin;
 
  Eigen::MatrixXd m_end_members;
 
  Eigen::MatrixXd m_to_n;
 
  Eigen::MatrixXd m_to_x;
};
 
template <typename OutputIterator>
OutputIterator standard_composition_axes(
    ParamComposition::AllowedOccupants _allowed_occs, OutputIterator result);
 
void display_composition_axes(
    std::ostream &stream,
    const std::map<std::string, CompositionConverter> &map);
 
void display_comp(std::ostream &stream, const CompositionConverter &f,
                  int indent = 0);
 
void display_comp_n(std::ostream &stream, const CompositionConverter &f,
                    int indent = 0);
 
void display_param_chem_pot(std::ostream &stream, const CompositionConverter &f,
                            int indent = 0);
 
Eigen::MatrixXd end_members(
    const ParamComposition::AllowedOccupants &_allowed_occs);
 
Eigen::MatrixXd composition_space(
    const ParamComposition::AllowedOccupants &_allowed_occs,
    double tol = 1e-14);
 
Eigen::MatrixXd null_composition_space(
    const ParamComposition::AllowedOccupants &_allowed_occs,
    double tol = 1e-14);
 
// ------ Definitions ---------------------------------------------
 
template <typename ComponentIterator, typename... EndMembers>
CompositionConverter::CompositionConverter(ComponentIterator begin,
                                           ComponentIterator end,
                                           Eigen::VectorXd _origin,
                                           EndMembers... _end_members)
    : m_components(begin, end), m_origin(_origin) {
  _add_end_member(_end_members...);
 
  _check_size(_origin);
 
  _calc_conversion_matrices();
}
 
template <typename ComponentIterator>
CompositionConverter::CompositionConverter(ComponentIterator begin,
                                           ComponentIterator end,
                                           Eigen::VectorXd _origin,
                                           Eigen::MatrixXd _end_members)
    : m_components(begin, end), m_origin(_origin), m_end_members(_end_members) {
  _check_size(_origin);
 
  _check_size(_end_members);
 
  _calc_conversion_matrices();
}
 
template <typename... EndMembers>
void CompositionConverter::_add_end_member(Eigen::VectorXd _end_member,
                                           EndMembers... _others) {
  _add_end_member(_end_member);
  _add_end_member(_others...);
}
 
template <typename OutputIterator>
OutputIterator standard_composition_axes(
    ParamComposition::AllowedOccupants _allowed_occs, OutputIterator result) {
  ParamComposition param_comp(_allowed_occs);
  param_comp.generate_prim_end_members();
  param_comp.generate_composition_space();
 
  for (int i = 0; i < param_comp.allowed_list().size(); i++) {
    const ParamComposition &curr = param_comp.allowed_list()[i];
    Eigen::MatrixXd end_members(curr.origin().size(),
                                curr.spanning_end_members().size());
    for (int j = 0; j < curr.spanning_end_members().size(); j++) {
      end_members.col(j) = curr.spanning_end_members()[j];
    }
 
    *result++ = CompositionConverter(param_comp.components().begin(),
                                     param_comp.components().end(),
                                     curr.origin(), end_members);
  }
 
  return result;
}
 
}  // namespace CASM
 
#endif