sphbes_radials.h

Go to the documentation of this file.

#ifndef SPHBES_RADIALS_H_
#define SPHBES_RADIALS_H_
 
#include <map>
#include <vector>
#include <string>
 
#include "source_basis/module_nao/radial_set.h"
 
class SphbesRadials : public RadialSet
{
  public:
    SphbesRadials() {}
    SphbesRadials(const SphbesRadials& other):
        RadialSet(other), sigma_(other.sigma_), dr_(other.dr_), coeff_(other.coeff_) {}
 
    SphbesRadials& operator=(const SphbesRadials& rhs);
    SphbesRadials* clone() const { return new SphbesRadials(*this); } // covariant return type
 
    ~SphbesRadials() {} // ~RadialSet() is called automatically
 
    void build(const std::string& file,
               const double dr = 0.01,
               const int itype = 0,
               std::ofstream* ptr_log = nullptr,
               const int rank = 0
    );
 
    void build(const int lmax,
               const int nbes,
               const double rcut,
               const double sigma,
               const double dr = 0.01,
               const int itype = 0,
               std::ofstream* ptr_log = nullptr,
               const int rank = 0
    );
 
    double sigma() const { return sigma_; }
    double dr() const { return dr_; }
    std::vector<double> const& coeff(const int l, const int izeta) const { return coeff_.at(std::make_pair(l, izeta)); }
 
  private:
 
    double sigma_ = 0.0;
 
    double dr_ = 0.01;
 
    std::map<std::pair<int,int>, std::vector<double>> coeff_;
 
    void read_coeff(std::ifstream& ifs,
                    std::ofstream* ptr_log = nullptr,
                    const int rank = 0);
 
    void build_radset(const bool normalize = true);
 
    std::string extract(std::string const& str, std::string const& keyword);
 
    std::vector<std::string> split(std::string const& str, const char* delim = " \n\t");
 
    std::vector<double> sphbes_comb(const int l,
                                    std::vector<double> const& coeff_q, 
                                    double rcut,
                                    double dr,
                                    std::vector<double> const& q
    );
 
    double smooth(double r, double rcut, double sigma);
 
};
 
#endif