1. remove LRI::cal_loop4()

Author: PeizeLin

include/RI/physics/Exx.h

@@ -66,8 +66,6 @@ class Exx
 		const std::array<std::array<std::map<TA, std::map<TAC, Tensor<Tdata>>>,Npos>,Npos> &dVRs,
 		const Tdata_real &threshold_dVR,
 		const std::string &save_name_suffix="");
-	void set_csm_threshold(
-		const Tdata_real &threshold) { this->lri.csm.set_threshold(threshold); }
 
 	void cal_Hs(
 		const std::array<std::string,3> &save_names_suffix={"","",""});		// "Cs","Vs","Ds"

include/RI/physics/Exx.hpp

@@ -202,7 +202,6 @@ void Exx<TA,Tcell,Ndim,Tdata>::cal_Hs(
 	}
 
 	std::vector<std::map<TA, std::map<TAC, Tensor<Tdata>>>> Hs_vec(1);
-	this->lri.coefficients = {nullptr};
 	this->lri.cal_loop3(
 		{Label::ab_ab::a0b0_a1b1,
 		 Label::ab_ab::a0b0_a1b2,
@@ -317,92 +316,6 @@ void Exx<TA,Tcell,Ndim,Tdata>::cal_force(
 }
 
 
-/*
-template<typename TA, typename Tcell, std::size_t Ndim, typename Tdata>
-void Exx<TA,Tcell,Ndim,Tdata>::cal_stress(
-	const std::array<std::string,5> &save_names_suffix)						// "Cs","Vs","Ds","dCs","dVs"
-{
-	assert(this->flag_finish.stru);
-	assert(this->flag_finish.C);
-	assert(this->flag_finish.V);
-	assert(this->flag_finish.D);
-	assert(this->flag_finish.dC);
-	assert(this->flag_finish.dV);
-
-	Cell_Nearest<TA,Tcell,Ndim,Tpos,Npos> cell_nearest;
-	cell_nearest.init(this->atoms_pos, this->latvec, this->period);
-
-	using namespace Array_Operator;
-	auto get_delta_pos = [this, &cell_nearest](
-		const TA &Ax, const TA &Ay, const std::array<Tcell,Ndim> &celly, const std::size_t &ipos1)
-		-> Tpos
-	{
-		Tpos delta_pos = this->atoms_pos[Ay][ipos1] - this->atoms_pos[Ax][ipos1];
-		const std::array<Tcell,Ndim> celly_nearest = cell_nearest.get_cell_nearest_discrete(Ax, Ay, celly);
-		for(std::size_t idim=0; idim<Ndim; ++idim)
-			delta_pos += celly_nearest[idim] * this->latvec[idim][ipos1];
-		return delta_pos;
-	};
-
-	this->stress = Tensor<Tdata>({Npos, Npos});
-
-	this->lri.data_ab_name[Label::ab::a1b1] = this->lri.data_ab_name[Label::ab::a2b1] = "Ds_"+save_names_suffix[2];
-	for(std::size_t ipos0=0; ipos0<Npos; ++ipos0)
-	{
-		std::vector<std::map<TA,std::map<TAC,Tensor<Tdata>>>> dHs_vec(Npos);
-		this->lri.coefficients.resize(Npos);
-
-		this->lri.data_ab_name[Label::ab::a   ] = "dCs_"+std::to_string(ipos0)+"_"+save_names_suffix[3];
-		this->lri.data_ab_name[Label::ab::a0b0] = "Vs_"+save_names_suffix[1];
-		this->lri.data_ab_name[Label::ab::b   ] = "Cs_"+save_names_suffix[0];
-
-		for(std::size_t ipos1=0; ipos1<Npos; ++ipos1)
-			this->lri.coefficients[ipos1] =
-				[this,ipos1,&get_delta_pos](
-					const Label::ab_ab &label, const TA &Aa01, const TAC &Aa2, const TAC &Ab01, const TAC &Ab2) -> Tdata
-				{	return get_delta_pos(Aa01, Aa2.first, Aa2.second, ipos1);	};
-
-		this->lri.cal(
-			{Label::ab_ab::a0b0_a1b1,
-			 Label::ab_ab::a0b0_a2b1},
-			dHs_vec);
-
-		this->lri.data_ab_name[Label::ab::a   ] = "Cs_"+save_names_suffix[0];
-		this->lri.data_ab_name[Label::ab::a0b0] = "dVs_"+std::to_string(ipos0)+"_"+save_names_suffix[4];
-
-		for(std::size_t ipos1=0; ipos1<Npos; ++ipos1)
-			this->lri.coefficients[ipos1] =
-				[this,ipos1,&get_delta_pos](
-					const Label::ab_ab &label, const TA &Aa01, const TAC &Aa2, const TAC &Ab01, const TAC &Ab2) -> Tdata
-				{	return get_delta_pos(Aa01, Ab01.first, Ab01.second, ipos1);	};
-
-		this->lri.cal(
-			{Label::ab_ab::a0b0_a1b1,
-			 Label::ab_ab::a0b0_a2b1},
-			dHs_vec);
-
-		this->lri.data_ab_name[Label::ab::a0b0] = "Vs_"+save_names_suffix[1];
-		this->lri.data_ab_name[Label::ab::b   ] = "dCs_"+std::to_string(ipos0)+"_"+save_names_suffix[3];
-
-		for(std::size_t ipos1=0; ipos1<Npos; ++ipos1)
-			this->lri.coefficients[ipos1] =
-				[this,ipos1,&get_delta_pos](
-					const Label::ab_ab &label, const TA &Aa01, const TAC &Aa2, const TAC &Ab01, const TAC &Ab2) -> Tdata
-				{	return get_delta_pos(Ab01.first, Ab2.first, (Ab2.second-Ab01.second)%this->period, ipos1); };
-
-		this->lri.cal(
-			{Label::ab_ab::a0b0_a1b1,
-			 Label::ab_ab::a0b0_a2b1},
-			dHs_vec);
-
-		for(std::size_t ipos1=0; ipos1<Npos; ++ipos1)
-			this->stress(ipos0,ipos1) = post_2D.cal_energy(
-				this->post_2D.saves["Ds_"+save_names_suffix[2]],
-				this->post_2D.set_tensors_map2(dHs_vec[ipos1]));
-	}
-}
-*/
-
 
 template<typename TA, typename Tcell, std::size_t Ndim, typename Tdata>
 void Exx<TA,Tcell,Ndim,Tdata>::cal_stress(

include/RI/physics/GW.h

@@ -37,8 +37,6 @@ class G0W0
 	void set_Cs(
 		const std::map<TA, std::map<TAC, Tensor<Tdata>>> &Cs,
 		const Tdata_real &threshold_C);
-	void set_csm_threshold(
-		const Tdata_real &threshold) { this->lri.csm.set_threshold(threshold); }
 
 	void cal_Sigc(
 		const std::map<TA, std::map<TAC, Tensor<Tdata>>> gf_tau,

include/RI/physics/GW.hpp

@@ -65,7 +65,6 @@ void G0W0<TA, Tcell, Ndim, Tdata>::cal_Sigc(
 		{{"threshold_filter", threshold_W}} );
 
 	std::vector<std::map<TA, std::map<TAC, Tensor<Tdata>>>> Sigc_vec(1);
-	this->lri.coefficients = {nullptr};
 	this->lri.cal_loop3(
 		{Label::ab_ab::a0b0_a1b1,
 		 Label::ab_ab::a0b0_a1b2,

include/RI/physics/RPA.h

@@ -33,7 +33,6 @@ class RPA
 	void set_Cs(
 		const std::map<TA, std::map<TAC, Tensor<Tdata>>> &Cs,
 		const Tdata_real &threshold_C);
-	void set_csm_threshold(const Tdata_real &threshold){ this->lri.csm.set_threshold(threshold); }
 
 	void cal_chi0s(
 		const std::map<TA, std::map<TAC, Tensor<Tdata>>> &Gs_tau_positive,

include/RI/physics/RPA.hpp

@@ -68,7 +68,6 @@ void RPA<TA,Tcell,Ndim,Tdata>::cal_chi0s(
 	};
 
 	std::vector<std::map<TA,std::map<TAC,Tensor<Tdata>>>> chi0s_vec(1);
-	this->lri.coefficients = {nullptr};
 
 	set_Gs_a1(Gs_tau_positive);
 	set_Gs_a2(Gs_tau_negative);

include/RI/ri/Data_Pack.h

@@ -6,7 +6,6 @@
 #pragma once
 
 #include "../global/Tensor.h"
-#include "CS_Matrix.h"
 #include "../global/Global_Func-1.h"
 
 #include <vector>
@@ -24,7 +23,6 @@ struct Data_Pack
 
 	std::map<TA, std::map<TAC, Tensor<Tdata>>> Ds_ab;					// Ds_ab[A0][{A1,C1}]
 	std::vector<std::set<TA>> index_Ds_ab;								// index_Ds_ab[0]=A1
-	typename CS_Matrix<TA,TC,Tdata_real>::Uplimits csm_uplimits;
 };
 
 

include/RI/ri/LRI-set.hpp

@@ -8,7 +8,6 @@
 #include "LRI.h"
 #include "RI_Tools.h"
 #include "Label_Tools.h"
-#include "CS_Matrix.h"
 #include "../global/Map_Operator.h"
 #include <algorithm>
 
@@ -30,46 +29,6 @@ void LRI<TA,Tcell,Ndim,Tdata>::set_parallel(
 		Label_Tools::to_Aab_Aab_set(labels_all));
 }
 
-/*
-template<typename TA, typename Tcell, std::size_t Ndim, typename Tdata>
-void LRI<TA,Tcell,Ndim,Tdata>::set_tensors_map2(
-	const std::map<TA, std::map<TAC, Tensor<Tdata>>> &Ds_local,
-	const Label::ab &label,
-	const std::map<std::string, double> &para_in,
-	const std::string &save_name_in)
-{
-	const std::map<std::string, double> para_default = {
-		{"flag_period",      true},
-		{"flag_comm",        true},
-		{"flag_filter",      true},
-		{"threshold_filter", 0.0}};
-	const std::map<std::string, double> para = Map_Operator::cover(para_default, para_in);
-
-	const std::string save_name =
-		save_name_in=="default"
-		? Label_Tools::get_name(label)
-		: save_name_in;
-	this->data_ab_name[label] = save_name;
-
-	std::map<TA, std::map<TAC, Tensor<Tdata>>> Ds_new =
-		para.at("flag_period")
-		? RI_Tools::cal_period(Ds_local, this->period)
-		: Ds_local;
-
-	if(para.at("flag_comm"))
-		Ds_new = this->parallel->comm_tensors_map2(label, std::move(Ds_new));
-
-	if(para.at("flag_filter"))
-		Ds_new = RI_Tools::filter(std::move(Ds_new), filter_funcs[label], para.at("threshold_filter"));
-
-	this->data_pool[save_name].Ds_ab = std::move(Ds_new);
-
-	this->data_pool[save_name].index_Ds_ab = RI_Tools::get_index(this->data_pool[save_name].Ds_ab);
-
-	this->data_pool[save_name].csm_uplimits = this->csm.cal_uplimits(label, this->data_pool[save_name].Ds_ab);
-}
-*/
-
 template<typename TA, typename Tcell, std::size_t Ndim, typename Tdata>
 void LRI<TA,Tcell,Ndim,Tdata>::set_tensors_map2(
 	const std::map<TA, std::map<TAC, Tensor<Tdata>>> &Ds_local,
@@ -110,56 +69,6 @@ void LRI<TA,Tcell,Ndim,Tdata>::set_tensors_map2(
 	this->data_pool[save_name].Ds_ab = std::move(Ds_new);
 
 	this->data_pool[save_name].index_Ds_ab = RI_Tools::get_index(this->data_pool[save_name].Ds_ab);
-
-	this->data_pool[save_name].csm_uplimits = this->csm.cal_uplimits(label_list, this->data_pool[save_name].Ds_ab);
-}
-
-/*
-template<typename TA, typename Tcell, std::size_t Ndim, typename Tdata>
-void RI<TA,Tcell,Ndim,Tdata>::set_tensors_map3(
-	const std::map<TA, std::map<TAC, std::map<TAC, Tensor<Tdata>>>> &Ds_local,
-	const Label::ab &label,
-	const Tdata_real &threshold)
-{
-	if(label==Label::ab::a)
-	{
-		//this->Ds_ab[label] = Communicate::communicate(Ds_ab, threshold);
-		if(threshold)
-			this->Ds_a = LRI::filter(Ds_local, filter_func, threshold);
-		else
-			this->Ds_a = Ds_local;
-		//this->cs_matrix.set_tensor2(this->Ds_ab[label], label);
-	}
-	else if(label==Label::ab::b)
-	{
-		//this->Ds_ab[label] = Communicate::communicate(Ds_ab, threshold);
-		if(threshold)
-			this->Ds_b = LRI::filter(Ds_local, filter_func, threshold);
-		else
-			this->Ds_b = Ds_local;
-		//this->cs_matrix.set_tensor2(this->Ds_ab[label], label);
-	}
-}
-*/
-
-
-/*
-template<typename TA, typename Tcell, std::size_t Ndim, typename Tdata>
-std::map<TA,std::map<TAC,std::map<TAC,Tensor<Tdata>>>>
-RI<TA,Tcell,Ndim,Tdata>::comm_tensors_map3(
-	const Label::ab &label,
-	const std::map<TA,std::map<TAC,Tensor<Tdata>>> &Ds) const
-{
-	switch(label)
-	{
-		case Label::ab:a:
-			return Map3(this->mpi_comm, Ds, this->list_Aa0(), this->list_Aa1(), this->list_Aa2());
-		case Label::ab:b:
-			return Map3_period(this->mpi_comm, Ds, this->list_Ab0(), this->list_Ab1(), this->list_Ab2());
-		default:
-			throw std::invalid_argument(std::string(__FILE__)+" line "+std::to_string(__LINE__));
-	}
 }
-*/
 
 }

include/RI/ri/LRI.h

@@ -9,7 +9,6 @@
 #include "Label.h"
 #include "../global/Tensor.h"
 #include "Data_Pack.h"
-#include "CS_Matrix.h"
 #include "../parallel/Parallel_LRI_Equally.h"
 #include "RI_Tools.h"
 #include "../global/Global_Func-2.h"
@@ -45,11 +44,6 @@ class LRI
 		const std::array<Tcell,Ndim> &period_in,
 		const std::vector<Label::ab_ab> &labels_all_in);
 
-//	void set_tensors_map2(
-//		const std::map<TA, std::map<TAC, Tensor<Tdata>>> &Ds_local,
-//		const Label::ab &label,
-//		const std::map<std::string, double> &para_in = {},
-//		const std::string &save_name_in = "default");
 	void set_tensors_map2(
 		const std::map<TA, std::map<TAC, Tensor<Tdata>>> &Ds_local,
 		const std::vector<Label::ab> &label_list,
@@ -61,14 +55,7 @@ class LRI
 			//     "flag_filter",      true
 			//     "threshold_filter", 0.0
 			// save_name:              Label_Tools::get_name(label)
-	//void set_tensors_map3(
-	//	const std::map<TA, std::map<TAC, Tensor<Tdata>>> &Ds_local,
-	//	const std::string &label,
-	//	const Tdata &threshold);
 
-	void cal_loop4(
-		const std::vector<Label::ab_ab> &lables,
-		std::vector<std::map<TA, std::map<TAC, Tensor<Tdata>>>> &Ds_result);
 	void cal_loop3(
 		const std::vector<Label::ab_ab> &labels,
 		std::vector<std::map<TA, std::map<TAC, Tensor<Tdata>>>> &Ds_result,
@@ -79,9 +66,6 @@ class LRI
 		parallel = std::make_shared<Parallel_LRI_Equally<TA,Tcell,Ndim,Tdata>>();
 	std::unordered_map< Label::ab, RI_Tools::T_filter_func<Tdata> >
 		filter_funcs;
-	std::vector<std::function<Tdata (const Label::ab_ab &label, const TA &Aa01, const TAC &Aa2, const TAC &Ab01, const TAC &Ab2)>>
-		coefficients = {nullptr};
-	CS_Matrix<TA,TC,Tdata_real> csm;
 
 public:		// private:
 	TC period;
@@ -99,15 +83,10 @@ class LRI
 		std::unordered_map<Label::ab_ab, Tdata_real> &Ds_b01_csm,
 		LRI_Cal_Tools<TA,TC,Tdata> &tools)>;
 	std::unordered_map<Label::ab_ab, T_cal_func> cal_funcs;
-	void set_cal_funcs_b01();
-	void set_cal_funcs_bx2();
 };
 
 }
 
 #include "LRI.hpp"
 #include "LRI-set.hpp"
-#include "LRI-cal-loop4.hpp"
-#include "LRI-cal-loop4-b01.hpp"
-#include "LRI-cal-loop4-bx2.hpp"
 #include "LRI-cal_loop3.hpp"

include/RI/ri/LRI.hpp

@@ -26,9 +26,6 @@ LRI<TA,Tcell,Ndim,Tdata>::LRI()
 
 	for(std::size_t i=0; i<Ndim; ++i)
 		this->period[i] = std::numeric_limits<Tcell>::max()/4;		// /4 for not out of range when Array_Operator::operator%
-
-	this->set_cal_funcs_b01();
-	this->set_cal_funcs_bx2();
 }
 
 }