radial_proj.h

Go to the documentation of this file.

#ifndef RADIAL_PROJECTION_H
#define RADIAL_PROJECTION_H
 
#include "source_base/vector3.h"
#include "source_base/cubic_spline.h"
#include <memory>
#include <vector>
#include <complex>
#include <map>
#include <utility>
#include <algorithm>
 
#include "source_cell/unitcell.h"
#include "source_psi/psi.h"
#include "source_basis/module_pw/pw_basis_k.h"
 
namespace RadialProjection
{
    class RadialProjector
    {
        public:
            static void _build_backward_map(const std::vector<std::vector<int>>& it2iproj,
                                            const std::vector<int>& iproj2l,
                                            std::vector<int>& irow2it,
                                            std::vector<int>& irow2iproj,
                                            std::vector<int>& irow2m);
            static void _build_forward_map(const std::vector<std::vector<int>>& it2ia,
                                           const std::vector<std::vector<int>>& it2iproj,
                                           const std::vector<int>& iproj2l,
                                           std::map<std::tuple<int, int, int, int>, int>& itiaiprojm2irow);
        public:
            RadialProjector(const bool realspace = false) {}
            ~RadialProjector() {}
 
            // it is more feasible to build interpolation table. this function will tabulate
            // for those functions. This function will write the in-build tab_, to place the
            // values of Jl[f](q) for each q and l.
            // Here I provide two versions of tabulate, one for the case may be capable to 
            // avoid the memory copy operation, and the other one is for the case of 
            // std::vector<double> and std::vector<std::vector<double>>.
            void _build_sbt_tab(const int nr,
                                const double* r,
                                const std::vector<double*>& radials,
                                const std::vector<int>& l,
                                const int nq,                             //< GlobalV::DQ
                                const double& dq);                        //< GlobalV::NQX
            void _build_sbt_tab(const std::vector<double>& r,
                                const std::vector<std::vector<double>>& radials,
                                const std::vector<int>& l,
                                const int nq,                             //< GlobalV::DQ
                                const double& dq);                        //< GlobalV::NQX
            // compatibility concern: for FS_Nonlocal_tools. Will not call sbtft so need omega
            void _build_sbt_tab(const std::vector<int>& nproj,
                                const std::vector<double>& r,
                                const std::vector<std::vector<double>>& radials,
                                const std::vector<int>& l,
                                const int nq,                             //< GlobalV::DQ
                                const double& dq,                         //< GlobalV::NQX
                                const double& omega,
                                const int npol,
                                ModuleBase::realArray& tab,
                                ModuleBase::matrix& nhtol);
            void sbtft(const std::vector<ModuleBase::Vector3<double>>& qs,
                       std::vector<std::complex<double>>& out,
                       const char type = 'r',                                   // 'r' for ket |>, 'l' for bra <|
                       const double& omega = 1.0,
                       const double& tpiba = 1.0);                                  // 'n' for no gradient, 'x', 'y', 'z' for gradient in x, y, z direction
            
            void sbfft(); // interface for SBFFT
 
 
        private:
            std::unique_ptr<ModuleBase::CubicSpline> cubspl_;
            std::vector<int> l_;
    };
  
    void _mask_func(std::vector<double>& mask);
 
    void _do_mask_on_radial(const int nr1,
                            const double* r,
                            const double* in,
                            const int nr2,
                            const double* mask,
                            double* out);
}
 
#endif // RADIAL_PROJECTION_H