Clexulator.hh

Go to the documentation of this file.

#ifndef CLEXULATOR_HH
#define CLEXULATOR_HH
#include <cstddef>

#include "casm/external/boost.hh"
#include "casm/system/RuntimeLibrary.hh"
#include "casm/crystallography/UnitCellCoord.hh"
#include "casm/clex/NeighborList.hh"
#include "casm/casm_io/Log.hh"

namespace CASM {

  namespace Clexulator_impl {

    class Base {

    public:

      typedef unsigned int size_type;


      Base(size_type _nlist_size, size_type _corr_size) :
        m_nlist_size(_nlist_size),
        m_corr_size(_corr_size) {}

      virtual ~Base() {}

      size_type nlist_size() const {
        return m_nlist_size;
      }

      size_type corr_size() const {
        return m_corr_size;
      }

      std::unique_ptr<Base> clone() const {
        return std::unique_ptr<Base>(_clone());
      }

      const std::set<UnitCellCoord> &neighborhood() const {
        return m_neighborhood;
      }

      const std::set<UnitCellCoord> &neighborhood(size_type linear_orbit_index) const {
        return m_orbit_neighborhood[linear_orbit_index];
      }

      const PrimNeighborList::Matrix3Type &weight_matrix() const {
        return m_weight_matrix;
      }

      void set_config_occ(const int *_occ_ptr) {
        m_occ_ptr = _occ_ptr;
      }

      void set_nlist(const long int *_nlist_ptr) {
        m_nlist_ptr = _nlist_ptr;
        return;
      };

      virtual void calc_global_corr_contribution(double *corr_begin) const = 0;

      virtual void calc_restricted_global_corr_contribution(double *corr_begin, size_type const *ind_list_begin, size_type const *ind_list_end) const = 0;

      virtual void calc_point_corr(int b_index, double *corr_begin) const = 0;

      virtual void calc_restricted_point_corr(int b_index, double *corr_begin, size_type const *ind_list_begin, size_type const *ind_list_end) const = 0;

      virtual void calc_delta_point_corr(int b_index, int occ_i, int occ_f, double *corr_begin) const = 0;

      virtual void calc_restricted_delta_point_corr(int b_index,
                                                    int occ_i,
                                                    int occ_f,
                                                    double *corr_begin,
                                                    size_type const *ind_list_begin,
                                                    size_type const *ind_list_end) const = 0;


    private:

      virtual Base *_clone() const = 0;

      size_type m_nlist_size;

      size_type m_corr_size;


    protected:

      const int *m_occ_ptr;

      const long int *m_nlist_ptr;

      std::set<UnitCellCoord> m_neighborhood;

      std::vector<std::set<UnitCellCoord> > m_orbit_neighborhood;

      PrimNeighborList::Matrix3Type m_weight_matrix;

    };
  }

  class Clexulator {

  public:

    typedef Clexulator_impl::Base::size_type size_type;


    Clexulator() {}

    Clexulator(std::string name,
               boost::filesystem::path dirpath,
               PrimNeighborList &nlist,
               const Logging &logging,
               std::string compile_options,
               std::string so_options) {

      namespace fs = boost::filesystem;

      // Construct the RuntimeLibrary that will store the loaded clexulator library
      try {
        m_lib = std::make_shared<RuntimeLibrary>(
                  (dirpath / name).string(),
                  compile_options,
                  so_options,
                  "compile time depends on how many basis functions are included");
      }
      catch(std::exception &e) {
        logging.log() << "Clexulator construction failed: could not construct runtime library." << std::endl;
        throw;
      }

      // Get the Clexulator factory function
      std::function<Clexulator_impl::Base* (void)> factory;
      factory = m_lib->get_function<Clexulator_impl::Base* (void)>("make_" + name);

      // Use the factory to construct the clexulator and store it in m_clex
      m_clex.reset(factory());

      // Check nlist has the right weight_matrix
      if(nlist.weight_matrix() != m_clex->weight_matrix()) {
        std::cerr << "Error in Clexulator constructor: weight matrix of neighbor "
                  "list does not match the weight matrix used to print the "
                  "clexulator." << std::endl;
        std::cerr << "nlist weight matrix: \n" << nlist.weight_matrix() << std::endl;
        std::cerr << "clexulator weight matrix: \n" << m_clex->weight_matrix() << std::endl;
        throw std::runtime_error(
          "Error in Clexulator constructor: weight matrix of neighbor list does "
          "not match the weight matrix used to print the clexulator. Try 'casm bset -uf'.");
      }

      // Expand the given neighbor list as necessary
      nlist.expand(neighborhood().begin(), neighborhood().end());

    }


    Clexulator(const Clexulator &B) :
      m_name(B.name()),
      m_lib(B.m_lib) {

      if(B.m_clex.get() != nullptr) {
        m_clex.reset(B.m_clex->clone().release());
      }
    }

    Clexulator(Clexulator &&B) {
      swap(*this, B);
    }

    ~Clexulator() {
      // ensure Clexulator is deleted before library
      delete m_clex.release();
    }

    Clexulator &operator=(Clexulator B) {

      swap(*this, B);

      return *this;
    }

    friend void swap(Clexulator &first, Clexulator &second) {

      using std::swap;

      swap(first.m_name, second.m_name);
      swap(first.m_clex, second.m_clex);
      swap(first.m_lib, second.m_lib);
    }

    bool initialized() const {
      return m_lib.get() != nullptr;
    }

    std::string name() const {
      return m_name;
    }

    size_type nlist_size() const {
      return m_clex->nlist_size();
    }

    size_type corr_size() const {
      return m_clex->corr_size();
    }

    const std::set<UnitCellCoord> &neighborhood() const {
      return m_clex->neighborhood();
    }

    const std::set<UnitCellCoord> &neighborhood(size_type linear_orbit_index) const {
      return m_clex->neighborhood(linear_orbit_index);
    }

    const PrimNeighborList::Matrix3Type &weight_matrix() const {
      return m_clex->weight_matrix();
    }

    void set_config_occ(const int *_occ_ptr) {
      return m_clex->set_config_occ(_occ_ptr);
    }

    void set_nlist(const long int *_nlist_ptr) {
      return m_clex->set_nlist(_nlist_ptr);
    };

    void calc_global_corr_contribution(double *corr_begin) const {
      m_clex->calc_global_corr_contribution(corr_begin);
    }

    void calc_restricted_global_corr_contribution(double *corr_begin, size_type const *ind_list_begin, size_type const *ind_list_end) const {
      m_clex->calc_restricted_global_corr_contribution(corr_begin, ind_list_begin, ind_list_end);
    }

    void calc_point_corr(int b_index, double *corr_begin) const {
      m_clex->calc_point_corr(b_index, corr_begin);
    }

    void calc_restricted_point_corr(int b_index, double *corr_begin, size_type const *ind_list_begin, size_type const *ind_list_end) const {
      m_clex->calc_restricted_point_corr(b_index, corr_begin, ind_list_begin, ind_list_end);
    }

    void calc_delta_point_corr(int b_index, int occ_i, int occ_f, double *corr_begin) const {
      m_clex->calc_delta_point_corr(b_index, occ_i, occ_f, corr_begin);
    }

    void calc_restricted_delta_point_corr(int b_index,
                                          int occ_i,
                                          int occ_f,
                                          double *corr_begin,
                                          size_type const *ind_list_begin,
                                          size_type const *ind_list_end) const {
      m_clex->calc_restricted_delta_point_corr(b_index, occ_i, occ_f, corr_begin, ind_list_begin, ind_list_end);
    }


  private:

    std::string m_name;
    std::unique_ptr<Clexulator_impl::Base> m_clex;
    std::shared_ptr<RuntimeLibrary> m_lib;

  };

}

#endif