klist.h

Go to the documentation of this file.

#ifndef K_VECTORS_H
#define K_VECTORS_H
 
#include "source_base/global_function.h"
#include "source_base/global_variable.h"
#include "source_base/matrix3.h"
#include "source_cell/unitcell.h"
#include "parallel_kpoints.h"
#include "k_vector_utils.h"
#include <vector>
 
class K_Vectors
{
public:
    std::vector<ModuleBase::Vector3<double>> kvec_c; 
    std::vector<ModuleBase::Vector3<double>> kvec_d; 
 
    std::vector<double> wk; 
 
    std::vector<int> ngk; 
    std::vector<int> isk; 
 
    int nmp[3]={0};                 
    std::vector<int> kl_segids; 
 
    std::vector<std::map<int, ModuleBase::Vector3<double>>> kstars;
 
    bool kc_done = false;
    bool kd_done = false;
 
    K_Vectors(){};
    ~K_Vectors(){};
    K_Vectors& operator=(const K_Vectors&) = default;
    K_Vectors& operator=(K_Vectors&& rhs) = default;
 
    Parallel_Kpoints para_k; 
 
 
    void set(const UnitCell& ucell,
        const ModuleSymmetry::Symmetry& symm,
        const std::string& k_file_name,
        const int& nspin,
        const ModuleBase::Matrix3& reciprocal_vec,
        const ModuleBase::Matrix3& latvec,
        std::ofstream& ofs);
 
    int get_nks() const
    {
        return this->nks;
    }
 
    int get_nkstot() const
    {
        return this->nkstot;
    }
 
    int get_nkstot_full() const
    {
        return this->nkstot_full;
    }
 
    double get_koffset(const int i) const
    {
        return this->koffset[i];
    }
 
    int get_k_nkstot() const
    {
        return this->k_nkstot;
    }
 
    int get_nspin() const
    {
        return this->nspin;
    }
 
    std::string get_k_kword() const
    {
        return this->k_kword;
    }
 
    void set_nks(int value)
    {
        this->nks = value;
    }
 
    void set_nkstot(int value)
    {
        this->nkstot = value;
    }
 
    void set_nkstot_full(int value)
    {
        this->nkstot_full = value;
    }
 
    void set_nspin(int value)
    {
        this->nspin = value;
    }
 
    bool get_is_mp() const
    {
        return is_mp;
    }
 
    std::vector<int> ik2iktot; 
    std::vector<int> ibz_index; 
 
    void update_use_ibz(const int& nkstot_ibz,
                        const std::vector<ModuleBase::Vector3<double>>& kvec_d_ibz,
                        const std::vector<double>& wk_ibz);
 
  private:
    int nks = 0;         
    int nkstot = 0;      
    int nkstot_full = 0; 
 
    int nspin = 0;
    double koffset[3] = {0.0}; // used only in automatic k-points.
    std::string k_kword;       // LiuXh add 20180619
    int k_nkstot = 0;          // LiuXh add 20180619 // WHAT IS THIS?????
    bool is_mp = false;        // Monkhorst-Pack
 
    void renew(const int& kpoint_number);
 
    // step 1 : generate kpoints
 
    bool read_kpoints(const UnitCell& ucell,
                      const std::string& fn); // return 0: something wrong.
 
    void interpolate_k_between(std::ifstream& ifk, std::vector<ModuleBase::Vector3<double>>& kvec);
 
    void Monkhorst_Pack(const int* nmp_in, const double* koffset_in, const int tipo);
 
    double Monkhorst_Pack_formula(const int& k_type, const double& offset, const int& n, const int& dim);
 
    // step 2 : set both kvec and kved; normalize weight
 
    //    void set_both_kvec(const ModuleBase::Matrix3& G, const ModuleBase::Matrix3& R, std::string& skpt);
 
    void normalize_wk(const int& degspin);
 
 
 
    // step 4 : *2 kpoints.
 
    void set_kup_and_kdw();
 
    void cal_ik_global();
#ifdef __MPI
    friend void KVectorUtils::kvec_mpi_k(K_Vectors& kvec);
#endif
};
#endif // KVECT_H