radial_collection.h

Go to the documentation of this file.

#ifndef RADIAL_COLLECTION_H_
#define RADIAL_COLLECTION_H_
 
#include <numeric>
#include <string>
#include <memory>
 
#include "source_basis/module_nao/radial_set.h"
 
class RadialCollection
{
  public:
    RadialCollection() = default;
    RadialCollection(const RadialCollection& other);          
    RadialCollection& operator=(const RadialCollection& rhs); 
 
    ~RadialCollection();
 
    void build(const int nfile, const std::string* const file, const char ftype = '\0');
 
    void build(const int ntype, Numerical_Nonlocal* const nls);
 
    void build(const RadialCollection* nls, double radius = 0.0);
 
    void build(const int ntype, 
               const double* const charges, 
               const bool with_slater_screening,
               const int* const nmax, 
               const std::string* symbols = nullptr,
               const double conv_thr = 1e-10,
               const std::string* strategies = nullptr,
               const int& rank = 0);
               
    void build(const int ntype, 
               const std::string* const file, 
               const double* const screening_coeff,
               const double conv_thr = 1e-10,
               const int& rank = 0);
 
    void build(const int lmax, 
               const int nbes,
               const double rcut,
               const double sigma,
               const double dr
               );
 
    const std::string& symbol(const int itype) const { return radset_[itype]->symbol(); }
    int ntype() const { return ntype_; }
    int lmax(const int itype) const { return radset_[itype]->lmax(); }
    int lmax() const { return lmax_; }
    double rcut_max(const int itype) const { return radset_[itype]->rcut_max(); }
    double rcut_max() const { return rcut_max_; }
    int nzeta(const int itype, const int l) const { return radset_[itype]->nzeta(l); }
    int nzeta_max(const int itype) const { return radset_[itype]->nzeta_max(); }
    int nzeta_max() const { return nzeta_max_; }
    int nchi() const { return nchi_; }
    int nchi(const int itype) const { return radset_[itype]->nchi(); }
 
    const NumericalRadial& operator()(const int itype, const int l, const int izeta) const
    {
        assert(itype >= 0 && itype < ntype_);
        return radset_[itype]->chi(l, izeta);
    }
 
    const RadialSet& operator()(const int itype) const
    {
        assert(itype >= 0 && itype < ntype_);
        return *radset_[itype];
    }
 
    const NumericalRadial** cbegin() const
    {
        assert(ntype_ > 0);
        return iter_;
    }
 
    const NumericalRadial** cend() const
    {
        assert(ntype_ > 0);
        return iter_ + nchi_;
    }
 
    const NumericalRadial** cbegin(const int l) const
    {
        assert(ntype_ > 0 && l >= 0 && l <= lmax_);
        return iter_ + std::accumulate(nl_, nl_ + l, 0);
    }
 
    const NumericalRadial** cend(const int l) const
    {
        assert(ntype_ > 0 && l >= 0 && l <= lmax_);
        return iter_ + std::accumulate(nl_, nl_ + l + 1, 0);
    }
 
    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);
 
    void to_file(const std::string& appendix,                
                 const std::string& format = "abacus_orb"    
                 ) const;
 
  private:
    int ntype_ = 0;         
    int lmax_ = -1;         
    int nchi_ = 0;          
    int nzeta_max_ = 0;     
    double rcut_max_ = 0.0; 
 
    RadialSet** radset_ = nullptr;
 
    const NumericalRadial** iter_ = nullptr;
 
    int* nl_ = nullptr;
 
    void cleanup();
 
    void iter_build();
 
    void set_rcut_max();
 
    char check_file_type(const std::string& file) const;
};
 
#endif