lr_util.h

Go to the documentation of this file.

#pragma once
#include <cstddef>
#include <vector>
#include <utility>
#include "source_base/matrix.h"
#include "source_base/complexmatrix.h"
#include "source_base/parallel_2d.h"
#include "source_psi/psi.h"
#include <ATen/core/tensor.h>
#include "source_basis/module_pw/pw_basis.h"
 
using DAT = container::DataType;
using DEV = container::DeviceType;
 
#ifndef TO_COMPLEX_H
#define TO_COMPLEX_H
template <typename T> struct ToComplex;
template <> struct ToComplex<double> { using type = std::complex<double>; };
template <> struct ToComplex<std::complex<double>> { using type = std::complex<double>; };
template <> struct ToComplex<float> { using type = std::complex<float>; };
template <> struct ToComplex<std::complex<float>> { using type = std::complex<float>; };
#endif
 
namespace LR_Util
{
 
    template <typename TCell>
    int cal_nelec(const TCell& ucell);
    
    int cal_nocc(int nelec);
    
    std::pair<ModuleBase::matrix, std::vector<std::pair<int, int>>>
        set_ix_map_diagonal(bool mode, int nc, int nv);
 
    // Operators to calculate xc kernel have been moved into lr_util_xc.hpp.
 
    //====== newers and deleters========
    template <typename T>
    void _deallocate_2order_nested_ptr(T** p2, size_t size);
    template <typename T>
    void _allocate_2order_nested_ptr(T**& p2, size_t size1, size_t size2);
 
    template<typename T> ct::Tensor newTensor(const ct::TensorShape& shape)
    {
        return ct::Tensor(ct::DataTypeToEnum<T>::value, ct::DeviceTypeToEnum<base_device::DEVICE_CPU>::value, shape);
    }
 
    template<typename T>
    void matsym(const T* in, const int n, T* out);
    template<typename T>
    void matsym(T* inout, const int n);
#ifdef __MPI
    template<typename T>
    void matsym(const T* in, const int n, const Parallel_2D& pmat, T* out);
    template<typename T>
    void matsym(T* inout, const int n, const Parallel_2D& pmat);
#endif
 
    template<typename T, typename Device>
    psi::Psi<T, Device> k1_to_bfirst_wrapper(const psi::Psi<T, Device>& psi_kfirst, int nk_in, int nbasis_in);
    template<typename T, typename Device>
    psi::Psi<T, Device> bfirst_to_k1_wrapper(const psi::Psi<T, Device>& psi_bfirst);
 
    // pack the process to setup 2d divion reusing blacs_ctxt of a new 2d-matrix
    void setup_2d_division(Parallel_2D& pv, int nb, int gr, int gc);
 
#ifdef __MPI
    // pack the process to setup 2d divion reusing blacs_ctxt of an existing 2d-matrix
    void setup_2d_division(Parallel_2D& pv, int nb, int gr, int gc, const int& blacs_ctxt_in);
    template <typename T>
    void gather_2d_to_full(const Parallel_2D& pv, const T* submat, T* fullmat, bool col_first, int global_nrow, int global_ncol);
#endif
 
    void diag_lapack(const int& n, double* mat, double* eig);
    void diag_lapack(const int& n, std::complex<double>* mat, double* eig);
    void diag_lapack_nh(const int& n, double* mat, std::complex<double>* eig);
    void diag_lapack_nh(const int& n, std::complex<double>* mat, std::complex<double>* eig);
 
    std::string tolower(const std::string& str);
    std::string toupper(const std::string& str);
}
#include "lr_util.hpp"