1. update CS_Matrix to adding CS_Matrix::Uplimits

PeizeLin · PeizeLin · commit 6c132eb18e70 · 2023-08-25T01:03:16.000+08:00
diff --git a/include/RI/ri/CS_Matrix-filter.hpp b/include/RI/ri/CS_Matrix-filter.hpp
@@ -19,7 +19,8 @@ template<typename TA, typename TC, typename Tdata>
 typename CS_Matrix<TA,TC,Tdata>::Step CS_Matrix<TA,TC,Tdata>::set_label_A(
 	const Label::ab_ab &label_in,
 	const TA &Aa01, const TAC &Aa2, const TAC &Ab01, const TAC &Ab2,
-	const TC &period) const
+	const TC &period,
+	const std::unordered_map<Label::ab, CS_Matrix<TA,TC,Tdata>::Uplimits> &uplimits) const
 {
 	using namespace Array_Operator;
 
@@ -44,32 +45,32 @@ typename CS_Matrix<TA,TC,Tdata>::Step CS_Matrix<TA,TC,Tdata>::set_label_A(
 		}
 	};
 	auto get_uplimit_tensor2 = [&get_Aa_Ab](
-		const std::unordered_map<Label::ab, std::map<TA,std::map<TAC,Tdata>>> &uplimits_tensor2,
+		const std::unordered_map<Label::ab, CS_Matrix<TA,TC,Tdata>::Uplimits> &uplimits,
 		const Label::ab label_ab) -> Tdata
 	{
 		const int xa = Label::get_a(label_ab);
 		const int xb = Label::get_b(label_ab);
 		const std::pair<TA,TAC> &Aa_Ab = get_Aa_Ab(xa,xb);
 		const TA &Aa=Aa_Ab.first;
 		const TAC &Ab=Aa_Ab.second;
-		return Global_Func::find(uplimits_tensor2.at(label_ab), Aa, Ab);
+		return Global_Func::find(uplimits.at(label_ab).square_tensor2, Aa, Ab);
 	};
 
 	Step step;
 
 	step.label = label_in;
 
 	const int index_a = Label::get_unused_a(step.label);
-	step.a_square = Global_Func::find(this->uplimits_square_tensor3.at(Label::ab::a)[index_a], Aa01, Aa2);
-	step.a_norm   = Global_Func::find(this->uplimits_norm_tensor3  .at(Label::ab::a)[index_a], Aa01, Aa2);
+	step.a_square = Global_Func::find(uplimits.at(Label::ab::a).square_tensor3[index_a], Aa01, Aa2);
+	step.a_norm   = Global_Func::find(uplimits.at(Label::ab::a).norm_tensor3  [index_a], Aa01, Aa2);
 
 	const int index_b = get_unused_b(step.label);
-	step.b_square = Global_Func::find(this->uplimits_square_tensor3.at(Label::ab::b)[index_b], Ab01.first, TAC{Ab2.first, (Ab2.second-Ab01.second)%period});
-	step.b_norm   = Global_Func::find(this->uplimits_norm_tensor3  .at(Label::ab::b)[index_b], Ab01.first, TAC{Ab2.first, (Ab2.second-Ab01.second)%period});
+	step.b_square = Global_Func::find(uplimits.at(Label::ab::b).square_tensor3[index_b], Ab01.first, TAC{Ab2.first, (Ab2.second-Ab01.second)%period});
+	step.b_norm   = Global_Func::find(uplimits.at(Label::ab::b).norm_tensor3  [index_b], Ab01.first, TAC{Ab2.first, (Ab2.second-Ab01.second)%period});
 
 	const std::pair<Label::ab, Label::ab> label_split_tmp = CS_Matrix_Tools::split_label(step.label);
-	step.first_square  = get_uplimit_tensor2(this->uplimits_square_tensor2, label_split_tmp.first);
-	step.second_square = get_uplimit_tensor2(this->uplimits_square_tensor2, label_split_tmp.second);
+	step.first_square  = get_uplimit_tensor2(uplimits, label_split_tmp.first);
+	step.second_square = get_uplimit_tensor2(uplimits, label_split_tmp.second);
 
 	return step;
 }
diff --git a/include/RI/ri/CS_Matrix-set.hpp b/include/RI/ri/CS_Matrix-set.hpp
@@ -31,29 +31,31 @@ void CS_Matrix<TA,TC,Tdata>::set_threshold(const Label::ab_ab &label, const Tdat
 
 
 template<typename TA, typename TC, typename Tdata> template<typename T>
-void CS_Matrix<TA,TC,Tdata>::set_tensor(
+CS_Matrix<TA,TC,Tdata>::Uplimits CS_Matrix<TA,TC,Tdata>::cal_uplimits(
 	const Label::ab &label,
 	const T &Ds)
 {
+	Uplimits uplimits;
 	switch(label)
 	{
 		case Label::ab::a:	case Label::ab::b:
-			this->uplimits_square_tensor3[label][0] = CS_Matrix_Tools::cal_uplimit(CS_Matrix_Tools::Uplimit_Type::square_three_0, Ds);
-			this->uplimits_square_tensor3[label][1] = CS_Matrix_Tools::cal_uplimit(CS_Matrix_Tools::Uplimit_Type::square_three_1, Ds);
-			this->uplimits_square_tensor3[label][2] = CS_Matrix_Tools::cal_uplimit(CS_Matrix_Tools::Uplimit_Type::square_three_2, Ds);
-			this->uplimits_norm_tensor3[label][0] = CS_Matrix_Tools::cal_uplimit(CS_Matrix_Tools::Uplimit_Type::norm_three_0, Ds);
-			this->uplimits_norm_tensor3[label][1] = CS_Matrix_Tools::cal_uplimit(CS_Matrix_Tools::Uplimit_Type::norm_three_1, Ds);
-			this->uplimits_norm_tensor3[label][2] = CS_Matrix_Tools::cal_uplimit(CS_Matrix_Tools::Uplimit_Type::norm_three_2, Ds);
+			uplimits.square_tensor3[0] = CS_Matrix_Tools::cal_uplimit(CS_Matrix_Tools::Uplimit_Type::square_three_0, Ds);
+			uplimits.square_tensor3[1] = CS_Matrix_Tools::cal_uplimit(CS_Matrix_Tools::Uplimit_Type::square_three_1, Ds);
+			uplimits.square_tensor3[2] = CS_Matrix_Tools::cal_uplimit(CS_Matrix_Tools::Uplimit_Type::square_three_2, Ds);
+			uplimits.norm_tensor3[0] = CS_Matrix_Tools::cal_uplimit(CS_Matrix_Tools::Uplimit_Type::norm_three_0, Ds);
+			uplimits.norm_tensor3[1] = CS_Matrix_Tools::cal_uplimit(CS_Matrix_Tools::Uplimit_Type::norm_three_1, Ds);
+			uplimits.norm_tensor3[2] = CS_Matrix_Tools::cal_uplimit(CS_Matrix_Tools::Uplimit_Type::norm_three_2, Ds);
 			break;
 		case Label::ab::a0b0:	case Label::ab::a0b1:	case Label::ab::a0b2:
 		case Label::ab::a1b0:	case Label::ab::a1b1:	case Label::ab::a1b2:
 		case Label::ab::a2b0:	case Label::ab::a2b1:	case Label::ab::a2b2:
-			this->uplimits_square_tensor2[label] = CS_Matrix_Tools::cal_uplimit(CS_Matrix_Tools::Uplimit_Type::square_two, Ds);
-			//this->uplimits_norm_tensor2[label] = CS_Matrix_Tools::cal_uplimit(CS_Matrix_Tools::Uplimit_Type::norm_two, Ds);
+			uplimits.square_tensor2 = CS_Matrix_Tools::cal_uplimit(CS_Matrix_Tools::Uplimit_Type::square_two, Ds);
+			//uplimits.norm_tensor2 = CS_Matrix_Tools::cal_uplimit(CS_Matrix_Tools::Uplimit_Type::norm_two, Ds);
 			break;
 		default:
 			throw std::invalid_argument("CS_Matrix::set_tensor");
 	}
+	return uplimits;
 }
 
 }
diff --git a/include/RI/ri/CS_Matrix.h b/include/RI/ri/CS_Matrix.h
@@ -31,29 +31,31 @@ class CS_Matrix
 		Tdata second_square;
 	};
 
+	struct Uplimits
+	{
+		std::array< std::map<TA,std::map<TAC,Tdata>> ,3> square_tensor3;
+		std::array< std::map<TA,std::map<TAC,Tdata>> ,3> norm_tensor3;
+		std::map<TA,std::map<TAC,Tdata>> square_tensor2;
+		//std::map<TA,std::map<TAC,Tdata>> norm_tensor2;
+	};
+
 	std::unordered_map<Label::ab_ab, Tdata> threshold;
 	CS_Matrix();
 	void set_threshold(const Tdata &threshold_in);
 	void set_threshold(const Label::ab_ab &label, const Tdata &threshold_in);
 
-	template<typename T> void set_tensor( const Label::ab &label, const T &Ds);
+	template<typename T> Uplimits cal_uplimits( const Label::ab &label, const T &Ds);
 
 	Step set_label_A(
 		const Label::ab_ab &label_in,
 		const TA &Aa01, const TAC &Aa2, const TAC &Ab01, const TAC &Ab2,
-		const TC &period) const;
+		const TC &period,
+		const std::unordered_map<Label::ab, CS_Matrix<TA,TC,Tdata>::Uplimits> &uplimits) const;
 
 	bool filter_4(const Step &step                           ) const { return step.a_square * step.first_square * step.second_square * step.b_square < this->threshold.at(step.label); }
 	bool filter_3(const Step &step, const Tdata &uplimit_norm) const { return uplimit_norm                      * step.second_square * step.b_square < this->threshold.at(step.label); }
 	bool filter_2(const Step &step, const Tdata &uplimit_norm) const { return uplimit_norm                                           * step.b_norm   < this->threshold.at(step.label); }
 	bool filter_1(const Step &step, const Tdata &uplimit_norm) const { return uplimit_norm                                                           < this->threshold.at(step.label); }
-
-public:	// private:
-
-	std::unordered_map<Label::ab, std::array< std::map<TA,std::map<TAC,Tdata>> ,3>> uplimits_square_tensor3;
-	std::unordered_map<Label::ab, std::array< std::map<TA,std::map<TAC,Tdata>> ,3>> uplimits_norm_tensor3;
-	std::unordered_map<Label::ab, std::map<TA,std::map<TAC,Tdata>>> uplimits_square_tensor2;
-	//std::unordered_map<Label::ab, std::map<TA,std::map<TAC,Tdata>>> uplimits_norm_tensor2;
 };
 
 }
diff --git a/include/RI/ri/LRI-cal-b01.hpp b/include/RI/ri/LRI-cal-b01.hpp
@@ -35,7 +35,7 @@ void LRI<TA,Tcell,Ndim,Tdata>::set_cal_funcs_b01()
 		if(D_ab_second.empty())	return;	\
 		typename CS_Matrix<TA,TC,Tdata_real>::Step csm_step;	\
 		if(this->csm.threshold.at(label))	\
-			csm_step = this->csm.set_label_A(label, Aa01, Aa2, Ab01, Ab2, period);	\
+			csm_step = this->csm.set_label_A(label, Aa01, Aa2, Ab01, Ab2, period, this->csm_uplimits);	\
 		\
 		if(this->csm.threshold.at(label))	\
 			if(this->csm.filter_4(csm_step))	\
diff --git a/include/RI/ri/LRI-cal-bx2.hpp b/include/RI/ri/LRI-cal-bx2.hpp
@@ -35,7 +35,7 @@ void LRI<TA,Tcell,Ndim,Tdata>::set_cal_funcs_bx2()
 		if(D_ab_second.empty())	return;	\
 		typename CS_Matrix<TA,TC,Tdata_real>::Step csm_step;	\
 		if(this->csm.threshold.at(label))	\
-			csm_step = this->csm.set_label_A(label, Aa01, Aa2, Ab01, Ab2, period);	\
+			csm_step = this->csm.set_label_A(label, Aa01, Aa2, Ab01, Ab2, period, this->csm_uplimits);	\
 		\
 		if(this->csm.threshold.at(label))	\
 			if(this->csm.filter_4(csm_step))	\
diff --git a/include/RI/ri/LRI-set.hpp b/include/RI/ri/LRI-set.hpp
@@ -43,7 +43,7 @@ void LRI<TA,Tcell,Ndim,Tdata>::set_tensors_map2(
 
 	this->index_Ds_ab[label] = RI_Tools::get_index(this->Ds_ab[label]);
 
-	this->csm.set_tensor(label, this->Ds_ab[label]);
+	this->csm_uplimits[label] = this->csm.cal_uplimits(label, this->Ds_ab[label]);
 }
 
 /*
diff --git a/include/RI/ri/LRI.h b/include/RI/ri/LRI.h
@@ -77,6 +77,7 @@ class LRI
 
 	std::unordered_map<Label::ab, std::map<TA, std::map<TAC, Tensor<Tdata>>>> Ds_ab;		// Ds_ab[A0][{A1,C1}]
 	std::unordered_map<Label::ab, std::vector<std::set<TA>>> index_Ds_ab;					// index_Ds_ab[0]=A1
+	std::unordered_map<Label::ab, typename CS_Matrix<TA,TC,Tdata_real>::Uplimits> csm_uplimits;
 
 public:		// private:
 	using T_cal_func = std::function<void(
diff --git a/include/RI/ri/Save_Load.h b/include/RI/ri/Save_Load.h
@@ -25,7 +25,8 @@ template<typename TA, typename Tcell, std::size_t Ndim, typename Tdata>
 class Save_Load
 {
 public:
-	using TAC = std::pair<TA,std::array<Tcell,Ndim>>;
+	using TC = std::array<Tcell,Ndim>;
+	using TAC = std::pair<TA,TC>;
 	using Tdata_real = Global_Func::To_Real_t<Tdata>;
 
 	Save_Load(LRI<TA,Tcell,Ndim,Tdata> &lri_in): lri(lri_in){}
@@ -43,10 +44,7 @@ class Save_Load
 	{
 		std::map<TA, std::map<TAC, Tensor<Tdata>>> Ds_ab;
 		std::vector<std::set<TA>> index_Ds_ab;
-		std::array< std::map<TA,std::map<TAC,Tdata_real>> ,3> csm_uplimits_square_tensor3;
-		std::array< std::map<TA,std::map<TAC,Tdata_real>> ,3> csm_uplimits_norm_tensor3;
-		std::map<TA,std::map<TAC,Tdata_real>> csm_uplimits_square_tensor2;
-		//std::map<TA,std::map<TAC,Tdata_real>> csm_uplimits_norm_tensor2;
+		typename CS_Matrix<TA,TC,Tdata_real>::Uplimits csm_uplimits;
 	};
 	std::map<std::string,Info> saves;
 
diff --git a/include/RI/ri/Save_Load.hpp b/include/RI/ri/Save_Load.hpp
@@ -15,27 +15,18 @@ void Save_Load<TA,Tcell,Ndim,Tdata>::save(const std::string &name, const Label::
 {
 	this->saves[name].Ds_ab = std::move(this->lri.Ds_ab[label]);
 	this->saves[name].index_Ds_ab = std::move(this->lri.index_Ds_ab[label]);
-	this->saves[name].csm_uplimits_square_tensor3 = std::move(this->lri.csm.uplimits_square_tensor3[label]);
-	this->saves[name].csm_uplimits_norm_tensor3   = std::move(this->lri.csm.uplimits_norm_tensor3  [label]);
-	this->saves[name].csm_uplimits_square_tensor2 = std::move(this->lri.csm.uplimits_square_tensor2[label]);
+	this->saves[name].csm_uplimits = std::move(this->lri.csm_uplimits[label]);
 }
 
 template<typename TA, typename Tcell, std::size_t Ndim, typename Tdata>
 void Save_Load<TA,Tcell,Ndim,Tdata>::load(const std::string &name, const Label::ab &label)
 {
 	assert(this->lri.Ds_ab[label].empty());
 	assert(this->lri.index_Ds_ab[label].empty());
-	for(std::size_t i=0; i<this->lri.csm.uplimits_square_tensor3[label].size(); ++i)
-		assert(this->lri.csm.uplimits_square_tensor3[label][i].empty());
-	for(std::size_t i=0; i<this->lri.csm.uplimits_norm_tensor3[label].size(); ++i)
-		assert(this->lri.csm.uplimits_norm_tensor3[label][i].empty());
-	assert(this->lri.csm.uplimits_square_tensor2[label].empty());
 
 	this->lri.Ds_ab[label] = std::move(this->saves.at(name).Ds_ab);
 	this->lri.index_Ds_ab[label] = std::move(this->saves.at(name).index_Ds_ab);
-	this->lri.csm.uplimits_square_tensor3[label] = std::move(this->saves.at(name).csm_uplimits_square_tensor3);
-	this->lri.csm.uplimits_norm_tensor3  [label] = std::move(this->saves.at(name).csm_uplimits_norm_tensor3);
-	this->lri.csm.uplimits_square_tensor2[label] = std::move(this->saves.at(name).csm_uplimits_square_tensor2);
+	this->lri.csm_uplimits[label] = std::move(this->saves.at(name).csm_uplimits);
 
 //	auto save_name_empty = [this]() -> bool
 //	{

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ void LRI<TA,Tcell,Ndim,Tdata>::set_cal_funcs_b01()`
`35`	`35`	`if(D_ab_second.empty()) return; \`
`36`	`36`	`typename CS_Matrix<TA,TC,Tdata_real>::Step csm_step; \`
`37`	`37`	`if(this->csm.threshold.at(label)) \`
`38`		`- csm_step = this->csm.set_label_A(label, Aa01, Aa2, Ab01, Ab2, period); \`
	`38`	`+ csm_step = this->csm.set_label_A(label, Aa01, Aa2, Ab01, Ab2, period, this->csm_uplimits); \`
`39`	`39`	`\`
`40`	`40`	`if(this->csm.threshold.at(label)) \`
`41`	`41`	`if(this->csm.filter_4(csm_step)) \`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ void LRI<TA,Tcell,Ndim,Tdata>::set_tensors_map2(`
`43`	`43`
`44`	`44`	`this->index_Ds_ab[label] = RI_Tools::get_index(this->Ds_ab[label]);`
`45`	`45`
`46`		`- this->csm.set_tensor(label, this->Ds_ab[label]);`
	`46`	`+ this->csm_uplimits[label] = this->csm.cal_uplimits(label, this->Ds_ab[label]);`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`/*`