radial_set.h

Go to the documentation of this file.

#ifndef RADIAL_SET_H_
#define RADIAL_SET_H_
 
#include <map>
#include <memory>
#include <string>
#include <utility>
 
#include "source_base/spherical_bessel_transformer.h"
#include "source_basis/module_nao/numerical_radial.h"
#include "source_basis/module_ao/ORB_nonlocal.h"
#include "source_basis/module_ao/ORB_atomic.h"
 
class RadialSet
{
  public:
    RadialSet() = default;
    RadialSet(const RadialSet&);            
    RadialSet& operator=(const RadialSet&); 
    virtual RadialSet* clone() const = 0;   
 
    virtual ~RadialSet();
 
    // FIXME The following functions are not pure virtual because each
    // derived class may not need all of them. However, it is not a good
    // design. Such functions will be removed in the future; their
    // functionalities will be moved to the constructors of corresponding
    // derived classes.
 
 
    virtual void build(const std::string&,             
                       const int = 0,                  
                       std::ofstream* const = nullptr, 
                       const int = 0                   
                       ) {}
 
    virtual void build(const Numerical_Nonlocal&,     
                       const int = 0,                 
                       std::ofstream* const = nullptr 
                       ) {}
 
    virtual void build(const int = 0,                         
                       const double = 1.0,                    
                       const bool = false,                    
                       const int = 0,                         
                       const double = 10.0,                   
                       const double = 0.01,                   
                       const double = 1e-6,                   
                       const int = 0,                         
                       const std::string = "",                
                       const std::string = "minimal-valence", 
                       std::ofstream* const = nullptr         
                       ) {}
 
    virtual void build(const std::string&,             
                       const int,                      
                       const double,                   
                       const double,                   
                       std::ofstream* const = nullptr, 
                       const int = 0                   
                       ) {}
 
    virtual void build(const int,                   
                       const int,                   
                       const double,                
                       const double = 0.1,          
                       const double = 0.01,         
                       const int = 0,               
                       std::ofstream* = nullptr,    
                       const int = 0                
    ) {};
 
    void write_abacus_orb(const std::string&,      
                          const int = 0) const;    
 
 
    virtual void to_numerical_orbital(Numerical_Orbital&,
                                      const int nk_legacy = 4005, // equivalent to lcao_ecut = 1600
                                      const double lcao_dk = 0.01
                                      ) const;
 
    const std::string& symbol() const { return symbol_; }
    int itype() const { return itype_; }
    int lmax() const { return lmax_; }
    double rcut_max() const { return rcut_max_; }
 
    int nzeta(const int l) const { return (l >= 0 && l <= lmax_) ? nzeta_[l] : 0; }
    int nzeta_max() const { return nzeta_max_; }
    int nchi() const { return nchi_; }
 
    const NumericalRadial& chi(const int l, const int izeta);
    const NumericalRadial* cbegin() const { return chi_; }
    const NumericalRadial* cend() const { return chi_ + nchi_; }
 
    void set_transformer(ModuleBase::SphericalBesselTransformer sbt, const int update = 0);
 
    void set_grid(const bool for_r_space, const int ngrid, const double* grid, const char mode = 'i');
 
    void set_uniform_grid(const bool for_r_space,
                          const int ngrid,
                          const double cutoff,
                          const char mode = 'i',
                          const bool enable_fft = false);
 
  protected:
    std::string symbol_ = "";   
    int itype_ = 0;             
    int lmax_ = -1;             
    double rcut_max_ = 0.0;     
 
    int* nzeta_ = nullptr;      
    int nzeta_max_ = 0;         
    int nchi_ = 0;              
 
    NumericalRadial* chi_ = nullptr; 
 
    int* index_map_ = nullptr;
 
    void cleanup();
 
    int index(const int l, const int izeta) const;
 
    void indexing();
 
    void set_rcut_max();
};
 
#endif