chi0.h

Go to the documentation of this file.

 
#pragma once
#include <vector>
#include <set>
#include "meanfield.h"
#include "timefreq.h"
#include "atoms.h"
#include "ri.h"
#include "vector3_order.h"
 
using std::vector;
 
class Chi0
{
    private:
        size_t gf_save;
        size_t gf_discard;
 
        map<int, atom_mapping<map<Vector3_Order<int>, map<double, matrix>>>::pair_t_old> gf_is_R_tau;
 
        vector<Vector3_Order<int>> Rlist_gf;
        map<double, map<Vector3_Order<double>, atom_mapping<ComplexMatrix>::pair_t_old>> chi0_q;
        void build_gf_Rt(Vector3_Order<int> R, double tau);
        /*
         @todo add threshold parameter. Maybe in the class level?
         */
        void build_chi0_q_space_time(const Cs_LRI &Cs,
                                     const Vector3_Order<int> &R_period,
                                     const vector<atpair_t> &atpairs_ABF,
                                     const vector<Vector3_Order<double>> &qlist);
        void build_chi0_q_space_time_atom_pair_routing(const Cs_LRI &Cs,
                                                       const Vector3_Order<int> &R_period,
                                                       const vector<atpair_t> &atpairs_ABF,
                                                       const vector<Vector3_Order<double>> &qlist);
        void build_chi0_q_space_time_R_tau_routing(const Cs_LRI &Cs,
                                                   const Vector3_Order<int> &R_period,
                                                   const vector<atpair_t> &atpairs_ABF,
                                                   const vector<Vector3_Order<double>> &qlist);
        void build_chi0_q_space_time_LibRI_routing(const Cs_LRI &Cs,
                                                   const Vector3_Order<int> &R_period,
                                                   const vector<atpair_t> &atpairs_ABF,
                                                   const vector<Vector3_Order<double>> &qlist);
 
        // TODO: implement the conventional method
        void build_chi0_q_conventional(const Cs_LRI &Cs,
                                       const Vector3_Order<int> &R_period,
                                       const vector<atpair_t> &atpairs_ABF,
                                       const vector<Vector3_Order<double>> &qlist);
        matrix compute_chi0_s_munu_tau_R(const atpair_R_mat_t &Cs_IJR,
                                         const Vector3_Order<int> &R_period, 
                                         int spin_channel,
                                         atom_t mu, atom_t nu, double tau, Vector3_Order<int> R);
        // copy some reshape method inside chi0, test performance
        /* matrix reshape_Cs(const size_t n1, const size_t n2, const size_t n3, const std::shared_ptr<matrix> &Cs); */
        /* matrix reshape_dim_Cs(const size_t n1, const size_t n2, const size_t n3, const std::shared_ptr<matrix> &Cs);//(n1*n2,n3) -> (n1,n2*n3) */
        /* matrix reshape_mat(const size_t n1, const size_t n2, const size_t n3, const matrix &mat); */
        /* matrix reshape_mat_21(const size_t n1, const size_t n2, const size_t n3, const matrix &mat); //(n1,n2*n3) -> (n1*n2,n3) */
    public:
        double gf_R_threshold;
        MeanField mf;
        const vector<Vector3_Order<double>> &klist;
        TFGrids tfg;
        Chi0(const MeanField &mf_in,
             const vector<Vector3_Order<double>> &klist_in,
             unsigned n_tf_grids):
            mf(mf_in), klist(klist_in), tfg(n_tf_grids) { gf_R_threshold = 1e-9; }
        ~Chi0() {};
        void build(const Cs_LRI &Cs,
                   const vector<Vector3_Order<int>> &Rlist,
                   const Vector3_Order<int> &R_period,
                   const vector<atpair_t> &atpair_ABF,
                   const vector<Vector3_Order<double>> &qlist,
                   TFGrids::GRID_TYPES gt, bool use_space_time);
        const map<double, map<Vector3_Order<double>, atom_mapping<ComplexMatrix>::pair_t_old>> & get_chi0_q() const { return chi0_q; }
        void free_chi0_q(const double freq, const Vector3_Order<double> q);
        
};
 
 
map<size_t, matrix> compute_chi0_munu_tau_LRI_saveN_noreshape(const map<size_t, atom_mapping<matrix>::pair_t_old> &gf_occ_ab_t,
                                                              const map<size_t, atom_mapping<matrix>::pair_t_old> &gf_unocc_ab_t,
                                                              const atpair_R_mat_t &LRI_Cs,
                                                              const vector<Vector3_Order<int>> &Rlist, const Vector3_Order<int> &R_period, 
                                                              const vector<int> iRs,
                                                              atom_t mu, atom_t nu);