SuperConfigEnum.hh

Go to the documentation of this file.

#ifndef CASM_SuperConfigEnum
#define CASM_SuperConfigEnum

#include "casm/misc/cloneable_ptr.hh"
#include "casm/container/InputEnumerator.hh"
#include "casm/clex/Configuration.hh"
#include "casm/clex/Supercell.hh"

extern "C" {
  CASM::EnumInterfaceBase *make_SuperConfigEnum_interface();
}

namespace CASM {

  class SuperConfigEnum : public InputEnumeratorBase<Configuration> {

    // -- Required members -------------------

  public:

    template<typename ConfigIterator>
    SuperConfigEnum(Supercell &_target_scel,
                    ConfigIterator _begin,
                    ConfigIterator _end);

    template<typename ConfigIterator>
    SuperConfigEnum(Supercell &_target_scel,
                    ConfigIterator _begin,
                    ConfigIterator _end,
                    PermuteIterator _perm_begin,
                    PermuteIterator _perm_end);

    std::string name() const override {
      return enumerator_name;
    }

    static const std::string enumerator_name;
    static const std::string interface_help;
    static int run(PrimClex &primclex, const jsonParser &kwargs, const Completer::EnumOption &enum_opt);


    // -- Unique -------------------

    const std::vector<Configuration> &sub_config() const {
      return m_sub_config;
    }

    const Array<int> &counter() const {
      return m_counter();
    }

    const PrimGrid &prim_grid() const {
      return *m_prim_grid;
    }

  private:

    // -- Required members -------------------

    void increment() override;


    // -- Unique -------------------

    void _init();

    bool _check_current() const;

    Supercell &_target_supercell() {
      return m_target_scel;
    }

    Supercell &_sub_supercell() {
      return *m_sub_scel;
    }

    std::vector<Configuration> &_sub_config() {
      return m_sub_config;
    }

    PrimGrid &_prim_grid() {
      return *m_prim_grid;
    }

    void _fill(const Array<int> &counter_val, Configuration &config);

    const PermuteIterator &_perm_begin() const {
      return m_perm_begin;
    }
    const PermuteIterator &_perm_end() const {
      return m_perm_end;
    }


    Supercell &m_target_scel;

    std::vector<Configuration> m_sub_config;

    PermuteIterator m_perm_begin, m_perm_end;

    // All sub_config use the same supercell
    Supercell *m_sub_scel;

    notstd::cloneable_ptr<Configuration> m_current;

    Counter<Array<int> > m_counter;

    notstd::cloneable_ptr<PrimGrid> m_prim_grid;

    std::vector<std::vector<Index> > m_index_map;

    bool m_has_occ;
    bool m_has_disp;

  };

  template<typename ConfigIterator>
  SuperConfigEnum::SuperConfigEnum(Supercell &_target_scel,
                                   ConfigIterator _begin,
                                   ConfigIterator _end) :
    SuperConfigEnum(_target_scel,
                    _begin,
                    _end,
                    _target_scel.permute_begin(),
                    _target_scel.permute_end()) {}

  template<typename ConfigIterator>
  SuperConfigEnum::SuperConfigEnum(Supercell &_target_scel,
                                   ConfigIterator _begin,
                                   ConfigIterator _end,
                                   PermuteIterator _perm_begin,
                                   PermuteIterator _perm_end) :
    m_target_scel(_target_scel),
    m_sub_config(_begin, _end),
    m_perm_begin(_perm_begin),
    m_perm_end(_perm_end) {

    _init();

  }

}

#endif