void paw_end_LogGrid()
{
paw_dealloc_LogGrid(rgrid);
paw_dealloc_LogGrid(rgrid2);
paw_dealloc_LogGrid(rgrid3);
paw_dealloc_LogGrid(scratch);
}
/****************************************
Function name : paw_generate_pseudopot
Description :
Return type : void
Author : Marat Valiev
Date & Time : 4/10/99 7:40:00 PM
****************************************/
void paw_generate_pseudopot()
{
int k;
int Ngrid;
double charge;
double ps_charge;
double Z;
double *Vh;
double *Vx;
double *Vc;
double *rho;
double *rho_ps;
double *rho_core;
double *rho_core_ps;
double *full_density;
double *full_ps_density;
double* V_comp;
double *rgrid;
FILE *fp;
char data_filename[300];
if ( !(paw_projectors_are_done()) )
{
printf("error, pseudopotential cannot be generated ");
printf(" because projectors have not been yet \n");
exit(1);
}
Ngrid = paw_N_LogGrid();
rgrid = paw_r_LogGrid();
Vh = paw_alloc_LogGrid();
Vx = paw_alloc_LogGrid();
Vc = paw_alloc_LogGrid();
full_density = paw_alloc_LogGrid();
full_ps_density = paw_alloc_LogGrid();
Z = paw_get_ion_charge();
paw_set_core();
/*get densities*/
rho = paw_get_pointer_paw_density();
rho_ps = paw_get_pointer_paw_ps_density();
rho_core = paw_get_pointer_core_density();
rho_core_ps = paw_get_pointer_ps_core_density();
paw_Zero_LogGrid(full_density);
paw_Zero_LogGrid(full_ps_density);
for (k=0;k<=Ngrid-1;k++)
{
full_density[k] = rho[k] + rho_core[k];
full_ps_density[k] = rho_ps[k] + rho_core_ps[k];
}
charge = paw_Integrate_LogGrid(full_density);
ps_charge = paw_Integrate_LogGrid(full_ps_density);
V_comp = paw_find_comp_charge_potential(Z,charge,ps_charge);
paw_generate_hartree_pot(full_ps_density);
Vh = paw_get_hartree_pot();
paw_generate_exchange_pot_LDA(full_ps_density);
Vx = paw_get_exchange_potential();
paw_generate_corr_pot_LDA(full_ps_density);
Vc = paw_get_corr_pot_LDA();
/*form pseudopotential*/
for (k=0;k<=Ngrid-1;k++)
{
V_pseudo[k] = V_ref[k] - Vh[k]- V_comp[k]- Vc[k] - Vx[k];
}
if (paw_debug())
{
sprintf(data_filename,"%sdensity",paw_sdir());
fp = fopen(data_filename,"w");
for (k=0;k<Ngrid;++k)
fprintf(fp,"%f %f %f\n",rgrid[k],rho[k] - rho_ps[k],V_pseudo[k]);
fclose(fp);
}
paw_dealloc_LogGrid(full_density);
paw_dealloc_LogGrid(full_ps_density);
}
/****************************************
Function name : solve_pseudo_orbitals
Description :
Return type : void
Author : Marat Valiev
Date & Time : 4/7/99 2:31:16 PM
****************************************/
void paw_generate_pseudo_orbitals()
{
int i;
int k;
int Ngrid;
int max_iter;
int converged;
int iteration;
int match;
int status;
double log_amesh;
double f1,f2;
double *V;
double *rgrid;
double *f;
double norm;
char output[300];
FILE *fp;
Ngrid = paw_N_LogGrid();
rgrid = paw_r_LogGrid();
log_amesh = paw_log_amesh_LogGrid();
/*set maximum number of iterations*/
max_iter = 600;
for (i = 0; i <= nbasis-1; i++)
{
iteration = 0;
converged = False;
status = False;
match = i_r_orbital[i];
/*Start the selfconsistent loop over given ps state */
while ((iteration <= max_iter) && (!converged))
{
++iteration;
/* get pseudopotential*/
V = paw_get_paw_potential(i);
/*
if(orb_type[i]==bound || orb_type[i]==virt)
{
status = paw_R_Schrodinger(prin_n_ps[i],
orb_l[i],
V,
&e_ps[i],
phi_ps[i],
phi_ps_prime[i]);
}
else if(orb_type[i]==scattering)
{
status = paw_R_Schrodinger_Fixed_Logderiv(prin_n_ps[i],
orb_l[i],
V,
match,
log_deriv[i],
&e_ps[i],
phi_ps[i],
phi_ps_prime[i]);
}
else
{
printf("unknown orbital type\n");
exit(1);
}
*/
status = paw_R_Schrodinger_Fixed_Logderiv(prin_n_ps[i],
orb_l[i],
V,
match,
log_deriv[i],
&e_ps[i],
phi_ps[i],
phi_ps_prime[i]);
/*Update pseudopotential potential*/
paw_update_paw_potential(&converged, i, e[i], e_ps[i],phi_ps[i]);
}
/*report on convergence status*/
if (converged && (status))
{
if (paw_debug()) printf("\n%d%d pseudo orbital with the eigenvalue=%f has been found\n",
prin_n[i], orb_l[i], e_ps[i]);
}
else
{
if (paw_debug()) printf("Unable to find %d%d orbital\n ",
prin_n[i], orb_l[i]);
}
norm = phi[i][match]/phi_ps[i][match];
/*scale ps orbital */
for (k=0;k<=match;k++)
{
phi_ps[i][k]=phi_ps[i][k]*norm;
phi_ps_prime[i][k]=phi_ps_prime[i][k]*norm;
}
for (k=match+1;k<=Ngrid-1;k++)
{
phi_ps[i][k]=phi[i][k];
phi_ps_prime[i][k]=phi_prime[i][k];
}
}
if (paw_debug())
{
for (i = 0; i <= nbasis-1; ++i)
{
sprintf(output, "%s%s%d%d", paw_sdir(),"test",prin_n[i],orb_l[i]);
fp = fopen(output, "w+");
for (k = 0; k < Ngrid; k++)
{
fprintf(fp, "%f\t%f\t%f\n", rgrid[k], phi[i][k],phi_ps[i][k]);
}
fclose(fp);
}
}
pseudo_orbitals_done = True;
/* save original basis functions */
for (i=0;i<=nbasis-1;i++)
{
for (k = 0; k <= Ngrid-1; k++)
{
phi0[i][k] = phi[i][k];
phi0_prime[i][k] = phi_prime[i][k];
phi_ps0[i][k] = phi_ps[i][k];
phi_ps0_prime[i][k] = phi_ps_prime[i][k];
}
}
/* calculate densities */
paw_Zero_LogGrid(rho);
paw_Zero_LogGrid(rho_ps);
for (i = 0; i <= nbasis-1; i++)
{
for (k = 0; k <= Ngrid-1; k++)
{
rho[k] += fill[i]*pow((phi0[i][k]/rgrid[k]),2.0);
rho_ps[k] += fill[i]*pow((phi_ps0[i][k]/rgrid[k]),2.0);
}
}
/*calculate kinetic energy*/
ekin = paw_get_kinetic_energy(nbasis, orb_l, fill, phi, phi_prime);
f = paw_alloc_LogGrid();
for (i = 0; i <= nbasis-1; i++)
{
for (k=0; k<=Ngrid-1; k++)
{
f[k] = 0.5*phi_prime[i][k]/(rgrid[k]*log_amesh)*
phi_prime[i][k]/(rgrid[k]*log_amesh) -
0.5*phi_ps_prime[i][k]/(rgrid[k]*log_amesh)*
phi_ps_prime[i][k]/(rgrid[k]*log_amesh);
}
f1 = paw_Def_Integr(0.0,f,0.0,Ngrid-1);
for (k=0; k<=Ngrid-1; k++)
{
f[k] = 0.5*phi_prime[i][k]/(rgrid[k]*log_amesh)*
phi_prime[i][k]/(rgrid[k]*log_amesh);
}
f2 = paw_Def_Integr(0.0,f,0.0,Ngrid-1);
delta_ekin[i] = (int)(100*f1/f2);
if (paw_debug())
printf("kinetic energy of the %d%s orbital was reduced by %d%s\n",
prin_n[i],paw_spd_Name(orb_l[i]),delta_ekin[i],"%");
}
paw_dealloc_LogGrid(f);
}
void paw_end_paw_basis()
{
int i;
for (i = 0; i < nbasis; ++i)
{
paw_dealloc_LogGrid(phi0[i]);
paw_dealloc_LogGrid(phi[i]);
paw_dealloc_LogGrid(phi_prime[i]);
paw_dealloc_LogGrid(phi_ps0[i]);
paw_dealloc_LogGrid(phi_ps[i]);
paw_dealloc_LogGrid(phi_ps_prime[i]);
paw_dealloc_LogGrid(phi_ps0_prime[i]);
paw_dealloc_LogGrid(phi0_prime[i]);
paw_dealloc_LogGrid( prj_ps[i]);
paw_dealloc_LogGrid(prj_ps0[i]);
paw_dealloc_LogGrid(psi_ps[i]);
paw_dealloc_LogGrid( psi_ps_prime[i]);
}
free(phi);
free(phi0);
free(phi_prime);
free(phi_ps0);
free(phi_ps0_prime);
free(phi0_prime);
free(phi_ps);
free(phi_ps_prime);
free(prj_ps);
free(prj_ps0);
free(psi_ps);
free(psi_ps_prime);
free(delta_ekin);
free(orb_type);
free(prin_n_ps);
free(prin_n);
free(orb_l);
free(l_counter);
free(i_r_orbital);
free(r_orbital);
free(fill);
free(e);
free(e_ps);
free(log_deriv);
paw_dealloc_LogGrid(rho);
paw_dealloc_LogGrid(rho_ps);
}
/****************************************
Function name : paw_solve_occupied_orbitals
Description :
Return type : void
Author : Marat Valiev
Date & Time : 4/10/99 6:13:22 PM
****************************************/
void paw_solve_occupied_orbitals()
{
int i;
int j;
int k;
int it;
int converged;
int Ngrid;
int max_iter;
double sum;
double Etmp;
double thl;
double sn;
double sd;
double dr;
double rl0;
double rl1;
double vn;
double Zion;
double *Vo;
double *Vo1;
double *Vi1;
double *Vi;
double *rgrid;
max_iter = 100;
Ngrid = paw_N_LogGrid();
rgrid = paw_r_LogGrid();
/* allocate temporary grids */
Vi = paw_alloc_LogGrid();
Vo1 = paw_alloc_LogGrid();
Vi1 = paw_alloc_LogGrid();
/* set initial guess for KS potential as Thomas-Fermi*/
Zion = paw_get_ion_charge();
paw_Thomas_Fermi(Zion,Vi);
/*initial guess for the eigenvalues*/
paw_guess_eigenvalues(Zion,Vi);
it = 0;
converged = False;
while ((!converged) && (it < max_iter))
{
it = it + 1;
converged = True;
/* solve for each of the eigenstates */
for (i=0; i<= Nvalence-1; i++)
{
Etmp = eigenvalue[i];
if (Solver_Type==Schrodinger)
{
paw_R_Schrodinger(n[i],l[i],Vi,
&Etmp,psi[i],psi_prime[i]);
}
else
{
paw_R_Pauli(n[i],l[i],Zion,Vi,
&Etmp,psi[i],psi_prime[i]);
}
if (fabs(eigenvalue[i] - Etmp) >1.0e-10)
converged = False;
eigenvalue[i]=Etmp;
/*orthogonalize to lower orbitals*/
for (j=0;j<=i-1;j++)
{
if (l[i]==l[j])
{
sum = paw_dot_product(psi[i],psi[j]);
for (k=0;k<Ngrid;++k)
psi[i][k] = psi[i][k] - sum*psi[j][k];
}
}
/*normalize the orbital*/
for (k=0; k<=Ngrid-1; k++)
psi_tmp[k] = pow((psi[i][k]/rgrid[k]),2.0);
sum = paw_Integrate_LogGrid(psi_tmp);
for (k=0; k<=Ngrid-1; k++)
psi[i][k]=psi[i][k]/pow(sum,0.5);
}
/*get new density*/
paw_generate_density(rho);
/*get new potential*/
paw_set_kohn_sham_potential(rho);
Vo = paw_get_kohn_sham_potential();
/*****************************************/
/* Generate the next iteration potential */
/* using D.G. Anderson method */
/*****************************************/
thl = 0.0;
if (it > 1)
{
sn = 0.0;
sd = 0.0;
for (k=0; k<Ngrid; ++k)
{
rl0 = Vo[k] - Vi[k];
rl1 = Vo1[k] - Vi1[k];
dr = rl0 - rl1;
sn = sn + rl0*dr*(rgrid[k]*rgrid[k]);
sd = sd + dr*dr*(rgrid[k]*rgrid[k]);
}
thl = sn/sd;
}
for (k=0; k<=Ngrid-1; k++)
{
vn = (1.0-0.5)*( (1.0-thl)*Vi[k] + thl*Vi1[k] )
+ 0.5 *( (1.0-thl)*Vo[k] + thl*Vo1[k] );
Vi1[k] = Vi[k];
Vo1[k] = Vo[k];
Vi[k] = vn;
}
} /* end while */
if (!converged)
{
printf("Not Converged\n");
exit(1);
}
occupied_orbitals_done = True;
paw_generate_density(rho);
paw_set_kohn_sham_potential(rho);
/* free up temporary memory */
paw_dealloc_LogGrid(Vi);
paw_dealloc_LogGrid(Vo1);
paw_dealloc_LogGrid(Vi1);
}
void paw_R_Schrodinger_Fixed_E1(
int l,
double *v,
double *f,
int match,
double E,
double *u,
double *uprime
)
{
int i,j,
Ngrid;
double log_amesh,
log_amesh2,
gamma,
L2,
r2,
*r,
*f_upp,
*upp;
double max_u;
/*set maximum allowed value for u*/
max_u = 10000000;
/* define power of the orbital near 0 */
gamma = ((double) (l+1));
/* define square of the angular momentum */
L2 = ((double) (l*(l+1)));
/* define log grid parameters */
Ngrid = paw_N_LogGrid();
log_amesh = paw_log_amesh_LogGrid();
log_amesh2 = log_amesh*log_amesh;
if (match > Ngrid-1)
{
printf("match point is outside the allowed region\n");
printf("abborting the program\n");
exit(1);
}
/* get pointer rgrid, and extra memory */
r = (double *) paw_r_LogGrid();
f_upp = (double *) paw_alloc_LogGrid();
upp = (double *) paw_alloc_LogGrid();
for (i=0; i<=match; i++)
{
u[i] = 0.0;
uprime[i] = 0.0;
}
/* define f_upp */
for (i=0; i<match+1; ++i)
{
r2 = r[i]*r[i];
f_upp[i] = log_amesh2*(L2 + 2.0*(v[i] - E)*r2);
}
for (i=0; i<4; ++i)
{
u[i] = pow(r[i],gamma);
uprime[i] = log_amesh*gamma*u[i];
upp[i] = log_amesh*uprime[i] + f_upp[i]*u[i];
}
/* integrate from 0 to match */
i=3;
while (i<match && fabs(u[i])<max_u)
{
/* predictors */
u[i+1] = paw_Predictor_Out(i,u,uprime);
uprime[i+1] = paw_Predictor_Out(i,uprime,upp);
/* correctors */
for (j=0; j<Corrector_Iterations; ++j)
{
upp[i+1] = log_amesh*uprime[i+1] + f_upp[i+1]*u[i+1]- 2.0*log_amesh2*r[i+1]*r[i+1]*f[i+1];
uprime[i+1] = paw_Corrector_Out(i,uprime,upp);
u[i+1] = paw_Corrector_Out(i,u,uprime);
}
i = i+1;
}
/* dealloc memory */
paw_dealloc_LogGrid(upp);
paw_dealloc_LogGrid(f_upp);
return;
} /* paw_R_Schrodinger */
int paw_R_Schrodinger_Fixed_Logderiv1(
int n,
int l,
double *v,
int match,
double u_logderiv,
double *Eig,
double *u,
double *uprime
)
{
int i;
int j;
int iteration;
int Ngrid;
double sum;
double E;
double de;
double Emax;
double Emin;
double log_amesh;
double log_amesh2;
double gamma;
double L2;
double r2;
double uout;
double upout;
double upin;
double *r;
double *f_upp;
double *upp;
/* define eigenvalues */
E = *Eig;
/* define power of the orbital near 0 */
gamma = ((double) (l+1));
/* define square of the angular momentum */
L2 = ((double) (l*(l+1)));
/* define log grid parameters */
Ngrid = paw_N_LogGrid();
log_amesh = paw_log_amesh_LogGrid();
log_amesh2 = log_amesh*log_amesh;
/* get pointer rgrid, and extra memory */
r = (double *) paw_r_LogGrid();
f_upp = (double *) paw_alloc_LogGrid();
upp = (double *) paw_alloc_LogGrid();
/* set up bounds for eigenvalue */
Emax = E + 10.0;
Emin = E - 10.0;
iteration = 0;
while (iteration < Max_Iterations)
{
++iteration;
/* define f_upp */
for (i=0; i<Ngrid; ++i)
{
r2 = r[i]*r[i];
f_upp[i] = log_amesh2*(L2 + 2.0*(v[i] - E)*r2);
}
/* set the boundry condition near zero */
for (i=0; i<4; ++i)
{
u[i] = pow(r[i],gamma);
uprime[i] = log_amesh*gamma*u[i];
upp[i] = log_amesh*uprime[i] + f_upp[i]*u[i];
}
/* integrate from 0 to match */
for (i=3; i<match; ++i)
{
/* predictors */
u[i+1] = paw_Predictor_Out(i,u,uprime);
uprime[i+1] = paw_Predictor_Out(i,uprime,upp);
/* correctors */
for (j=0; j<Corrector_Iterations; ++j)
{
upp[i+1] = log_amesh*uprime[i+1] + f_upp[i+1]*u[i+1];
uprime[i+1] = paw_Corrector_Out(i,uprime,upp);
u[i+1] = paw_Corrector_Out(i,u,uprime);
}
}
uout = u[match];
upout = uprime[match];
upin = u_logderiv*uout;
/* Find Integral(u^2) */
sum = paw_Norm_LogGrid(match,gamma,u);
sum = 1.0/sqrt(sum);
uout = sum*uout;
upout = sum*upout;
upin = sum*upin;
for (i=0; i<=match; ++i)
{
u[i] = sum*u[i];
uprime[i] = sum*uprime[i];
}
for (i=match+1; i<Ngrid; ++i)
{
u[i] = 0.0;
uprime[i] = 0.0;
}
/* figure out new eigenvalue */
de = 0.5*uout*(upout-upin)/(log_amesh*r[match]);
/* eigenvalue is converged, exit */
if (fabs(de) < (Max(fabs(E),0.2)*tolerance))
{
*Eig = E;
/* dealloc memory */
paw_dealloc_LogGrid(upp);
paw_dealloc_LogGrid(f_upp);
return True;
}
if (de > 0.0)
Emin = E;
else
Emax = E;
E = E + de;
if ( (E > Emax) || (E < Emin))
E = 0.5*(Emin+Emax);
} /* while */
printf("paw_Error R_Schrodinger_Fixed_Logderiv: More than %d iterations\n",
Max_Iterations);
*Eig = E;
/* dealloc memory */
paw_dealloc_LogGrid(upp);
paw_dealloc_LogGrid(f_upp);
return False;
} /* paw_R_Schrodinger_Fixed_LogDeriv */
int paw_R_Schrodinger(int n,
int l,
double* v,
double *Eig,
double* u,
double* uprime)
{
int i,j,
iteration,
node,
match,
Ninf, Ngrid;
double E, de,
Emax,
Emin,
log_amesh,
log_amesh2,
gamma,
L2,
sum, a, scale, m1scale,
uout,upout,upin,
*r,
*f_upp,
*r2,
*upp;
/* define eigenvalues */
E = *Eig;
gamma = ((double) (l+1));
L2 = ((double) (l*(l+1)));
/* define log grid parameters */
Ngrid = paw_N_LogGrid();
log_amesh = paw_log_amesh_LogGrid();
log_amesh2 = log_amesh*log_amesh;
/* get pointer rgrid, and extra memory */
r = paw_r_LogGrid();
r2 = paw_r2_LogGrid();
f_upp = paw_alloc_LogGrid();
upp = paw_alloc_LogGrid();
/* set up bounds for eigenvalue */
Emin = 0.0;
Emax = v[Ngrid-1] + 0.5*L2/(r[Ngrid-1]*r[Ngrid-1]);
for (i=0; i <= Ngrid-1; i++)
Emin = Min(Emin, (v[i] + 0.5*L2/r2[i]));
if (E > Emax) E = 1.25*Emax;
if (E < Emin) E = 0.75*Emin;
if (E > Emax) E = 0.5*(Emax+Emin);
iteration = 0;
while (iteration < Max_Iterations)
{
++iteration;
/* define f_upp */
for (i=0; i<Ngrid; ++i)
f_upp[i] = log_amesh2*(L2 + 2.0*(v[i] - E)*r2[i]);
/* classical turning point is used for matching */
match = Ngrid-1;
while (f_upp[match-1]*f_upp[match] > 0.0)
{
match = match - 1;
if (match < 2)
{
printf("Error in paw_R_Schrodinger: no turning point\n");
return False;
}
}
/* set the boundry condition near zero */
m1scale = 1.0;
for (i=0; i<(n-l-1); ++i)
m1scale *= -1.0;
for (i=0; i<=3; i++)
{
u[i] = m1scale*pow(r[i],gamma);
uprime[i] = log_amesh*gamma*u[i];
upp[i] = log_amesh*uprime[i] + f_upp[i]*u[i];
}
/* integrate from 0 to match */
node = 0;
for (i=3; i <= match-1; i++)
{
/* predictors */
u[i+1] = paw_Predictor_Out(i,u,uprime);
uprime[i+1] = paw_Predictor_Out(i,uprime,upp);
/* correctors */
for (j=0; j<= Corrector_Iterations-1; j++)
{
upp[i+1] = log_amesh*uprime[i+1] + f_upp[i+1]*u[i+1];
uprime[i+1] = paw_Corrector_Out(i,uprime,upp);
u[i+1] = paw_Corrector_Out(i,u,uprime);
}
/* finding nodes */
if (u[i+1]*u[i] <= 0) node = node + 1;
}
uout = u[match];
upout = uprime[match];
/* not enough nodes in u */
if ((node-n+l+1) < 0)
{
Emin = E;
E = 0.5*(Emin+Emax);
}
/* too many nodes in u */
else if ((node-n+l+1) > 0)
{
Emax = E;
E = 0.5*(Emin+Emax);
}
/* number of nodes ok, start integration inward */
else
{
/* find infinity
*/
/* find infinity */
Ninf = match + floor(2.3/log_amesh);
if ((Ninf+5) > Ngrid) Ninf = Ngrid - 5;
/* define boundry near infinity */
a = sqrt( L2/(r[Ninf]*r[Ninf]) + 2.0*(v[Ninf]-E) );
for (i=Ninf; i<=(Ninf+4); i++)
{
u[i] = exp(-a*(r[i]-r[Ninf]));
uprime[i] = -r[i]*log_amesh*a*u[i];
upp[i] = log_amesh*uprime[i] + f_upp[i]*u[i];
}
/* integrate from infinity to match */
for (i=Ninf; i>=(match+1); --i)
{
/* predictors */
u[i-1] = paw_Predictor_In(i,u,uprime);
uprime[i-1] = paw_Predictor_In(i,uprime,upp);
/* Correctors */
for (j=0; j<Corrector_Iterations; ++j)
{
upp[i-1] = log_amesh*uprime[i-1] + f_upp[i-1]*u[i-1];
uprime[i-1] = paw_Corrector_In(i,uprime,upp);
u[i-1] = paw_Corrector_In(i,u,uprime);
}
}
/* make the outside u, match the inside u */
scale = uout/u[match];
for (i=match; i<= Ninf; i++)
{
u[i] = scale*u[i];
uprime[i] = scale*uprime[i];
}
upin = uprime[match];
/* Find Integral(u^2) */
sum = paw_Norm_LogGrid(Ninf,gamma,u);
sum = 1.0/sqrt(sum);
uout = sum*uout;
upout = sum*upout;
upin = sum*upin;
for (i=0; i<=Ninf; i++)
{
u[i] = sum*u[i];
uprime[i] = sum*uprime[i];
}
/* figure out new eigenvalue */
de = 0.5*uout*(upout-upin)/(log_amesh*r[match]);
/* eigenvalue is converged, exit */
if (fabs(de) < (Max(fabs(E),0.2)*tolerance))
{
*Eig = E;
for (i=Ninf+1; i<Ngrid; ++i)
{
u[i] = u[Ninf]*exp(-a*(r[i]-r[Ninf]));
uprime[i] = -r[i]*log_amesh*a*u[i];
}
/* dealloc memory */
paw_dealloc_LogGrid(upp);
paw_dealloc_LogGrid(f_upp);
return True;
}
if (de > 0.0)
Emin = E;
else
Emax = E;
E = E + de;
if (Emax<=Emin)
{
/* dealloc memory */
paw_dealloc_LogGrid(upp);
paw_dealloc_LogGrid(f_upp);
*Eig = E;
return False;
}
if ( (E > Emax) || (E < Emin))
E = 0.5*(Emin+Emax);
} /* nodes ok */
} /* while */
printf("Error paw_R_Schrodinger: More than %d iterations\n",Max_Iterations);
*Eig = E;
/* dealloc memory */
paw_dealloc_LogGrid(upp);
paw_dealloc_LogGrid(f_upp);
return False;
} /* paw_R_Schrodinger */
