Merge pull request #797 from wenfei-li/develop

dyzheng · web-flow · commit f8a645f5284f · 2022-03-22T15:26:39.000+08:00
Gint : merge the calculation of block info; removed unused class grid_base
diff --git a/source/Makefile.Objects b/source/Makefile.Objects
@@ -122,7 +122,6 @@ gint_k_init.o\
 gint_k_vl.o\
 gint_k_rho.o\
 gint_k_fvl.o\
-grid_base.o\
 grid_base_beta.o\
 ORB_control.o\
 ORB_read.o\
diff --git a/source/module_grid/Makefile.Objects b/source/module_grid/Makefile.Objects
@@ -17,10 +17,9 @@ complexarray.o\
 complexmatrix.o\
 matrix.o\
 
-OBJS_GRID=grid_base.o\
+OBJS_GRID=
 grid_base_beta.o\
 grid_bigcell.o\
 grid_meshball.o\
 grid_meshk.o\
 grid_technique.o\
-
diff --git a/source/src_lcao/CMakeLists.txt b/source/src_lcao/CMakeLists.txt
@@ -43,7 +43,6 @@ list(APPEND objects
     gint_k_vl.cpp
     gint_tools.cpp
     global_fp.cpp
-    grid_base.cpp
     grid_base_beta.cpp
     grid_bigcell.cpp
     grid_meshball.cpp
diff --git a/source/src_lcao/gint_gamma_env.cpp b/source/src_lcao/gint_gamma_env.cpp
@@ -26,13 +26,6 @@ void Gint_Gamma::gamma_envelope(const double* wfc, double* rho)
     const double delta_r = GlobalC::ORB.dr_uniform;
 	const Numerical_Orbital_Lm* pointer;
 
-	// allocate 1
-	int nnnmax=0;
-	for(int T=0; T<GlobalC::ucell.ntype; T++)
-	{
-		nnnmax = max(nnnmax, nnn[T]);
-	}
-
 	double*** dr; // vectors between atom and grid: [bxyz, maxsize, 3]
 	double** distance; // distance between atom and grid: [bxyz, maxsize]
 	double*** psir_ylm;	
@@ -136,7 +129,6 @@ void Gint_Gamma::gamma_envelope(const double* wfc, double* rho)
 						
 						std::vector<double> ylma;
 						//if(distance[id] > GlobalC::GridT.orbital_rmax) continue;
-						//	Ylm::get_ylm_real(this->nnn[it], this->dr[id], ylma);
 						if (distance[ib][id] < 1.0E-9) distance[ib][id] += 1.0E-9;
 						
 						ModuleBase::Ylm::sph_harm (	GlobalC::ucell.atoms[it].nwl,
diff --git a/source/src_lcao/gint_gamma_fvl.cpp b/source/src_lcao/gint_gamma_fvl.cpp
@@ -89,8 +89,6 @@ inline void cal_psir_ylm_dphi(
             //array to store spherical harmonics and its derivatives
             std::vector<double> rly;
             std::vector<std::vector<double>> grly;
-            // >>> the old method
-            // ylma[id] = new double[nnn[it]]; // liaochen found this bug 2010/03/29
             // Ylm::get_ylm_real(GlobalC::ucell.atoms[it].nwl+1, this->dr[id], ylma[id]);
             // <<<
             // Ylm::rlylm(GlobalC::ucell.atoms[it].nwl+1, dr[id].x, dr[id].y, dr[id].z, rly, grly);
@@ -594,17 +592,8 @@ void Gint_Gamma::gamma_force(const double*const vlocal) const
 					//------------------------------------------------------------------
 					double *vldr3 = get_vldr3(vlocal, ncyz, ibx, jby, kbz);
 					
-					//------------------------------------------------------
-					// index of wave functions for each block
-					//------------------------------------------------------
-					int *block_iw = Gint_Tools::get_block_iw(na_grid, grid_index, this->max_size);
-					
-					int* block_index = Gint_Tools::get_block_index(na_grid, grid_index);
-					
-					//------------------------------------------------------
-					// band size: number of columns of a band
-					//------------------------------------------------------------------
-					int* block_size = Gint_Tools::get_block_size(na_grid, grid_index);
+                    int * block_iw, * block_index, * block_size;
+                    Gint_Tools::get_block_info(na_grid, grid_index, block_iw, block_index, block_size);
 
 					Gint_Tools::Array_Pool<double> psir_vlbr3(GlobalC::pw.bxyz, LD_pool);
 					Gint_Tools::Array_Pool<double> psir_ylm(GlobalC::pw.bxyz, LD_pool);
@@ -619,9 +608,9 @@ void Gint_Gamma::gamma_force(const double*const vlocal) const
                                 DGridV_22, DGridV_23, DGridV_33, drr);
 								
 					free(vldr3);		vldr3=nullptr;
-					free(block_iw);		block_iw=nullptr;
-					free(block_index);	block_index=nullptr;
-					free(block_size);	block_size=nullptr;
+					delete[] block_iw;
+					delete[] block_index;
+					delete[] block_size;
                 }// k
             }// j
         }// i
diff --git a/source/src_lcao/gint_gamma_mull.cpp b/source/src_lcao/gint_gamma_mull.cpp
@@ -32,13 +32,6 @@ void Gint_Gamma::gamma_mulliken(double** mulliken)
     const double delta_r = GlobalC::ORB.dr_uniform;
 	const Numerical_Orbital_Lm* pointer;
 
-	// allocate 1
-	int nnnmax=0;
-	for(int T=0; T<GlobalC::ucell.ntype; T++)
-	{
-		nnnmax = max(nnnmax, nnn[T]);
-	}
-
 	double*** dr; // vectors between atom and grid: [bxyz, maxsize, 3]
 	double** distance; // distance between atom and grid: [bxyz, maxsize]
 	double*** psir_ylm;	
@@ -141,8 +134,6 @@ void Gint_Gamma::gamma_mulliken(double** mulliken)
 						}
 						
 						std::vector<double> ylma;
-						//if(distance[id] > GlobalC::GridT.orbital_rmax) continue;
-						//	Ylm::get_ylm_real(this->nnn[it], this->dr[id], ylma);
 						if (distance[ib][id] < 1.0E-9) distance[ib][id] += 1.0E-9;
 						
 						ModuleBase::Ylm::sph_harm (	GlobalC::ucell.atoms[it].nwl,
@@ -214,7 +205,6 @@ void Gint_Gamma::gamma_mulliken(double** mulliken)
 					// a particular number: (lmax+1)^2 and vectors between
 					// atom and grid point(we need the direction), the output
 					// are put in the array: ylm1.
-					//Ylm::get_ylm_real(this->nnn[T1], this->dr[ia1], this->ylm1);
 
 					// attention! assume all rcut are same for this atom type now.
 					//if (distance[ia1] > GlobalC::ORB.Phi[T1].getRcut())continue;
diff --git a/source/src_lcao/gint_gamma_rho.cpp b/source/src_lcao/gint_gamma_rho.cpp
@@ -215,17 +215,8 @@ Gint_Tools::Array_Pool<double> Gint_Gamma::gamma_charge(const double*const*const
 						// here vindex refers to local potentials
 						int* vindex = Gint_Tools::get_vindex(ncyz, ibx, jby, kbz);	
 						
-						//------------------------------------------------------
-						// band size: number of columns of a band
-						//------------------------------------------------------------------
-						int* block_size = Gint_Tools::get_block_size(na_grid, grid_index);
-						
-						//------------------------------------------------------
-						// index of wave functions for each block
-						//------------------------------------------------------
-						int *block_iw = Gint_Tools::get_block_iw(na_grid, grid_index, this->max_size);
-
-						int* block_index = Gint_Tools::get_block_index(na_grid, grid_index);
+                        int * block_iw, * block_index, * block_size;
+                        Gint_Tools::get_block_info(na_grid, grid_index, block_iw, block_index, block_size);
 
 						//------------------------------------------------------
 						// whether the atom-grid distance is larger than cutoff
@@ -244,9 +235,9 @@ Gint_Tools::Array_Pool<double> Gint_Gamma::gamma_charge(const double*const*const
 							cal_flag, psir_ylm.ptr_2D, vindex, DM, rho);
 
 						free(vindex);			vindex=nullptr;
-						free(block_size);		block_size=nullptr;
-						free(block_iw);			block_iw=nullptr;
-						free(block_index);		block_index=nullptr;
+                        delete[] block_iw;
+                        delete[] block_index;
+                        delete[] block_size;
 
 						for(int ib=0; ib<GlobalC::pw.bxyz; ++ib)
 							free(cal_flag[ib]);
diff --git a/source/src_lcao/gint_gamma_vl.cpp b/source/src_lcao/gint_gamma_vl.cpp
@@ -374,18 +374,8 @@ Gint_Tools::Array_Pool<double> Gint_Gamma::gamma_vlocal(const double*const vloca
 						//------------------------------------------------------------------
 						const int kbz=k*GlobalC::pw.bz-GlobalC::pw.nczp_start;
 
-						//------------------------------------------------------
-						// index of wave functions for each block
-						//------------------------------------------------------
-						int *block_iw = Gint_Tools::get_block_iw(na_grid, grid_index, this->max_size);
-						
-						int* block_index = Gint_Tools::get_block_index(na_grid, grid_index);
-						
-						//------------------------------------------------------
-						// band size: number of columns of a band
-						//------------------------------------------------------
-						int* block_size = Gint_Tools::get_block_size(na_grid, grid_index);
-
+                        int * block_iw, * block_index, * block_size;
+                        Gint_Tools::get_block_info(na_grid, grid_index, block_iw, block_index, block_size);
 						//------------------------------------------------------
 						// whether the atom-grid distance is larger than cutoff
 						//------------------------------------------------------
@@ -414,9 +404,9 @@ Gint_Tools::Array_Pool<double> Gint_Gamma::gamma_vlocal(const double*const vloca
 							vldr3, psir_ylm.ptr_2D, psir_vlbr3.ptr_2D, lgd_now, GridVlocal_thread.ptr_2D);
 						
 						free(vldr3);		vldr3=nullptr;
-						free(block_iw);		block_iw=nullptr;
-						free(block_index);		block_index=nullptr;
-						free(block_size);		block_size=nullptr;
+                        delete[] block_iw;
+                        delete[] block_index;
+                        delete[] block_size;
 
 						for(int ib=0; ib<GlobalC::pw.bxyz; ++ib)
 							free(cal_flag[ib]);
diff --git a/source/src_lcao/gint_k_init.cpp b/source/src_lcao/gint_k_init.cpp
@@ -6,12 +6,10 @@ Gint_k_init::Gint_k_init()
 	nbx = nby = nbz =0;
 	ncxyz = 0;
 	nbz_start = 0;
-	nnn = new int[1];
 }
 
 Gint_k_init::~Gint_k_init()
 {
-	delete[] nnn;
 }
 
 void Gint_k_init::init(
@@ -34,15 +32,6 @@ void Gint_k_init::init(
 	assert(nbz>0);
 	assert(ncxyz>0);
 
-	// claculate the maximal orbital numbers 
-	// for each type of atom.
-	delete[] this->nnn;
-	this->nnn = new int[GlobalC::ucell.ntype];
-	for(int it=0; it<GlobalC::ucell.ntype; it++)
-	{
-		this->nnn[it] = (GlobalC::ucell.atoms[it].nwl+1) * (GlobalC::ucell.atoms[it].nwl+1);
-	}
-
 	assert( GlobalC::ucell.omega > 0.0);
 
 	return;
diff --git a/source/src_lcao/gint_k_init.h b/source/src_lcao/gint_k_init.h
@@ -29,7 +29,6 @@ class Gint_k_init
 	int nbz;
 	int ncxyz;
 	int nbz_start;
-	int* nnn;
 
 };
 
diff --git a/source/src_lcao/gint_tools.cpp b/source/src_lcao/gint_tools.cpp
@@ -37,13 +37,19 @@ namespace Gint_Tools
 		return vindex;
 	}
 
-	// index of wave functions for each block
-	int* get_block_iw(
-		const int na_grid,  		// how many atoms on this (i,j,k) grid
-		const int grid_index,		// 1d index of FFT index (i,j,k)
-		const int max_size)
+	void get_block_info(
+		const int na_grid,
+		const int grid_index,
+		int * &block_iw,
+		int * &block_index,
+		int * &block_size	
+	)
 	{
-		int *block_iw = (int*)malloc(max_size*sizeof(int));
+		block_iw = new int[na_grid];
+		block_index = new int[na_grid+1];
+		block_size = new int[na_grid];
+
+		block_index[0] = 0;
 		for (int id=0; id<na_grid; id++)
 		{
 			const int mcell_index=GlobalC::GridT.bcell_start[grid_index] + id;
@@ -52,40 +58,9 @@ namespace Gint_Tools
 			const int ia=GlobalC::ucell.iat2ia[ iat ]; // index of atoms within each type
 			const int start=GlobalC::ucell.itiaiw2iwt(it, ia, 0); // the index of the first wave function for atom (it,ia)
 			block_iw[id]=GlobalC::GridT.trace_lo[start];
-		}
-		return block_iw;
-	}
-
-	int* get_block_index(
-		const int na_grid,  		// how many atoms on this (i,j,k) grid
-		const int grid_index)		// 1d index of FFT index (i,j,k)
-	{
-		int* block_index = (int*)malloc((na_grid+1)*sizeof(int));
-		block_index[0] = 0;
-		for (int id=0; id<na_grid; id++)
-		{
-			const int mcell_index = GlobalC::GridT.bcell_start[grid_index] + id;
-			const int iat = GlobalC::GridT.which_atom[mcell_index]; // index of atom
-			const int it = GlobalC::ucell.iat2it[iat]; // index of atom type
 			block_index[id+1] = block_index[id]+GlobalC::ucell.atoms[it].nw;
-		}
-		return block_index;
-	}
-
-	// band size: number of columns of a band
-	int* get_block_size(
-		const int na_grid,			// how many atoms on this (i,j,k) grid
-		const int grid_index)		// 1d index of FFT index (i,j,k)
-	{
-		int* block_size = (int*)malloc(na_grid*sizeof(int));
-		for (int id=0; id<na_grid; id++)
-		{
-			const int mcell_index=GlobalC::GridT.bcell_start[grid_index] + id;
-			const int iat=GlobalC::GridT.which_atom[mcell_index]; // index of atom
-			const int it=GlobalC::ucell.iat2it[ iat ]; // index of atom type
 			block_size[id]=GlobalC::ucell.atoms[it].nw;	
 		}
-		return block_size;
 	}
 	
 	// whether the atom-grid distance is larger than cutoff
diff --git a/source/src_lcao/gint_tools.h b/source/src_lcao/gint_tools.h
@@ -28,23 +28,19 @@ namespace Gint_Tools
 		const int jby,
 		const int kbz);
 
-	// index of wave functions for each block
-	// block_iw[na_grid]
-	int* get_block_iw(
-		const int na_grid,  		// how many atoms on this (i,j,k) grid
-		const int grid_index,		// 1d index of FFT index (i,j,k))
-		const int max_size);
-		
-	// block_index[na_grid+1]
-	int* get_block_index(
-		const int na_grid,  		// how many atoms on this (i,j,k) grid
-		const int grid_index);		// 1d index of FFT index (i,j,k)
-		
-	// band size: number of columns of a band
-	// block_size[na_grid]
-	int* get_block_size(
-		const int na_grid,			// how many atoms on this (i,j,k) grid
-		const int grid_index);		// 1d index of FFT index (i,j,k)
+	//------------------------------------------------------
+	// na_grid : #. atoms for this group of grids
+	// block_iw : size na_grid, index of the first orbital on this atom
+	// block_size : size na_grid, number of orbitals on this atom
+	// block_index : size na_grid+1, start from 0, accumulates block_size
+	//------------------------------------------------------
+	void get_block_info(
+		const int na_grid,
+		const int grid_index,
+		int * &block_iw,
+		int * &block_index,
+		int * &block_size
+	);
 
 	// whether the atom-grid distance is larger than cutoff
 	// cal_flag[pw.bxyz][na_grid]
diff --git a/source/src_lcao/grid_base.cpp b/source/src_lcao/grid_base.cpp
diff --git a/source/src_lcao/grid_base.h b/source/src_lcao/grid_base.h
diff --git a/source/src_lcao/grid_base_beta.cpp b/source/src_lcao/grid_base_beta.cpp
diff --git a/source/src_lcao/grid_base_beta.h b/source/src_lcao/grid_base_beta.h
