void FT_ProExpn_VNA()
{
int numprocs,myid,ID,tag=999;
int count,NumSpe;
int L,i,kj;
int Lspe,spe,GL,Mul;
int RestartRead_Succeed;
double Sr,Dr;
double norm_k,h,dum0;
double rmin,rmax,r,sum;
double kmin,kmax,Sk,Dk;
double RGL[GL_Mesh + 2];
double *SumTmp;
double tmp0,tmp1;
double **SphB;
double *tmp_SphB,*tmp_SphBp;
double TStime, TEtime;
/* for MPI */
MPI_Status stat;
MPI_Request request;
/* for OpenMP */
int OMPID,Nthrds,Nprocs;
char fileFT[YOUSO10];
char operate[300];
FILE *fp;
size_t size;
dtime(&TStime);
/* MPI */
MPI_Comm_size(mpi_comm_level1,&numprocs);
MPI_Comm_rank(mpi_comm_level1,&myid);
if (myid==Host_ID && 0<level_stdout) printf("<FT_ProExpn_VNA> Fourier transform of VNA separable projectors\n");
RestartRead_Succeed = 0;
/***********************************************************
In case of Scf_RestartFromFile==1, read Spe_VNA_Bessel
***********************************************************/
if (Scf_RestartFromFile){
/****************************************************
regenerate radial grids in the k-space
for the MPI calculation
****************************************************/
for (kj=0; kj<GL_Mesh; kj++){
kmin = Radial_kmin;
kmax = PAO_Nkmax;
Sk = kmax + kmin;
Dk = kmax - kmin;
norm_k = 0.50*(Dk*GL_Abscissae[kj] + Sk);
GL_NormK[kj] = norm_k;
}
/***********************************************************
read Spe_VNA_Bessel
***********************************************************/
sprintf(fileFT,"%s%s_rst/%s.ftPEvna",filepath,filename,filename);
if ((fp = fopen(fileFT,"rb")) != NULL){
RestartRead_Succeed = 1;
for (spe=0; spe<SpeciesNum; spe++){
for (L=0; L<=List_YOUSO[35]; L++){
for (Mul=0; Mul<List_YOUSO[34]; Mul++){
size = fread(&Spe_VNA_Bessel[spe][L][Mul][0],sizeof(double),GL_Mesh,fp);
if (size!=GL_Mesh) RestartRead_Succeed = 0;
}
}
}
fclose(fp);
}
else{
printf("Could not open a file %s in FT_ProExpn_VNA\n",fileFT);
}
}
/***********************************************************
if (RestartRead_Succeed==0), calculate Spe_VNA_Bessel
***********************************************************/
if (RestartRead_Succeed==0){
for (Lspe=0; Lspe<MSpeciesNum; Lspe++){
spe = Species_Top[myid] + Lspe;
/* initalize */
/* tabulation on Gauss-Legendre radial grid */
rmin = Spe_VPS_RV[spe][0];
rmax = Spe_Atom_Cut1[spe] + 0.5;
Sr = rmax + rmin;
Dr = rmax - rmin;
for (i=0; i<GL_Mesh; i++){
RGL[i] = 0.50*(Dr*GL_Abscissae[i] + Sr);
}
kmin = Radial_kmin;
kmax = PAO_Nkmax;
Sk = kmax + kmin;
Dk = kmax - kmin;
/* loop for kj */
#pragma omp parallel shared(List_YOUSO,GL_Weight,GL_Abscissae,Dr,Dk,Sk,RGL,Projector_VNA,Spe_VPS_RV,Spe_Num_Mesh_VPS,Spe_VNA_Bessel) private(SumTmp,SphB,tmp_SphB,tmp_SphBp,OMPID,Nthrds,Nprocs,kj,norm_k,i,r,L,Mul,tmp0,dum0)
{
/* allocate arrays */
SumTmp = (double*)malloc(sizeof(double)*List_YOUSO[34]);
SphB = (double**)malloc(sizeof(double*)*(List_YOUSO[35]+3));
for(L=0; L<(List_YOUSO[35]+3); L++){
SphB[L] = (double*)malloc(sizeof(double)*GL_Mesh);
}
tmp_SphB = (double*)malloc(sizeof(double)*(List_YOUSO[35]+3));
tmp_SphBp = (double*)malloc(sizeof(double)*(List_YOUSO[35]+3));
/* get info. on OpenMP */
OMPID = omp_get_thread_num();
Nthrds = omp_get_num_threads();
Nprocs = omp_get_num_procs();
for ( kj=OMPID; kj<GL_Mesh; kj+=Nthrds ){
norm_k = 0.50*(Dk*GL_Abscissae[kj] + Sk);
/* calculate SphB */
for (i=0; i<GL_Mesh; i++){
r = RGL[i];
Spherical_Bessel(norm_k*r,List_YOUSO[35],tmp_SphB,tmp_SphBp);
for(L=0; L<=List_YOUSO[35]; L++){
SphB[L][i] = tmp_SphB[L];
}
}
/* loop for L */
for (L=0; L<=List_YOUSO[35]; L++){
/****************************************************
\int jL(k*r)RL r^2 dr
****************************************************/
for (Mul=0; Mul<List_YOUSO[34]; Mul++) SumTmp[Mul] = 0.0;
/* Gauss-Legendre quadrature */
for (i=0; i<GL_Mesh; i++){
r = RGL[i];
tmp0 = r*r*GL_Weight[i]*SphB[L][i];
for (Mul=0; Mul<List_YOUSO[34]; Mul++){
dum0 = PhiF(r, Projector_VNA[spe][L][Mul], Spe_VPS_RV[spe], Spe_Num_Mesh_VPS[spe]);
SumTmp[Mul] += dum0*tmp0;
}
}
for (Mul=0; Mul<List_YOUSO[34]; Mul++){
Spe_VNA_Bessel[spe][L][Mul][kj] = 0.5*Dr*SumTmp[Mul];
}
} /* L */
} /* kj */
/* free arrays */
free(SumTmp);
for(L=0; L<(List_YOUSO[35]+3); L++){
free(SphB[L]);
}
free(SphB);
free(tmp_SphB);
free(tmp_SphBp);
#pragma omp flush(Spe_VNA_Bessel)
} /* #pragma omp parallel */
} /* Lspe */
/****************************************************
regenerate radial grids in the k-space
for the MPI calculation
****************************************************/
for (kj=0; kj<GL_Mesh; kj++){
kmin = Radial_kmin;
kmax = PAO_Nkmax;
Sk = kmax + kmin;
Dk = kmax - kmin;
norm_k = 0.50*(Dk*GL_Abscissae[kj] + Sk);
GL_NormK[kj] = norm_k;
}
/***********************************************************
sending and receiving of Spe_VNA_Bessel by MPI
***********************************************************/
for (ID=0; ID<Num_Procs2; ID++){
NumSpe = Species_End[ID] - Species_Top[ID] + 1;
for (Lspe=0; Lspe<NumSpe; Lspe++){
spe = Species_Top[ID] + Lspe;
for (L=0; L<=List_YOUSO[35]; L++){
for (Mul=0; Mul<List_YOUSO[34]; Mul++){
MPI_Bcast(&Spe_VNA_Bessel[spe][L][Mul][0],
GL_Mesh,MPI_DOUBLE,ID,mpi_comm_level1);
}
}
}
}
/***********************************************************
save Spe_VNA_Bessel
***********************************************************/
if (myid==Host_ID){
sprintf(fileFT,"%s%s_rst/%s.ftPEvna",filepath,filename,filename);
if ((fp = fopen(fileFT,"wb")) != NULL){
for (spe=0; spe<SpeciesNum; spe++){
for (L=0; L<=List_YOUSO[35]; L++){
for (Mul=0; Mul<List_YOUSO[34]; Mul++){
fwrite(&Spe_VNA_Bessel[spe][L][Mul][0],sizeof(double),GL_Mesh,fp);
}
}
}
fclose(fp);
}
else{
printf("Could not open a file %s in FT_ProExpn_VNA\n",fileFT);
}
}
} /* if (RestartRead_Succeed==0) */
/***********************************************************
elapsed time
***********************************************************/
dtime(&TEtime);
/*
printf("myid=%2d Elapsed Time (s) = %15.12f\n",myid,TEtime-TStime);
MPI_Finalize();
exit(0);
*/
}
void FT_VNA()
{
int numprocs,myid,ID,tag=999;
int count,NumSpe;
int L,i,j;
int Lspe,spe,GL,Mul;
int RestartRead_Succeed;
double Sr,Dr,Sk,Dk,kmin,kmax;
double norm_k,h,dum0;
double xmin,xmax,x,r,sum;
double sj;
double tmp0,tmp1;
double *tmp_SphB,*tmp_SphBp;
double TStime, TEtime;
/* for MPI */
MPI_Status stat;
MPI_Request request;
/* for OpenMP */
int OMPID,Nthrds,Nprocs;
char fileFT[YOUSO10];
char operate[300];
FILE *fp;
size_t size;
dtime(&TStime);
/* MPI */
MPI_Comm_size(mpi_comm_level1,&numprocs);
MPI_Comm_rank(mpi_comm_level1,&myid);
if (myid==Host_ID && 0<level_stdout) printf("<FT_VNA> Fourier transform of VNA potentials\n");
RestartRead_Succeed = 0;
/***********************************************************
In case of Scf_RestartFromFile==1, read Spe_CrudeVNA_Bessel
***********************************************************/
if (Scf_RestartFromFile) {
/****************************************************
regenerate radial grids in the k-space
for the MPI calculation
****************************************************/
for (j=0; j<GL_Mesh; j++) {
kmin = Radial_kmin;
kmax = PAO_Nkmax;
Sk = kmax + kmin;
Dk = kmax - kmin;
norm_k = 0.50*(Dk*GL_Abscissae[j] + Sk);
GL_NormK[j] = norm_k;
}
/***********************************************************
read Spe_VNA_Bessel
***********************************************************/
sprintf(fileFT,"%s%s_rst/%s.ftCvna",filepath,filename,filename);
if ((fp = fopen(fileFT,"rb")) != NULL) {
RestartRead_Succeed = 1;
for (spe=0; spe<SpeciesNum; spe++) {
for (L=0; L<=List_YOUSO[35]; L++) {
for (Mul=0; Mul<List_YOUSO[34]; Mul++) {
size = fread(&Spe_CrudeVNA_Bessel[spe][0],sizeof(double),GL_Mesh,fp);
if (size!=GL_Mesh) RestartRead_Succeed = 0;
}
}
}
fclose(fp);
}
else {
printf("Could not open a file %s in FT_VNA\n",fileFT);
}
}
/***********************************************************
if (RestartRead_Succeed==0), calculate Spe_CrudeVNA_Bessel
***********************************************************/
if (RestartRead_Succeed==0) {
/* loop for Lspe */
for (Lspe=0; Lspe<MSpeciesNum; Lspe++) {
spe = Species_Top[myid] + Lspe;
/****************************************************
\int jL(k*r)RL r^2 dr
****************************************************/
/* tabulation on Gauss-Legendre radial grid */
kmin = Radial_kmin;
kmax = PAO_Nkmax;
Sk = kmax + kmin;
Dk = kmax - kmin;
xmin = sqrt(Spe_PAO_RV[spe][0]);
xmax = sqrt(Spe_Atom_Cut1[spe] + 0.5);
h = (xmax - xmin)/(double)OneD_Grid;
/* loop for j */
#pragma omp parallel shared(spe,Dk,Sk,GL_Abscissae,xmin,xmax,h,OneD_Grid,Spe_CrudeVNA_Bessel) private(OMPID,Nthrds,Nprocs,j,norm_k,sum,x,r,i,tmp_SphB,tmp_SphBp,sj)
{
/* allocate arrays */
tmp_SphB = (double*)malloc(sizeof(double)*3);
tmp_SphBp = (double*)malloc(sizeof(double)*3);
/* get info. on OpenMP */
OMPID = omp_get_thread_num();
Nthrds = omp_get_num_threads();
Nprocs = omp_get_num_procs();
for ( j=OMPID; j<GL_Mesh; j+=Nthrds ) {
norm_k = 0.50*(Dk*GL_Abscissae[j] + Sk);
/**************************
trapezoidal rule
grid: r = x^2
dr = 2*x*dx
***************************/
sum = 0.0;
for (i=0; i<=OneD_Grid; i++) {
x = xmin + (double)i*h;
r = x*x;
Spherical_Bessel(norm_k*r,0,tmp_SphB,tmp_SphBp);
sj = tmp_SphB[0];
if (i==0 || i==OneD_Grid)
sum += r*r*x*sj*VNAF(spe,r);
else
sum += 2.0*r*r*x*sj*VNAF(spe,r);
}
sum = sum*h;
Spe_CrudeVNA_Bessel[spe][j] = sum;
} /* j */
/* free arrays */
free(tmp_SphB);
free(tmp_SphBp);
#pragma omp flush(Spe_CrudeVNA_Bessel)
} /* #pragma omp parallel */
} /* Lspe */
/****************************************************
regenerate radial grids in the k-space
for the MPI calculation
****************************************************/
for (j=0; j<GL_Mesh; j++) {
kmin = Radial_kmin;
kmax = PAO_Nkmax;
Sk = kmax + kmin;
Dk = kmax - kmin;
norm_k = 0.50*(Dk*GL_Abscissae[j] + Sk);
GL_NormK[j] = norm_k;
}
/***********************************************************
sending and receiving of Spe_CrudeVNA_Bessel by MPI
***********************************************************/
for (ID=0; ID<Num_Procs2; ID++) {
NumSpe = Species_End[ID] - Species_Top[ID] + 1;
for (Lspe=0; Lspe<NumSpe; Lspe++) {
spe = Species_Top[ID] + Lspe;
MPI_Bcast(&Spe_CrudeVNA_Bessel[spe][0],
GL_Mesh,MPI_DOUBLE,ID,mpi_comm_level1);
}
}
/***********************************************************
save Spe_CrudeVNA_Bessel
***********************************************************/
if (myid==Host_ID) {
sprintf(fileFT,"%s%s_rst/%s.ftCvna",filepath,filename,filename);
if ((fp = fopen(fileFT,"wb")) != NULL) {
for (spe=0; spe<SpeciesNum; spe++) {
fwrite(&Spe_CrudeVNA_Bessel[spe][0],sizeof(double),GL_Mesh,fp);
}
fclose(fp);
}
else {
printf("Could not open a file %s in FT_VNA\n",fileFT);
}
}
} /* if (RestartRead_Succeed==0) */
/***********************************************************
elapsed time
***********************************************************/
dtime(&TEtime);
/*
printf("myid=%2d Elapsed Time (s) = %15.12f\n",myid,TEtime-TStime);
MPI_Finalize();
exit(0);
*/
}
void FT_NLP()
{
int numprocs,myid,ID,tag=999;
int count,NumSpe;
int i,kj,num_k,so;
int Lspe,spe,L,GL,MaxGL;
double dk,norm_k;
double rmin,rmax,r,r2,h,sum[2];
double **SphB;
double *tmp_SphB,*tmp_SphBp;
double TStime, TEtime;
/* for MPI */
MPI_Status stat;
MPI_Request request;
/* for OpenMP */
int OMPID,Nthrds,Nprocs;
dtime(&TStime);
/* MPI */
MPI_Comm_size(mpi_comm_level1,&numprocs);
MPI_Comm_rank(mpi_comm_level1,&myid);
if (myid==Host_ID) printf("<FT_NLP> Fourier transform of non-local projectors\n");
for (Lspe=0; Lspe<MSpeciesNum; Lspe++){
spe = Species_Top[myid] + Lspe;
num_k = Ngrid_NormK;
dk = PAO_Nkmax/(double)num_k;
rmin = Spe_VPS_RV[spe][0];
rmax = Spe_Atom_Cut1[spe] + 0.5;
h = (rmax - rmin)/(double)OneD_Grid;
/* kj loop */
#pragma omp parallel shared(Spe_VPS_List,spe,Spe_Num_RVPS,num_k,dk,OneD_Grid,rmin,h,VPS_j_dependency,Spe_NLRF_Bessel) private(MaxGL,L,GL,SphB,tmp_SphB,tmp_SphBp,OMPID,Nthrds,Nprocs,norm_k,i,r,r2,sum,so,kj)
{
/* allocate SphB */
MaxGL = -1;
for (L=1; L<=Spe_Num_RVPS[spe]; L++){
GL = Spe_VPS_List[spe][L];
if (MaxGL<GL) MaxGL = GL;
}
SphB = (double**)malloc(sizeof(double*)*(MaxGL+3));
for(GL=0; GL<(MaxGL+3); GL++){
SphB[GL] = (double*)malloc(sizeof(double)*(OneD_Grid+1));
}
tmp_SphB = (double*)malloc(sizeof(double)*(MaxGL+3));
tmp_SphBp = (double*)malloc(sizeof(double)*(MaxGL+3));
/* get info. on OpenMP */
OMPID = omp_get_thread_num();
Nthrds = omp_get_num_threads();
Nprocs = omp_get_num_procs();
for ( kj=OMPID; kj<num_k; kj+=Nthrds ){
norm_k = (double)kj*dk;
/* calculate SphB */
for (i=0; i<=OneD_Grid; i++){
r = rmin + (double)i*h;
Spherical_Bessel(norm_k*r,MaxGL,tmp_SphB,tmp_SphBp);
r2 = r*r;
for(GL=0; GL<=MaxGL; GL++){
SphB[GL][i] = tmp_SphB[GL]*r2;
}
}
for(GL=0; GL<=MaxGL; GL++){
SphB[GL][0] *= 0.5;
SphB[GL][OneD_Grid] *= 0.5;
}
/* loof for L */
for (L=1; L<=Spe_Num_RVPS[spe]; L++){
GL = Spe_VPS_List[spe][L];
/****************************************************
\int jL(k*r)*RL*r^2 dr
****************************************************/
sum[0] = 0.0;
sum[1] = 0.0;
for (i=0; i<=OneD_Grid; i++){
r = rmin + (double)i*h;
for (so=0; so<=VPS_j_dependency[spe]; so++){
sum[so] += Nonlocal_RadialF(spe,L-1,so,r)*SphB[GL][i];
}
}
for (so=0; so<=VPS_j_dependency[spe]; so++){
Spe_NLRF_Bessel[so][spe][L][kj] = sum[so]*h;
}
} /* L */
} /* kj */
/* free arrays */
for(GL=0; GL<(MaxGL+3); GL++){
free(SphB[GL]);
}
free(SphB);
free(tmp_SphB);
free(tmp_SphBp);
#pragma omp flush(Spe_NLRF_Bessel)
} /* #pragma omp parallel */
} /* Lspe */
/****************************************************
Remedy for MSpeciesNum==0
generate radial grids in the k-space
****************************************************/
dk = PAO_Nkmax/(double)Ngrid_NormK;
for (i=0; i<Ngrid_NormK; i++){
NormK[i] = (double)i*dk;
}
/***********************************************************
sending and receiving of Spe_RF_Bessel by MPI
***********************************************************/
for (ID=0; ID<Num_Procs2; ID++){
NumSpe = Species_End[ID] - Species_Top[ID] + 1;
for (Lspe=0; Lspe<NumSpe; Lspe++){
spe = Species_Top[ID] + Lspe;
for (so=0; so<=VPS_j_dependency[spe]; so++){
for (L=1; L<=Spe_Num_RVPS[spe]; L++){
MPI_Bcast(&Spe_NLRF_Bessel[so][spe][L][0],
List_YOUSO[15],MPI_DOUBLE,ID,mpi_comm_level1);
}
}
}
}
/***********************************************************
elapsed time
***********************************************************/
dtime(&TEtime);
/*
printf("myid=%2d Elapsed Time (s) = %15.12f\n",myid,TEtime-TStime);
MPI_Finalize();
exit(0);
*/
}
void FT_ProductPAO()
{
int numprocs,myid,ID,tag=999;
int count,NumSpe;
int L,i,j,kj,l,Lmax;
int Lspe,spe,GL,GL1,Mul1,GL2,Mul2;
double Sr,Dr,Sk,Dk,kmin,kmax;
double norm_k,h,dum0;
double rmin,rmax,r,sum;
double sj,sy,sjp,syp;
double RGL[GL_Mesh+2];
double Tmp_RGL[GL_Mesh+2];
double SumTmp;
double tmp0,tmp1;
double ***GL_PAO;
double **SphB;
double *tmp_SphB,*tmp_SphBp;
double TStime, TEtime;
/* for MPI */
MPI_Status stat;
MPI_Request request;
/* for OpenMP */
int OMPID,Nthrds,Nprocs;
dtime(&TStime);
/* MPI */
MPI_Comm_size(mpi_comm_level1,&numprocs);
MPI_Comm_rank(mpi_comm_level1,&myid);
if (myid==Host_ID) printf("<FT_ProductPAO> Fourier transform of product of PAOs\n");
for (Lspe=0; Lspe<MSpeciesNum; Lspe++){
spe = Species_Top[myid] + Lspe;
/* initalize */
rmin = Spe_VPS_RV[spe][0];
rmax = Spe_Atom_Cut1[spe] + 0.5;
Sr = rmax + rmin;
Dr = rmax - rmin;
for (i=0; i<GL_Mesh; i++){
RGL[i] = 0.50*(Dr*GL_Abscissae[i] + Sr);
Tmp_RGL[i] = RGL[i]*RGL[i]*GL_Weight[i];
}
kmin = Radial_kmin;
kmax = PAO_Nkmax;
Sk = kmax + kmin;
Dk = kmax - kmin;
#pragma omp parallel shared(Spe_ProductRF_Bessel,RGL,Tmp_RGL,Dr,Dk,Sk,GL_Abscissae,List_YOUSO,Spe_MaxL_Basis,spe,Spe_Num_Basis) private(GL_PAO,i,j,GL1,Mul1,GL2,Lmax,Mul2,l,SumTmp,sj,r,SphB,GL,tmp_SphB,tmp_SphBp,OMPID,Nthrds,Nprocs,kj,norm_k)
{
/****************************************************
\int RL * RL' * jl(k*r) r^2 dr
****************************************************/
/* allocation of GL_PAO */
GL_PAO = (double***)malloc(sizeof(double**)*(List_YOUSO[25]+1));
for (i=0; i<(List_YOUSO[25]+1); i++){
GL_PAO[i] = (double**)malloc(sizeof(double*)*List_YOUSO[24]);
for (j=0; j<List_YOUSO[24]; j++){
GL_PAO[i][j] = (double*)malloc(sizeof(double)*(GL_Mesh + 2));
}
}
/* calculate GL_PAO */
for (GL1=0; GL1<=Spe_MaxL_Basis[spe]; GL1++){
for (Mul1=0; Mul1<Spe_Num_Basis[spe][GL1]; Mul1++){
for (i=0; i<GL_Mesh; i++){
r = RGL[i];
GL_PAO[GL1][Mul1][i] = RadialF(spe,GL1,Mul1,r);
}
}
}
/* allocate arrays */
SphB = (double**)malloc(sizeof(double*)*(2*Spe_MaxL_Basis[spe]+3));
for(GL=0; GL<(2*Spe_MaxL_Basis[spe]+3); GL++){
SphB[GL] = (double*)malloc(sizeof(double)*GL_Mesh);
}
tmp_SphB = (double*)malloc(sizeof(double)*(2*Spe_MaxL_Basis[spe]+3));
tmp_SphBp = (double*)malloc(sizeof(double)*(2*Spe_MaxL_Basis[spe]+3));
/* get info. on OpenMP */
OMPID = omp_get_thread_num();
Nthrds = omp_get_num_threads();
Nprocs = omp_get_num_procs();
/* kj loop */
for ( kj=OMPID; kj<GL_Mesh; kj+=Nthrds ){
norm_k = 0.50*(Dk*GL_Abscissae[kj] + Sk);
/* calculate SphB */
for (i=0; i<GL_Mesh; i++){
r = RGL[i];
Spherical_Bessel(norm_k*r,2*Spe_MaxL_Basis[spe],tmp_SphB,tmp_SphBp);
for(GL=0; GL<=2*Spe_MaxL_Basis[spe]; GL++){
SphB[GL][i] = tmp_SphB[GL];
}
}
/* \tilde{R}_{L,L',l} */
for (GL1=0; GL1<=Spe_MaxL_Basis[spe]; GL1++){
for (Mul1=0; Mul1<Spe_Num_Basis[spe][GL1]; Mul1++){
for (GL2=0; GL2<=Spe_MaxL_Basis[spe]; GL2++){
if (GL1<=GL2){
Lmax = 2*GL2;
for (Mul2=0; Mul2<Spe_Num_Basis[spe][GL2]; Mul2++){
for(l=0; l<=Lmax; l++){
/* Gauss-Legendre quadrature */
SumTmp = 0.0;
for (i=0; i<GL_Mesh; i++){
r = RGL[i];
sj = SphB[l][i];
SumTmp += Tmp_RGL[i]*sj*GL_PAO[GL1][Mul1][i]*GL_PAO[GL2][Mul2][i];
}
Spe_ProductRF_Bessel[spe][GL1][Mul1][GL2][Mul2][l][kj] = 0.5*Dr*SumTmp;
}
}
}
}
}
}
} /* kj */
/* free arrays */
for (i=0; i<(List_YOUSO[25]+1); i++){
for (j=0; j<List_YOUSO[24]; j++){
free(GL_PAO[i][j]);
}
free(GL_PAO[i]);
}
free(GL_PAO);
/* free SphB */
for(GL=0; GL<(2*Spe_MaxL_Basis[spe]+3); GL++){
free(SphB[GL]);
}
free(SphB);
free(tmp_SphB);
free(tmp_SphBp);
#pragma omp flush(Spe_ProductRF_Bessel)
} /* #pragma omp parallel */
} /* Lspe */
/****************************************************
regenerate radial grids in the k-space
for the MPI calculation
****************************************************/
for (j=0; j<GL_Mesh; j++){
kmin = Radial_kmin;
kmax = PAO_Nkmax;
Sk = kmax + kmin;
Dk = kmax - kmin;
norm_k = 0.50*(Dk*GL_Abscissae[j] + Sk);
GL_NormK[j] = norm_k;
}
/***********************************************************
sending and receiving of Spe_CrudeVNA_Bessel by MPI
***********************************************************/
MPI_Barrier(mpi_comm_level1);
for (ID=0; ID<Num_Procs2; ID++) {
NumSpe = Species_End[ID] - Species_Top[ID] + 1;
for (Lspe=0; Lspe<NumSpe; Lspe++){
spe = Species_Top[ID] + Lspe;
for (GL1=0; GL1<=Spe_MaxL_Basis[spe]; GL1++){
for (Mul1=0; Mul1<Spe_Num_Basis[spe][GL1]; Mul1++){
for (GL2=0; GL2<=Spe_MaxL_Basis[spe]; GL2++){
if (GL1<=GL2){
Lmax = 2*GL2;
for (Mul2=0; Mul2<Spe_Num_Basis[spe][GL2]; Mul2++){
for(l=0; l<=Lmax; l++){
MPI_Bcast(&Spe_ProductRF_Bessel[spe][GL1][Mul1][GL2][Mul2][l][0],
GL_Mesh,MPI_DOUBLE,ID,mpi_comm_level1);
MPI_Barrier(mpi_comm_level1);
}
}
}
}
}
}
}
}
/***********************************************************
elapsed time
***********************************************************/
dtime(&TEtime);
/*
printf("myid=%2d Elapsed Time (s) = %15.12f\n",myid,TEtime-TStime);
MPI_Finalize();
exit(0);
*/
}
