cal_pLpR.h

Go to the documentation of this file.

 
#include <cmath>
#include <vector>
#include <map>
#include <tuple>
#include <complex>
#include <memory>
#include "source_cell/unitcell.h"
#include "source_basis/module_nao/two_center_integrator.h"
#include "source_cell/module_neighbor/sltk_grid_driver.h"
#include "source_cell/module_neighbor/sltk_atom_arrange.h"
 
namespace ModuleIO
{
    std::complex<double> cal_LzijR(
        const std::unique_ptr<TwoCenterIntegrator>& calculator,
        const int it, const int ia, const int il, const int iz, const int mi,
        const int jt, const int ja, const int jl, const int jz, const int mj,
        const ModuleBase::Vector3<double>& vR);
 
    std::complex<double> cal_LyijR(
        const std::unique_ptr<TwoCenterIntegrator>& calculator,
        const int it, const int ia, const int il, const int iz, const int im,
        const int jt, const int ja, const int jl, const int jz, const int jm,
        const ModuleBase::Vector3<double>& vR);
 
    std::complex<double> cal_LxijR(
        const std::unique_ptr<TwoCenterIntegrator>& calculator,
        const int it, const int ia, const int il, const int iz, const int im,
        const int jt, const int ja, const int jl, const int jz, const int jm,
        const ModuleBase::Vector3<double>& vR);
    
    // the calculation of <phi_i|Lx/Ly/Lz|phi_j> matrix elements will be outputted
    // in the way that indexed by:
    // it, ia, il, iz, im, iRx, iRy, iRz, jt, ja, jl, jz, jm, in which the
    // iRx, iRy, iRz are the indices of the supercell in which the two-center-integral
    // it and jt are indexes of atomtypes,
    // ia and ja are indexes of atoms within the atomtypes,
    // il and jl are indexes of the angular momentum,
    // iz and jz are indexes of the zeta functions
    // im and jm are indexes of the magnetic quantum numbers.
    // The output is a complex number, which is the value of the matrix element.
    // Always the matrix is quite large, so direct print to file.
    class AngularMomentumCalculator
    {
        public:
            // the default constructor is meaningless
            AngularMomentumCalculator() = delete;
            AngularMomentumCalculator(
                const std::string& orbital_dir,
                const UnitCell& ucell,
                const double& search_radius,
                const int tdestructor,
                const int tgrid,
                const int tatom,
                const bool searchpbc,
                std::ofstream* ptr_log = nullptr,
                const int rank = 0);
            ~AngularMomentumCalculator() = default;
 
            void calculate(const std::string& prefix,
                           const std::string& outdir,
                           const UnitCell& ucell,
                           const int precision = 10,
                           const int rank = 0);
 
        private:
            // ofsrunning
            std::ofstream* ofs_;
            // the two-center-integrator
            std::unique_ptr<TwoCenterIntegrator> calculator_;
            // the spherical bessel transformer
            ModuleBase::SphericalBesselTransformer sbt_;
            // the radial collection
            std::unique_ptr<RadialCollection> orb_;
 
            // neighboring searcher
            std::unique_ptr<Grid_Driver> neighbor_searcher_;
 
            void kernel(std::ofstream* ofs, 
                        const UnitCell& ucell, 
                        const char dir = 'x',
                        const int precision = 10);
    };
} // namespace ModuleIO