CompositionConverter.hh

Go to the documentation of this file.

#ifndef CASM_CompositionConverter_HH
#define CASM_CompositionConverter_HH

#include <vector>
#include <map>
#include "casm/external/Eigen/Dense"

#include "casm/casm_io/jsonParser.hh"
#include "casm/clex/ParamComposition.hh"

namespace CASM {

  class Structure;

  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::VectorXd &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(const Structure &prim, 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);

  jsonParser &to_json(const CompositionConverter &f, jsonParser &json);

  void from_json(CompositionConverter &f, const jsonParser &json);

  Eigen::MatrixXd end_members(const Structure &prim);

  Eigen::MatrixXd composition_space(const Structure &prim, double tol = 1e-14);

  Eigen::MatrixXd null_composition_space(const Structure &prim, 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.col(0));

    _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(const Structure &prim, OutputIterator result) {
    ParamComposition param_comp(prim);
    param_comp.generate_components();
    param_comp.generate_sublattice_map();
    param_comp.generate_prim_end_members();
    param_comp.generate_composition_space();

    std::vector<std::string> components;
    for(int i = 0; i < param_comp.get_components().size(); i++) {
      components.push_back(param_comp.get_components()[i]);
    }

    for(int i = 0; i < param_comp.get_allowed_list().size(); i++) {
      const ParamComposition &curr = param_comp.get_allowed_list()[i];
      Eigen::MatrixXd end_members(curr.get_origin().size(), curr.get_spanning_end_members().size());
      for(int j = 0; j < curr.get_spanning_end_members().size(); j++) {
        end_members.col(j) = curr.get_spanning_end_members()[j];
      }

      *result++ = CompositionConverter(components.begin(), components.end(), curr.get_origin(), end_members);
    }

    return result;
  }


}

#endif