Пример #1
0
/****************************************
 Function name	  : paw_print_loggrid_information
 Description	    :
 Return type		  : void
 Argument         : FILE *fp
 Author     		  : Marat Valiev
 Date & Time		  : 3/31/99 3:00:49 PM
****************************************/
void  paw_print_loggrid_information(FILE *fp)
{
    fprintf(fp,"\n");
    fprintf(fp," Logarithmic grid information ( r(i)=r0*pow(a,i) ):\n");
    fprintf(fp,"\n");

    fprintf(fp,"   a    = %le\n", paw_amesh_LogGrid());
    fprintf(fp,"   N    = %d\n", paw_N_LogGrid());
    fprintf(fp,"   r0   = %le\n",paw_r0_LogGrid());
    fprintf(fp,"   rmax = %le\n",paw_r_LogGrid()[paw_N_LogGrid()-1]);
    fprintf(fp,"\n");

}
Пример #2
0
/****************************************
 Function name	  : paw_bound_state_test
 Description	    :
 Return type		  : int
 Argument         : int n
 Argument         : int l
 Argument         : double *v
 Author     		  : Marat Valiev
 Date & Time		  : 3/31/99 3:02:14 PM
****************************************/
int paw_bound_state_test(int l, double *v)
{
    int i;
    int Ngrid;
    double L2,r2;
    double Emin;
    double *r;


    Ngrid = paw_N_LogGrid();
    r      = (double *) paw_r_LogGrid();
    L2 = ((double) (l*(l+1)));
    Emin = 0;
    for (i=0; i<Ngrid; ++i)
    {
        r2 = r[i];
        r2 = r2*r2;
        Emin = Min(Emin, (v[i] + 0.5*L2/r2));
    }

    if (Emin>=0)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}
Пример #3
0
/****************************************
 Function name	  : paw_generate_exchange_pot_LDA(double *rho)
 Description	    :
****************************************/
void paw_generate_exchange_pot_LDA(double *rho)

{
    int	i;
    double n;
    double n_onethird;
    double ux_p;

    /* loggrid variables */
    int	   Ngrid;


    /* access the loggrid variables */
    Ngrid     = paw_N_LogGrid();


    for (i=0; i<=Ngrid-1; i++)
    {

        n = rho[i]/(4.0*PI);
        n_onethird = pow((3.0*n/PI),onethird);

        ux_p = -(3.0/2.0)*alpha*n_onethird;

        Vx[i] = ux_p ;

    } /*for i*/


}
Пример #4
0
/****************************************
 Function name	  : paw_solve_pseudo_orbitals
 Description	    :
 Return type		  : void
 Author     		  : Marat Valiev
 Date & Time		  : 5/15/00
****************************************/
void paw_solve_pseudo_orbitals()
{

    int i;
    int k;
    int i_end_point;
    int Ngrid;
    double scale;
    double *rgrid;


    Ngrid = paw_N_LogGrid();
    rgrid = paw_r_LogGrid();


    for (i=0;i<= nbasis-1;i++)
    {

        i_end_point = paw_get_grid_index(1.2*r_orbital[i]);


        paw_solve_paw_scattering(orb_l[i], 3*r_orbital[i], e_ps[i], psi_ps[i],psi_ps_prime[i]);


        if (paw_debug())
            printf("%d%s log derivative   %le  %le \n",prin_n[i],paw_spd_Name(orb_l[i]),
                   psi_ps_prime[i][i_end_point]/(psi_ps[i][i_end_point]*rgrid[i_end_point]*paw_log_amesh_LogGrid()),
                   phi0_prime[i][i_end_point]/(phi0[i][i_end_point]*rgrid[i_end_point]*paw_log_amesh_LogGrid()));

        /*rescale the orbitals*/
        scale = phi_ps0[i][i_r_orbital[i]]/psi_ps[i][i_r_orbital[i]];
        for (k=0;k<=i_end_point;++k)
        {
            psi_ps[i][k]       = psi_ps[i][k]*scale;
            psi_ps_prime[i][k] = psi_ps_prime[i][k]*scale;

        }

        for (k=i_end_point+1;k<=Ngrid-1;++k)
        {
            psi_ps[i][k]       = phi_ps0[i][k];
            psi_ps_prime[i][k] = phi_ps0_prime[i][k];

        }

    }


}
Пример #5
0
/****************************************
 Function name	  : paw_get_correlation_energy_LDA(double *rho)
****************************************/
double paw_get_correlation_energy_LDA(double *rho)
{
    int	i;
    double rs,n;
    double x,xxp;
    double ec_p;
    double Ec;
    double *tmp;

    /* loggrid variables */
    int	   Ngrid;


    /* access the loggrid variables */
    Ngrid     = paw_N_LogGrid();
    tmp		    = paw_scratch_LogGrid();

    /* allocate temporary memory */
    tmp		        = paw_alloc_LogGrid();
    ec_functional = paw_alloc_LogGrid();


    for (i=0; i<= Ngrid-1; i++)
    {
        n     = rho[i]/(4.0*PI);
        rs    = rs_scale/pow(n,onethird);

        x     = sqrt(rs);

        xxp  = rs + bp*x + cp;
        ec_p = cp1*log(rs/xxp) + cp2*log( (x+cp3)*(x+cp3)/xxp)
               + cp4*atan(cp5/(x+cp6));

        ec_functional[i] = ec_p;


    } /*for i*/


    for (i=0; i<= Ngrid-1; i++)
        tmp[i] = rho[i]*ec_functional[i];

    Ec = paw_Integrate_LogGrid(tmp);

    return Ec;

}
Пример #6
0
/****************************************
 Function name	  : paw_init_ion(double Z)
 Description	    :
****************************************/
void paw_init_ion(double Z)
{
    int i;
    int Ngrid;
    double *rgrid;


    Ngrid = paw_N_LogGrid();
    rgrid = paw_r_LogGrid();

    Zion = Z;

    Vion  = paw_alloc_LogGrid();
    for (i=0; i<Ngrid; ++i)
        Vion[i] = -Z/rgrid[i];

}
Пример #7
0
/****************************************
 Function name	  : paw_get_ion_energy
 Description	    :
 Return type		  : double
 Argument         : double *dn
 Author     		  : Marat Valiev
 Date & Time		  : 3/31/99 2:12:25 PM
****************************************/
double paw_get_ion_energy(double *dn)
{
    int    k;
    int Ngrid;
    double *tmp;


    Ngrid = paw_N_LogGrid();
    tmp   = paw_scratch_LogGrid();

    for (k=0; k<Ngrid; ++k)
    {
        tmp[k] = Vion[k]*dn[k];
    }

    Eion = paw_Integrate_LogGrid(tmp);
    return Eion;
}
Пример #8
0
/****************************************
 Function name	  : paw_get_core_density
 Description	    :
 Return type		  : void
 Argument         : double** rho
 Author     		  : Marat Valiev
 Date & Time		  : 3/31/99 3:35:46 PM
****************************************/
void paw_generate_density(double* rho)
{
    int i;
    int k;
    int Ngrid;
    double* rgrid;

    Ngrid = paw_N_LogGrid();
    rgrid = paw_r_LogGrid();

    paw_Zero_LogGrid(rho);
    for (i=0; i<=Nvalence-1; ++i)
    {
        for (k=0; k<Ngrid; ++k)
            rho[k] += fill[i]*pow((psi[i][k]/rgrid[k]),2.0);
    }

}
Пример #9
0
/****************************************
 Function name	  : paw_guess_eigenvalues
 Description	    :
 Return type		  : void
 Argument         : double **V
 Author     		  : Marat Valiev
 Date & Time		  : 3/30/99 11:46:56 PM
****************************************/
void paw_guess_eigenvalues(double Zion, double *V)
{
    int i;
    int Ngrid;
    double echarge;
    double Z;

    Ngrid = paw_N_LogGrid();

    echarge = 0.0;
    for (i=0; i<=Nbound-1; i++)
    {
        echarge += fill[i];
        Z = Zion - echarge + 1.0;
        eigenvalue[i] = -0.5*(Z*Z)/((double) (n[i]*n[i]));
        if (eigenvalue[i] > V[Ngrid-1])
            eigenvalue[i] = 2.0*V[Ngrid-1];
    }
}
Пример #10
0
/****************************************
 Function name    : paw_update_paw_potential
 Description        :
 Return type              : void
 Argument         : int conv_status
 Argument         : int i
 Argument         : double *w
 Author                   : Marat Valiev
 Date & Time              : 1/10/99 6:27:44 PM
****************************************/
void paw_update_paw_potential(int *conv_status, int i, double eig, double eig_ps,double *w)
{

    int     k;
    int Ngrid;
    double  sv;
    double  dcl;
    double  eps;
    double  *tmp;

    eps = 1.0e-7;

    Ngrid = paw_N_LogGrid();
    tmp   = paw_scratch_LogGrid();

    for (k = 0; k <= Ngrid-1; k++)
    {
        tmp[k]= fcut[i][k] * w[k] * w[k];
    }

    sv = paw_Def_Integr(0.0,tmp,0.0,Ngrid-1);

    dcl = (eig - eig_ps) / sv;

    /*In case of the overflow rescale dcl*/

    if (fabs(dcl)>100)
        dcl = 10*fabs(dcl)/dcl;


    c[i] = c[i] + dcl;
    *conv_status = (fabs(dcl) <= eps);


    /*Form new paw potential if necessary*/
    if (!(*conv_status))
        for (k = 0; k <= Ngrid-1; k++)
            V_paw[i][k] = V_ref[k] + c[i] * fcut[i][k];

}
Пример #11
0
/****************************************
 Function name	  : paw_get_exchange_energy_LDA(double *rho)
 Description	    :
****************************************/
double paw_get_exchange_energy_LDA(double *rho)

{
    int	i;
    double n;
    double n_onethird;
    double ex_p;
    double Ex;
    double *tmp;

    /* loggrid variables */
    int	   Ngrid;

    /* access the loggrid variables */
    Ngrid     = paw_N_LogGrid();
    tmp		    = paw_scratch_LogGrid();


    for (i=0; i<Ngrid; ++i)
    {

        n = rho[i]/(4.0*PI);
        n_onethird = pow((3.0*n/PI),onethird);


        ex_p = -(9.0/8.0)*alpha*n_onethird;

        ex_functional[i] = ex_p;

    } /*for i*/



    for (i=0; i<Ngrid; ++i)
        tmp[i] = rho[i]*ex_functional[i];
    Ex = paw_Integrate_LogGrid(tmp);

    return Ex;

}
Пример #12
0
/****************************************
 Function name	  : paw_generate_corr_pot
 Description	    : this routine calculates the spin
                    polarized Vosko et. al. correlation potential.
                    This is a Ceperly and Alder parameterization
 Return type		  : void
 Argument         : double **rho
 Argument         : double **Vc
 Argument         : double *Ec
 Author     		  : Eric Bylaska & Marat Valiev
 Date & Time		  : 1/8/99 1:19:44 PM
****************************************/
void paw_generate_corr_pot_LDA(double *rho)
{
    int	i;
    double rs,n;
    double x,xxp,dxxp;
    double ec_p;
    double uc_p;

    /* loggrid variables */
    int	   Ngrid;


    /* access the loggrid variables */
    Ngrid     = paw_N_LogGrid();


    for (i=0; i<= Ngrid-1; i++)
    {
        n     = rho[i]/(4.0*PI);
        rs    = rs_scale/pow(n,onethird);

        x     = sqrt(rs);

        xxp  = rs + bp*x + cp;
        dxxp = 2.0*x + bp;
        ec_p = cp1*log(rs/xxp) + cp2*log( (x+cp3)*(x+cp3)/xxp)
               + cp4*atan(cp5/(x+cp6));
        uc_p = ec_p
               - onesixth*x*(  dp1/x + dp2/(x+cp3) + dp4*dxxp/xxp
                               + dp5/( (x+dp6)*(x+dp6)+dp7)
                            );

        Vc[i] = uc_p;


    } /*for i*/



} /* R_Vosko */
Пример #13
0
void    paw_generate_projectors_blochl()
{
    int i;
    int j;
    int k;
    int Ngrid;
    double norm;
    double max_prj;
    double max_phi;
    double max_phi_ps;
    double tmp_prj;
    double *V_ref;
    double *V;
    double *rgrid;
    double **b;
    double **L;
    double **U;
    double **L_inv;
    double **U_inv;
    double **test_matrix;
    char  output[300];
    FILE  *fp;


    /*make sure the pseudo orbitalas were found*/
    if (! pseudo_orbitals_done)
    {
        printf("cannot calculate projectors\n");
        printf("pseudo basis is not ready\n");
        exit(1);

    }

    Ngrid = paw_N_LogGrid();
    rgrid = paw_r_LogGrid();

    b = paw_alloc_2d_array(nbasis,nbasis);
    L = paw_alloc_2d_array(nbasis,nbasis);
    L_inv = paw_alloc_2d_array(nbasis,nbasis);
    U = paw_alloc_2d_array(nbasis,nbasis);
    U_inv = paw_alloc_2d_array(nbasis,nbasis);
    test_matrix = paw_alloc_2d_array(nbasis,nbasis);

    /*obtain the ref potential*/
    V_ref = paw_get_ref_pot();

    /*form initial guess for projectors as in Blochl*/
    for (i = 0; i < nbasis; ++i)
    {
        V = paw_get_paw_potential(i);

        for (k = 0; k < Ngrid; ++k)
            prj_ps[i][k] = (V_ref[k] - V[k])*phi_ps[i][k];

        if (paw_debug())
        {
            sprintf(output, "%s%s_%d%d", paw_sdir(),"p",prin_n[i],orb_l[i]);
            fp = fopen(output, "w+");
            for (k = 0; k < Ngrid; ++k)
            {
                fprintf(fp, "%le\t  %le\t %le \n", rgrid[k], prj_ps[i][k],(V_ref[k] - V[k]));
            }
            fclose(fp);
        }

    }

    /*check for accidental null projectors*/
    for (i = 0; i < nbasis; ++i)
    {

        max_prj = 0.0;

        for (k = 0; k < Ngrid; ++k)
        {
            tmp_prj = fabs(prj_ps[i][k]);
            if (tmp_prj > max_prj)
                max_prj = tmp_prj;
        }

        if (max_prj <0.000001)
        {
            printf("found null projectors, aborting the program ... \n");
            exit(1);
        }
    }





    for (i=0;i<=nbasis-1;i++)
    {
        for (j=0;j<=nbasis-1;j++)
        {
            if (orb_l[i] == orb_l[j] )
            {
                b[i][j] = paw_dot_product(phi_ps[j],prj_ps[i]);

            }
            else
            {
                b[i][j] = 0.0;
            }

        }
    }

    paw_lu_decompose(nbasis, b, L, U);
    paw_triang_matrix_inverse("l",nbasis,L,L_inv);

    paw_triang_matrix_inverse("u",nbasis,U,U_inv);

    for (i=0;i<=nbasis-1;i++)
    {
        for (k = 0; k <= Ngrid-1; k++)
            prj_ps0[i][k] = prj_ps[i][k];
    }

    for (i=0;i<=nbasis-1;i++)
    {
        paw_Zero_LogGrid(prj_ps[i]);
        paw_Zero_LogGrid(phi[i]);
        paw_Zero_LogGrid(phi_ps[i]);
        paw_Zero_LogGrid(phi_prime[i]);
        paw_Zero_LogGrid(phi_ps_prime[i]);
    }

    for (i=0;i<=nbasis-1;i++)
    {
        for (j=0;j<=i;j++)
        {

            for (k = 0; k <= Ngrid-1; k++)
            {
                prj_ps[i][k] = prj_ps[i][k] + L_inv[i][j]*prj_ps0[j][k];

                phi[i][k]          = phi[i][k]          + U_inv[j][i]*phi0[j][k];
                phi_ps[i][k]       = phi_ps[i][k]       + U_inv[j][i]*phi_ps0[j][k];
                phi_prime[i][k]    = phi_prime[i][k]    + U_inv[j][i]*phi0_prime[j][k];
                phi_ps_prime[i][k] = phi_ps_prime[i][k] + U_inv[j][i]*phi_ps0_prime[j][k];

            }


        }

    }

    for (i=0;i<=nbasis-1;i++)
        paw_Zero_LogGrid(prj_ps0[i]);

    for (i=0;i<=nbasis-1;i++)
    {
        for (j=0;j<=nbasis-1;j++)
        {

            for (k = 0; k <= Ngrid-1; k++)
            {
                prj_ps0[i][k] = prj_ps0[i][k] + U_inv[i][j]*prj_ps[j][k];

            }


        }

    }


    /*rescale basis*/
    for (i = 0; i <= nbasis-1; i++)
    {

        max_prj = 0.0;
        max_phi = 0.0;
        max_phi_ps = 0.0;

        for (k = 0; k < i_r_orbital[i]; k++)
        {
            if (max_prj < fabs(prj_ps[i][k]))
                max_prj =  fabs(prj_ps[i][k]);

            if (max_phi_ps < fabs(phi_ps[i][k]))
                max_phi_ps =  fabs(phi_ps[i][k]);

        }

        if (max_prj == 0.0 || max_phi_ps == 0.0)
        {
            printf("division by zero while rescaling basis\n");
            exit(99);
        }

        norm = 0.75*sqrt(max_phi_ps/max_prj);

        max_prj = 0.0;
        max_phi = 0.0;
        max_phi_ps = 0.0;

        scaling_factor[i] = norm;

        for (k = 0; k < Ngrid; ++k)
        {
            prj_ps[i][k]       = prj_ps[i][k]*norm;
            phi[i][k]          = phi[i][k]/norm;
            phi_ps[i][k]       = phi_ps[i][k]/norm;
            phi_prime[i][k]    = phi_prime[i][k]/norm;
            phi_ps_prime[i][k] = phi_ps_prime[i][k]/norm;

        }

    }

    for (i = 0; i <= nbasis-1; i++)
    {
        for  (j = 0; j <= nbasis-1; j++)
        {
            tr_matrix[i][j] = U_inv[i][j];
        }
    }
    if (paw_debug())
        printf("derivative=%f\n",phi_ps_prime[0][0]/(rgrid[0]*paw_log_amesh_LogGrid()));

}
Пример #14
0
void    paw_generate_projectors_vanderbilt()
{
    int i;
    int j;
    int k;
    int Ngrid;
    double norm;
    double max_prj;
    double max_phi;
    double max_phi_ps;
    double tmp_prj;
    double *V_ref;
    double *V;
    double *rgrid;
    double **b;
    double **prj_ps0;
    char  output[300];
    FILE  *fp;


    /*make sure the pseudo orbitalas were found*/
    if (! pseudo_orbitals_done)
    {
        printf("cannot calculate projectors\n");
        printf("pseudo basis is not ready\n");
        exit(1);

    }

    Ngrid = paw_N_LogGrid();
    rgrid = paw_r_LogGrid();

    b = paw_alloc_2d_array(nbasis,nbasis);
    prj_ps0 = paw_alloc_2d_array(nbasis,Ngrid);

    /*obtain the ref potential*/
    V_ref = paw_get_ref_pot();

    /*form initial guess for projectors as in Blochl*/
    for (i = 0; i < nbasis; ++i)
    {
        V = paw_get_paw_potential(i);

        for (k = 0; k < Ngrid; ++k)
            prj_ps[i][k] = (V_ref[k] - V[k])*phi_ps[i][k];

        if (paw_debug())
        {
            sprintf(output, "%s%s_%d%d", paw_sdir(),"p",prin_n[i],orb_l[i]);
            fp = fopen(output, "w+");
            for (k = 0; k < Ngrid; ++k)
            {
                fprintf(fp, "%le\t  %le\t %le \n", rgrid[k], prj_ps[i][k],(V_ref[k] - V[k]));
            }
            fclose(fp);
        }


    }

    /*check for accidental null projectors*/
    for (i = 0; i < nbasis; ++i)
    {

        max_prj = 0.0;

        for (k = 0; k < Ngrid; ++k)
        {
            tmp_prj = fabs(prj_ps[i][k]);
            if (tmp_prj > max_prj)
                max_prj = tmp_prj;
        }

        if (max_prj <0.000001)
        {
            printf("found null projectors, aborting the program ... \n");
            exit(1);
        }
    }





    for (i=0;i<=nbasis-1;i++)
    {
        for (j=0;j<=nbasis-1;j++)
        {
            if (orb_l[i] == orb_l[j] )
            {
                b[i][j] = paw_dot_product(phi_ps[j],prj_ps[i]);

            }
            else
            {
                b[i][j] = 0.0;
            }



        }
    }

    paw_get_inverse(b,nbasis);

    for (i=0;i<=nbasis-1;i++)
    {
        for (k = 0; k <= Ngrid-1; k++)
            prj_ps0[i][k] = prj_ps[i][k];
    }

    for (i=0;i<=nbasis-1;i++)
    {
        paw_Zero_LogGrid(prj_ps[i]);
    }

    for (i=0;i<=nbasis-1;i++)
    {
        for (j=0;j<=nbasis-1;j++)
        {

            for (k = 0; k <= Ngrid-1; k++)
                prj_ps[i][k] = prj_ps[i][k] + b[i][j]*prj_ps0[j][k];

        }

    }

    for (i=0;i<=nbasis-1;i++)
    {

        norm = paw_dot_product(prj_ps[i],phi_ps[i]);
        if (fabs(norm) < SMALL)
        {
            printf("division by zero while normalizing prj_pss");
            exit(99);
        }

        if (paw_debug()) printf("prj_ps norm=%le\n",norm);

        for (k = 0; k < Ngrid; ++k)
            prj_ps[i][k] = prj_ps[i][k]/norm;

    }

    /*rescale basis*/
    for (i = 0; i <= nbasis-1; i++)
    {

        max_prj = 0.0;
        max_phi = 0.0;
        max_phi_ps = 0.0;

        for (k = 0; k < i_r_orbital[i]; k++)
        {
            if (max_prj < fabs(prj_ps[i][k]))
                max_prj =  fabs(prj_ps[i][k]);

            if (max_phi_ps < fabs(phi_ps[i][k]))
                max_phi_ps =  fabs(phi_ps[i][k]);

        }

        if (max_prj == 0.0 || max_phi_ps == 0.0)
        {
            printf("division by zero while rescaling basis\n");
            exit(99);
        }

        norm = 0.75*sqrt(max_phi_ps/max_prj);

        max_prj = 0.0;
        max_phi = 0.0;
        max_phi_ps = 0.0;

        for (k = 0; k < Ngrid; ++k)
        {
            prj_ps[i][k]       = prj_ps[i][k]*norm;
            phi[i][k]          = phi[i][k]/norm;
            phi_ps[i][k]       = phi_ps[i][k]/norm;
            phi_prime[i][k]    = phi_prime[i][k]/norm;
            phi_ps_prime[i][k] = phi_ps_prime[i][k]/norm;

        }

    }



}
Пример #15
0
/****************************************
 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);

}
Пример #16
0
/****************************************
 Function name	  : paw_solve_pseudo_orbitals
 Description	    :
 Return type		  : void
 Author     		  : Marat Valiev
 Date & Time		  : 5/15/00
****************************************/
void paw_scattering_test(double e1,double e2,int number_points ,int l, double r )
{

    int i;
    int k;
    int i_end_point;
    int Ngrid;
    double *rgrid;
    FILE   *fp;
    double *V_ks;


    double *psi1;
    double *psi1_prime;

    double *psi;
    double *psi_prime;

    double *log_grid_ae;
    double *log_grid_paw;

    double de;
    double* e3;
    double e_test;
    double log_amesh;

    /*char output[30];*/
    char data_filename[300];
    char script_filename[300];

    Ngrid = paw_N_LogGrid();
    rgrid = paw_r_LogGrid();
    log_amesh = paw_log_amesh_LogGrid();

    psi1       = paw_alloc_LogGrid();
    psi1_prime = paw_alloc_LogGrid();

    psi       = paw_alloc_LogGrid();
    psi_prime = paw_alloc_LogGrid();

    log_grid_ae = paw_alloc_1d_array(number_points);
    log_grid_paw = paw_alloc_1d_array(number_points);
    e3 = paw_alloc_1d_array(number_points);

    de = (e2-e1)/number_points;
    V_ks = paw_get_kohn_sham_potential();

    i_end_point = paw_get_grid_index(r);

    for (i=0;i<= number_points-1;i++)
    {
        e_test = e1+de*i;
        e3[i] = e_test;


        paw_solve_paw_scattering(l, r, e_test, psi,psi_prime);

        paw_R_Schrodinger_Fixed_E(
            l,
            V_ks,
            i_end_point,
            e_test,
            psi1,
            psi1_prime
        );




        log_grid_ae[i] =  psi1_prime[i_end_point-1]/(psi1[i_end_point-1]*rgrid[i_end_point-1]*log_amesh);
        log_grid_paw[i]  =  psi_prime[i_end_point-1]/(psi[i_end_point-1]*rgrid[i_end_point-1]*log_amesh);

    }

    if (paw_debug())
    {
        sprintf(data_filename,"%s%s_%s_scat_test.dat", paw_sdir(),paw_get_atom_name(),paw_spd_Name(l));
        fp = fopen(data_filename,"w+");

        for (k=0; k<=number_points-1; k++)
        {
            fprintf(fp,"%le\t%le\t%le\n", e3[k],log_grid_ae[k],log_grid_paw[k]);

        }
        fclose(fp);

        sprintf(script_filename,"%s%s_%s_scat_test.plt", paw_sdir(),paw_get_atom_name(),paw_spd_Name(l));
        printf("script_filename: %s\n",script_filename);
        fp = fopen(script_filename,"w+");

        fprintf(fp,"set style data lines \n");
        fprintf(fp,"set nolabel \n");
        fprintf(fp,"set autoscale \n");
        fprintf(fp,"set xr[%f:%f] \n",e1,e2);
        fprintf(fp,"set grid \n");
        fprintf(fp,"set nolabel \n");

        fprintf(fp,"set xlabel \"e (Hartree)\" \n");
        fprintf(fp,"set ylabel \"logarithmic derivative at r=%f\" \n",r);
        fprintf(fp,"set title \" %s %s channel scattering test\n",paw_get_atom_name(),paw_spd_Name(l));

        fprintf(fp,"plot \"%s\" using 1:2 title \"all electron\",",data_filename);
        fprintf(fp,"\"\" using 1:3 title \"paw\" \n");

        fprintf(fp,"\n");
        fprintf(fp,"pause -1\n");
        fclose(fp);
    }


}
Пример #17
0
/****************************************
 Function name	  : paw_print_basis_to_file
 Description	    :
 Return type		  : void
 Author     		  : Marat Valiev
 Date & Time		  : 3/31/99 3:01:57 PM
****************************************/
void paw_print_basis_test_to_file(char* atom_name)
{
    int i;
    int j;
    int k;
    int Ngrid;
    double *rgrid;
    char data_filename[300];
    char script_filename[300];
    char nl_name[20];
    char title[20];
    FILE *fp;

    Ngrid = paw_N_LogGrid();
    rgrid = paw_r_LogGrid();

    if (paw_debug())
    {
        sprintf(data_filename,"%s%s_test.dat",paw_sdir(),atom_name);
        printf("data_filename: %s\n",data_filename);
        fp = fopen(data_filename,"w+");

        for (k=0; k<=Ngrid-1; k++)
        {
            fprintf(fp,"%le", rgrid[k]);

            for (i=0; i<=nbasis-1; i++)
                fprintf(fp,"\t%le \t%le",phi_ps0[i][k],psi_ps[i][k]);



            fprintf(fp,"\n");

        }

        fclose(fp);


        /*gnu script file */
        for (i=0,j=2; i<=nbasis-1; i++,j=j+2)
        {

            sprintf(nl_name,"%d%s",prin_n[i],paw_spd_Name(orb_l[i]));

            sprintf(script_filename,"%s%s_%s_test.plt",paw_sdir(),atom_name,nl_name);

            printf("script_filename: %s \n",script_filename);
            fp = fopen(script_filename,"w+");

            fprintf(fp,"set style data lines \n");
            fprintf(fp,"set nolabel \n");
            fprintf(fp,"set autoscale \n");
            fprintf(fp,"set xr[0:%f] \n",1.5*r_orbital[i]);
            fprintf(fp,"set grid \n");
            fprintf(fp,"set key \n");
            fprintf(fp,"set nolabel \n");

            fprintf(fp,"set xlabel \"r (a0)\" \n");
            fprintf(fp,"set title \" %s paw_basis test for %s\\n (e=%f Hartree)\" \n",
                    nl_name,atom_name,e_ps[i]);

            sprintf(title,"%s (%f)",nl_name,e_ps[i]);

            fprintf(fp,"plot \"%s\" using 1:%d title \" original pseudo orbital \" ,  ",data_filename,j);
            fprintf(fp,"\"%s\" using 1:%d title \" solution of PAW Hamiltonian \"  with points\n",data_filename,j+1);

            fprintf(fp,"\n");
            fprintf(fp,"pause -1\n");
            fclose(fp);

        }
    }
}
Пример #18
0
/****************************************
 Function name	  : paw_print_basis_to_file
 Description	    :
 Return type		  : void
 Author     		  : Marat Valiev
 Date & Time		  : 3/31/99 3:01:57 PM
****************************************/
void paw_print_basis_to_file(char* atom_name)
{
    int i;
    int j;
    int k;
    int Ngrid;
    double *rgrid;
    char data_filename[300];
    char script_filename[300];
    char nl_name[20];
    char title[20];
    FILE *fp;

    Ngrid = paw_N_LogGrid();
    rgrid = paw_r_LogGrid();

    if (paw_debug())
    {
        sprintf(data_filename,"%s%s_paw.dat",paw_sdir(),atom_name);
        fp = fopen(data_filename,"w+");

        for (k=0; k<=Ngrid-1; k++)
        {
            fprintf(fp,"%le", rgrid[k]);

            for (i=0; i<=nbasis-1; i++)
                fprintf(fp,"\t%le \t%le \t%le ",phi[i][k],phi_ps[i][k],prj_ps[i][k]);

            fprintf(fp,"\n");
        }
        fclose(fp);


        /* individual orbitals gnu script file */
        for (i=0,j=2; i<=nbasis-1; i++,j=j+3)
        {

            sprintf(nl_name,"%d%s",prin_n[i],paw_spd_Name(orb_l[i]));
            sprintf(script_filename,"%s%s_%s_paw.plt",paw_sdir(),atom_name,nl_name);
            fp = fopen(script_filename,"w+");

            fprintf(fp,"set style data lines \n");
            fprintf(fp,"set nolabel \n");
            fprintf(fp,"set autoscale \n");
            fprintf(fp,"set xr[0:%f] \n",1.5*r_orbital[i]);
            fprintf(fp,"set grid \n");
            fprintf(fp,"set key \n");
            fprintf(fp,"set nolabel \n");

            fprintf(fp,"set xlabel \"r (a0)\" \n");
            fprintf(fp,"set title \" %s paw_basis for %s\\n (e=%f Hartree)\" \n",
                    nl_name,atom_name,e_ps[i]);

            sprintf(title,"%s (%f)",nl_name,e_ps[i]);

            fprintf(fp,"plot \"%s\" using 1:%d title \" all-electron orbital \" ,  ",data_filename,j);
            fprintf(fp,"\"%s\" using 1:%d title \" pseudo orbital \" ,  ",data_filename,j+1);
            fprintf(fp,"\"%s\" using 1:%d title \" projector \" \n",data_filename,j+2);

            fprintf(fp,"\n");
            fprintf(fp,"pause -1\n");
            fclose(fp);

        }
    }
}
Пример #19
0
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 */
Пример #20
0
/****************************************
 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);

}
Пример #21
0
/****************************************
 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);

}
Пример #22
0
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 */
Пример #23
0
/****************************************
 Function name	  : paw_solve_unoccupied_orbitals
 Description	    :
 Return type		  : void
 Author     		  : Marat Valiev
 Date & Time		  : 4/10/99 6:13:39 PM
****************************************/
void paw_solve_unoccupied_orbitals()
{
    int i;
    int j;
    int k;
    int state;
    int Ngrid;
    int status;
    double sum;
    double *V;
    double *rgrid;
    double Zion;


    Ngrid = paw_N_LogGrid();
    rgrid = paw_r_LogGrid();
    Zion = paw_get_ion_charge();

    /*check if the occupied orbitals are done*/
    if (!(occupied_orbitals_done))
    {
        printf("cannot calculate unoccupied states\n");
        printf("calculate occupied states first\n");
    }

    /*get Kohn-Sham potential*/
    V = paw_get_kohn_sham_potential();

    for (i=Nvalence; i<= Nbound-1; i++)
    {

        state=paw_bound_state_test(l[i],V);
        if (state==0)
        {
            printf("This potential has no bound states with n=%d l=%d\n",n[i],l[i]);
            printf("please change your input file\n");
            exit(1);
        }
        else
        {
            if (Solver_Type==Schrodinger)
            {
               status = paw_R_Schrodinger(n[i],l[i],V,
                                          &eigenvalue[i],psi[i],psi_prime[i]);
            }
            else
            {
               status = paw_R_Pauli(n[i],l[i],Zion,V,
                                          &eigenvalue[i],psi[i],psi_prime[i]);
            }

        }

        if (!(status))
        {
            printf("This potential has no bound states with n=%d l=%d\n",n[i],l[i]);
            printf("please change your input file\n");
            exit(1);
        }


        /*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-1;k++)
                    psi[i][k] = psi[i][k] - sum*psi[j][k];
            }

        }

        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);
    }


}
Пример #24
0
/****************************************
 Function name	  : paw_save_orbitals_to_file
 Description	    :
 Return type		  : void
 Author     		  : Marat Valiev
 Date & Time		  : 3/31/99 3:01:57 PM
****************************************/
void paw_print_orbitals_to_file(char* atom_name)
{
    int i;
    int k;
    int Ngrid;
    double *rgrid;
    char data_filename[300];
    char script_filename[300];
    char nl_name[20];
    char title[20];
    FILE *fp;

    Ngrid = paw_N_LogGrid();
    rgrid = paw_r_LogGrid();

    if (paw_debug())
    {
        sprintf(data_filename,"%s%s_orb.dat",paw_sdir(),atom_name);
        fp = fopen(data_filename,"w+");


        for (k=0; k<=Ngrid-1; k++)
        {
            fprintf(fp,"%le", rgrid[k]);

            for (i=0; i<=Ntotal-1; i++)
            {

                fprintf(fp,"\t%le",psi[i][k]);

            }
            fprintf(fp,"\n");
        }
        fclose(fp);

        /* all orbitals gnu script file */
        sprintf(script_filename,"%s%s_all_orb.plt",paw_sdir(),atom_name);

        fp = fopen(script_filename,"w+");

        fprintf(fp,
                "set title \" Kohn-Sham bound states for %s \" \n",
                atom_name);

        fprintf(fp,"set nolabel \n");

        fprintf(fp,"set key right top box\n");

        fprintf(fp,"set grid \n");

        fprintf(fp,"set xlabel \"r (a0)\" \n");

        fprintf(fp,"set style data lines \n");

        fprintf(fp,"set autoscale \n");

        fprintf(fp,"set xr[0:5] \n");

        i=0;
        sprintf(nl_name,"%d%s",n[i],paw_spd_Name(l[i]));
        sprintf(title,"%s (%f)",nl_name,eigenvalue[i]);
        fprintf(fp,"plot \"%s\" using 1:2  title \"%s\"  ",data_filename,title);

        for (i=1; i<=Nbound-1; i++)
        {

            sprintf(nl_name,"%d%s",n[i],paw_spd_Name(l[i]));

            sprintf(title,"%s (%f)",nl_name,eigenvalue[i]);


            fprintf(fp,",\"\" using 1:%d   title \"%s\"  ",i+2,title);

        }

        fprintf(fp,"\n");
        fprintf(fp,"pause -1\n");

        fclose(fp);

        /* individual orbitals gnu script file */
        for (i=0; i<=Ntotal-1; i++)
        {
            sprintf(nl_name,"%d%s",n[i],paw_spd_Name(l[i]));

            sprintf(script_filename,"%s%s_%s_orb.plt",paw_sdir(),atom_name,nl_name);

            fp = fopen(script_filename,"w+");

            fprintf(fp,"set style data lines \n");

            fprintf(fp,"set nolabel \n");

            fprintf(fp,"set autoscale \n");

            fprintf(fp,"set xr[0:%d] \n",n[i]+l[i]);

            fprintf(fp,"set xlabel \"r (a0)\" \n");

            fprintf(fp,"set grid \n");

            fprintf(fp,"set nokey \n");

            fprintf(fp,"set title \" %s orbital for %s\\n (e=%f Hartree)\" \n",
                    nl_name,atom_name,eigenvalue[i]);

            sprintf(title,"%s (%f)",nl_name,eigenvalue[i]);

            fprintf(fp,"plot \"%s\" using 1:%d   title \"%s\"  ",data_filename,i+2,title);


            fprintf(fp,"\n");
            fprintf(fp,"pause -1\n");
            fclose(fp);

        }
    }
}
Пример #25
0
/****************************************
 Function name    : paw_init_paw_potential
 Description        :
 Return type              : void
 Argument         : int a_nbasis
 Argument         : double a_r_sphere
 Author                   : Marat Valiev
 Date & Time              : 4/11/99 4:11:34 PM
****************************************/
void paw_init_paw_potential(int a_nbasis,
                            double c0,
                            double a_r_ref,
                            double* a_r_potential,
                            double* V_ks)
{

    int   i;
    int   k;
    int    Ngrid;
    int ic;
    double rc;
    double a,d,b;
    double V_prime;
    double *rgrid;

    Ngrid = paw_N_LogGrid();
    rgrid = paw_r_LogGrid();

    nbasis      = a_nbasis;

    r_ref  = a_r_ref;
    rc_ref = paw_find_rc_pot(r_ref);

    i_r_potential = (int *) malloc(nbasis * sizeof(int));
    r_potential   = (double *) malloc(nbasis * sizeof(double));
    rc_pot        = (double *) malloc(nbasis * sizeof(double));
    c             = (double *) malloc(nbasis * sizeof(double));
    fcut          = (double **) malloc(nbasis * sizeof(double *));
    V_pseudo      = paw_alloc_LogGrid();
    V_ref         = paw_alloc_LogGrid();
    V_paw         = (double **) malloc(nbasis * sizeof(double *));

    for (i = 0; i <= nbasis-1; ++i)
    {
        V_paw[i]  = paw_alloc_LogGrid();
        fcut[i]  = paw_alloc_LogGrid();
    }

    for (i=0; i <= nbasis-1;i++)
    {
        i_r_potential[i] = paw_get_grid_index(a_r_potential[i]);
        /*r_potential[i]   = rgrid[i_r_potential[i]];*/
        r_potential[i] = a_r_potential[i];
        rc_pot[i] = paw_find_rc_pot(r_potential[i]);
    }


    /* set ref potential
    for (k = 0; k <= Ngrid-1; ++k)
      V_ref[k] = V_ks[k]*(1 - exp(-pow((rgrid[k]/rc_ref),lambda)))+
                 c0*exp(-pow((rgrid[k]/rc_ref),lambda));

    */

    ic = paw_get_grid_index(a_r_ref);
    rc = rgrid[ic];

    V_prime = 0.5*(V_ks[ic+1] - V_ks[ic-1])/(rc*paw_log_amesh_LogGrid());


    a = c0;

    d = (0.5*V_prime*rc + a - V_ks[ic])/(rc*rc*rc*rc);

    b = (0.5*V_prime*rc - 2.0*d*rc*rc*rc*rc)/(rc*rc);

    for (k=0;k<ic;++k)
        V_ref[k] = a + b*rgrid[k]*rgrid[k] + d*rgrid[k]*rgrid[k]*rgrid[k]*rgrid[k];

    for (k=ic;k<Ngrid;++k)
        V_ref[k] = V_ks[k];

    /* Form cutoff function  for PS potential*/
    for (i = 0; i <= nbasis-1; i++)
        for (k = 0; k <= Ngrid-1; k++)
            fcut[i][k] = exp(-pow((rgrid[k]/rc_pot[i]),lambda));

    /*Initialize coefficients for the construction of PS potential*/
    for (i=0; i<nbasis; ++i)
        c[i] = V_ks[i_r_potential[i]];
    /*
      for (i = 0; i < nbasis; ++i)
        c[i] = V_ks[paw_get_grid_index(r_potential[i])];
    */


    /* set initial paw potential*/
    for (i = 0; i < nbasis; ++i)
        for (k = 0; k <= Ngrid-1; k++)
            V_paw[i][k] = V_ref[k] + c[i] * fcut[i][k];

}
Пример #26
0
void paw_generate_basis_file(char *outfile)
{
    char*   atom_name;
    FILE    *fp;
    int     i;
    int     k;
    double tmp;
    double *Vpseudo;
    double *rho_core;
    double *rho_core_ps;

    int nbasis;
    int Ngrid;
    double *rgrid;
    int* prin_n;
    int* prin_n_ps;
    int *l;
    double* e;
    double** psi;
    double** psi_ps0;
    double** psi_prime;
    double** psi_ps;
    double** psi_ps_prime;
    double** prj_ps;
    double** prj_ps0;

    Ngrid = paw_N_LogGrid();
    rgrid = paw_r_LogGrid();

    atom_name = paw_get_atom_name();
    nbasis    = paw_get_nbasis();


    prin_n    = paw_get_pointer_paw_n_array();
    prin_n_ps = paw_get_pointer_paw_n_ps_array();
    l         = paw_get_pointer_paw_l_array();
    e         = paw_get_pointer_paw_e_array();

    psi          = paw_get_pointer_paw_psi_array();
    psi_ps       = paw_get_pointer_paw_psi_ps_array();
    psi_prime    = paw_get_pointer_paw_psi_prime_array();
    psi_ps_prime = paw_get_pointer_paw_psi_ps_prime_array();
    prj_ps       = paw_get_pointer_paw_prj_ps_array();
    prj_ps0       = paw_get_pointer_paw_prj_ps0_array();

    rho_core    = paw_get_pointer_core_density();
    rho_core_ps = paw_get_pointer_ps_core_density();

    Vpseudo = paw_get_pointer_pseudopotential();

    psi_ps0 =  paw_get_pointer_paw_psi_ps_unscr_array();

    /* output the basis file */
    /*sprintf(output, "%s_basis", atom_name);*/
    if (paw_debug()) printf("paw basis file generated: %s\n",outfile);
    fp = fopen(outfile, "w+");

    fprintf(fp,"4\n"); /*dummy tag*/    /* new*/
    fprintf(fp,"%s\n",atom_name);    /* new*/
    fprintf(fp,"%lf\n",paw_get_Zvalence());    /* new*/
    fprintf(fp,"%15.11e\n",rgrid[0]);

    fprintf(fp,"%15.11e\n",rgrid[Ngrid-1]);

    fprintf(fp,"%d\n",Ngrid);

    fprintf(fp,"%d\n",nbasis);

    /* printout cutoff radii */    /* new*/
    for (i=0; i<nbasis; ++i) fprintf(fp,"%le ",paw_get_r_orbital(i));    /* new*/
    fprintf(fp,"\n");    /* new*/

    fprintf(fp,"%d\n",paw_get_max_i_r_orbital());
    fprintf(fp,"%s\n",paw_get_comment());    /* new*/

    fprintf(fp,"%15.11e\n",paw_get_core_kinetic_energy());

    for ( i = 0; i < nbasis; ++i)
        fprintf(fp, "%d\t %15.11e\t %d\t %d\n",prin_n[i],e[i],prin_n_ps[i],l[i]);

    for ( i = 0; i <= nbasis-1; i++)
    {
        for (k = 0; k <= Ngrid-1; k++)
            fprintf(fp, "%15.11e \n",psi[i][k]);
    }


    for ( i = 0; i <= nbasis-1; i++)
    {
        for (k = 0; k <= Ngrid-1; k++)
        {
            tmp = psi_prime[i][k]/(rgrid[k]*paw_log_amesh_LogGrid());
            fprintf(fp, "%15.11e \n",psi_prime[i][k]/(rgrid[k]*paw_log_amesh_LogGrid()));
        }
    }


    for ( i = 0; i <= nbasis-1; i++)
    {
        for (k = 0; k <= Ngrid-1; k++)
            fprintf(fp, "%15.11e \n",psi_ps[i][k]);
    }


    for ( i = 0; i <= nbasis-1; i++)
    {
        for (k = 0; k <= Ngrid-1; k++)
        {
            tmp = psi_ps_prime[i][k]/(rgrid[k]*paw_log_amesh_LogGrid());
            fprintf(fp, "%15.11e \n",psi_ps_prime[i][k]/(rgrid[k]*paw_log_amesh_LogGrid()));
        }
    }


    for ( i = 0; i <= nbasis-1; i++)
    {
        for (k = 0; k <= Ngrid-1; k++)
            fprintf(fp, "%15.11e \n",prj_ps[i][k]);
    }

    for (k = 0; k <= Ngrid-1; k++)
    {
        fprintf(fp, "%15.11e \n",rho_core[k]/(4.0*PI));
    }


    for (k = 0; k <= Ngrid-1; k++)
    {
        fprintf(fp, "%15.11e \n",rho_core_ps[k]/(4.0*PI));
    }


    for (k = 0; k <= Ngrid-1; k++)
    {
        fprintf(fp, "%15.11e \n",Vpseudo[k]);
    }


    fprintf(fp,"%15.11e\n",paw_get_sigma_comp());

    fprintf(fp,"%15.11e\n",paw_get_ion_charge());


    for ( i = 0; i <= nbasis-1; i++)
    {
        for (k = 0; k <= Ngrid-1; k++)
            fprintf(fp, "%15.11e \n",prj_ps0[i][k]);
    }

    fclose(fp);

}
Пример #27
0
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 */
Пример #28
0
/****************************************
 Function name	  : paw_solve_scattering_orbitals
 Description	    :
 Return type		  : void
 Author     		  : Marat Valiev
 Date & Time		  : 4/10/99 4:58:27 PM
****************************************/
void paw_solve_scattering_orbitals()
{
    int i;
    int j;
    int k;
    int i_match;
    int Ngrid;
    double sum;
    double *V;
    double *rgrid;
    double r_sphere;
    double Zion;

    Ngrid = paw_N_LogGrid();
    rgrid = paw_r_LogGrid();
    Zion = paw_get_ion_charge();

    /*normalization sphere radius*/
    r_sphere = 2.0;

    /*check if the occupied orbitals are done*/
    if (!(occupied_orbitals_done))
    {
        printf("cannot calculate scattering orbitals\n");
        printf("calculate occupied states first\n");
    }


    /*get Kohn-Sham potential*/
    V = paw_get_kohn_sham_potential();


    for (i=Nbound;i<Ntotal;i++)
    {

        /*set the end point*/
        i_match = Ngrid-1;

        if (Solver_Type==Schrodinger)
        {
           paw_R_Schrodinger_Fixed_E(l[i],V,i_match,eigenvalue[i],psi[i],psi_prime[i]);
        }
        else
        {
           paw_R_Pauli_Fixed_E(n[i],l[i],Zion,V,i_match,eigenvalue[i],psi[i],psi_prime[i]);
        }

        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*/
        sum = paw_dot_product1(paw_get_grid_index(r_sphere),psi[i],psi[i]);
        sum = 1.0/sqrt(sum);

        for (k=0;k<Ngrid;++k)
        {
            psi[i][k] = psi[i][k]*sum;
            psi_prime[i][k] = psi_prime[i][k]*sum;

        }


    }

    /*debug
    printf("orthogonality\n");
    for(i=0;i<=Ntotal-1;i++)
    {
        for(j=0;j<=Ntotal-1;j++)
        {
          if(l[i]==l[j])
          {
            printf("%d\t %d\t %f\n",i,j, paw_dot_product(psi[i],psi[j]));
          }
      
        }  
     }
        exit(1);
    end debug  */
}
Пример #29
0
void paw_print_paw_potential_to_file(char* atom_name)
{
    int i;
    int j;
    int k;
    int Ngrid;
    int *prin_n;
    int * orb_l;
    double *rgrid;
    char data_filename[300];
    char script_filename[300];
    char nl_name[20];
    FILE *fp;

    if (paw_debug())
    {
        Ngrid = paw_N_LogGrid();
        rgrid = paw_r_LogGrid();

        prin_n = paw_get_pointer_paw_n_array();
        orb_l  = paw_get_pointer_paw_l_array();

        sprintf(data_filename,"%s%s_pot.dat",paw_sdir(),atom_name);
        fp = fopen(data_filename,"w+");

        for (k=0; k<=Ngrid-1; k++)
        {
            fprintf(fp,"%le\t%le\t%le", rgrid[k], V_ref[k], V_pseudo[k]);

            for (i=0; i<=nbasis-1; i++)
                fprintf(fp,"\t%le ",V_paw[i][k]);



            fprintf(fp,"\n");

        }

        fclose(fp);

        sprintf(script_filename,"%s%s_ref_pot.plt",paw_sdir(),atom_name);

        fp = fopen(script_filename,"w+");

        fprintf(fp,"set data style lines \n");
        fprintf(fp,"set nolabel \n");
        fprintf(fp,"set autoscale \n");
        fprintf(fp,"set xr[0:%f] \n",2*r_ref);
        fprintf(fp,"set grid \n");
        fprintf(fp,"set nokey \n");
        fprintf(fp,"set nolabel \n");

        fprintf(fp,"set xlabel \"r (a0)\" \n");
        fprintf(fp,"set title \" %s reference potential\n",atom_name);

        fprintf(fp,"plot \"%s\" using 1:2 \n",data_filename);

        fprintf(fp,"\n");
        fprintf(fp,"pause -1\n");
        fclose(fp);


        sprintf(script_filename,"%s%s_loc_pot.plt",paw_sdir(),atom_name);

        fp = fopen(script_filename,"w+");

        fprintf(fp,"set data style lines \n");
        fprintf(fp,"set nolabel \n");
        fprintf(fp,"set autoscale \n");
        fprintf(fp,"set xr[0:%f] \n",2*r_ref);
        fprintf(fp,"set grid \n");
        fprintf(fp,"set nokey \n");
        fprintf(fp,"set nolabel \n");

        fprintf(fp,"set xlabel \"r (a0)\" \n");
        fprintf(fp,"set title \" %s local potential\n",atom_name);

        fprintf(fp,"plot \"%s\" using 1:3 \n",data_filename);

        fprintf(fp,"\n");
        fprintf(fp,"pause -1\n");
        fclose(fp);


        /*gnu script file */
        for (i=0,j=4; i<=nbasis-1; i++,j=j+1)
        {

            sprintf(nl_name,"%d%s",prin_n[i],paw_spd_Name(orb_l[i]));

            sprintf(script_filename,"%s%s_%s_pot.plt",paw_sdir(),atom_name,nl_name);

            fp = fopen(script_filename,"w+");

            fprintf(fp,"set data style lines \n");
            fprintf(fp,"set nolabel \n");
            fprintf(fp,"set autoscale \n");
            fprintf(fp,"set xr[0:%f] \n",1.5*r_potential[i]);
            fprintf(fp,"set grid \n");
            fprintf(fp,"set nokey \n");
            fprintf(fp,"set nolabel \n");

            fprintf(fp,"set xlabel \"r (a0)\" \n");
            fprintf(fp,"set title \" %s paw potential for %s orbital\" \n",
                    atom_name,nl_name);

            fprintf(fp,"plot \"%s\" using 1:%d \n",data_filename,j);

            fprintf(fp,"\n");
            fprintf(fp,"pause -1\n");
            fclose(fp);

        }
    }
}
Пример #30
0
/****************************************
 Function name	  : paw_init_paw_orbitals
 Description	    :
 Return type		  : void
 Argument         : int a_nbasis
 Argument         : double *a_rc_orb
 Argument         : int *a_n
 Argument         : int *a_n_ps
 Argument         : int *a_l
 Argument         : int *a_s_z
 Argument         : double *a_e
 Argument         : double *a_fill

 Author     		  : Marat Valiev
 Date & Time		  : 4/4/99 5:11:29 PM
****************************************/
void paw_init_paw_basis(
    char* a_nodal_constraint,
    char* a_projector_method,
    int a_nbasis,
    int *a_n,
    int *a_l,
    double *r_match
)
{

    int i;
    int k;
    int i_match;
    int Ngrid;
    int index;
    double *rgrid;
    double *psi;
    double *psi_prime;


    Ngrid = paw_N_LogGrid();
    rgrid = paw_r_LogGrid();

    strcpy(nodal_constraint,a_nodal_constraint);
    strcpy(projector_method,a_projector_method);

    nbasis = a_nbasis;
    /*  prin_n = a_n; */
    /*  orb_l  = a_l; */
    /* r_orbital = r_match; */



    /*maximum angular momentum in the basis*/
    max_orb_l = 0;
    for (i=0;i<=nbasis-1;i++)
    {
        if (max_orb_l < a_l[i])
            max_orb_l = a_l[i];
    }

    delta_ekin  = (int *) malloc( nbasis*      sizeof(int));

    orb_type    = (int *)    malloc( nbasis*      sizeof(int));
    prin_n_ps   = (int *)    malloc( nbasis*      sizeof(int));
    prin_n      = (int *)    malloc( nbasis*      sizeof(int));
    orb_l       = (int *)    malloc( nbasis*      sizeof(int));
    l_counter   = (int *)    malloc((max_orb_l+1)*sizeof(int));
    i_r_orbital = (int *)    malloc( nbasis*      sizeof(int));
    r_orbital   = (double *) malloc( nbasis*      sizeof(double));
    fill        = (double *) malloc( nbasis*      sizeof(double));
    e           = (double *) malloc( nbasis*      sizeof(double));
    e_ps        = (double *) malloc( nbasis*      sizeof(double));
    log_deriv   = (double *) malloc( nbasis*      sizeof(double));

    rho         = paw_alloc_LogGrid();
    rho_ps      = paw_alloc_LogGrid();


    phi          = (double **) malloc(nbasis * sizeof(double *));
    phi0         = (double **) malloc(nbasis * sizeof(double *));
    phi_prime    = (double **) malloc(nbasis * sizeof(double *));
    phi_ps0      = (double **) malloc(nbasis * sizeof(double *));
    phi_ps0_prime= (double **) malloc(nbasis * sizeof(double *));
    phi0_prime   = (double **) malloc(nbasis * sizeof(double *));
    phi_ps       = (double **) malloc(nbasis * sizeof(double *));
    phi_ps_prime = (double **) malloc(nbasis * sizeof(double *));
    prj_ps       = (double **) malloc(nbasis * sizeof(double *));
    prj_ps0      = (double **) malloc(nbasis * sizeof(double *));

    psi_ps       = (double **) malloc(nbasis * sizeof(double *));
    psi_ps_prime = (double **) malloc(nbasis * sizeof(double *));

    for (i = 0; i < nbasis; ++i)
    {
        prin_n[i] = a_n[i];
        orb_l[i]  = a_l[i];

        phi0[i]         = paw_alloc_LogGrid();
        phi[i]          = paw_alloc_LogGrid();
        phi_prime[i]    = paw_alloc_LogGrid();

        phi_ps0[i]      = paw_alloc_LogGrid();
        phi_ps[i]       = paw_alloc_LogGrid();
        phi_ps_prime[i] = paw_alloc_LogGrid();

        phi_ps0_prime[i] = paw_alloc_LogGrid();

        phi0_prime[i] = paw_alloc_LogGrid();

        prj_ps[i]       = paw_alloc_LogGrid();
        prj_ps0[i]      = paw_alloc_LogGrid();

        psi_ps[i]          = paw_alloc_LogGrid();
        psi_ps_prime[i] = paw_alloc_LogGrid();

    }


    Zvalence = 0.0;
    for (i=0;i<=nbasis-1;i++)
    {
        index = paw_get_orbital_index(prin_n[i],orb_l[i]);

        fill[i]      = paw_get_fill(index);
        Zvalence    += fill[i];
        e[i]         = paw_get_e(index);
        e_ps[i]      = e[i];
        orb_type[i]  = paw_get_orb_type(index);

        psi = paw_get_psi(index);
        for (k=0;k<=Ngrid-1;k++)
            phi[i][k] = psi[k];

        psi_prime = paw_get_psi_prime(index);
        for (k=0;k<=Ngrid-1;k++)
            phi_prime[i][k] = psi_prime[k];

    }


    /* set matching point for pseudoorbitals*/
    for (i=0;i<=nbasis-1;i++)
    {
        i_r_orbital[i] = paw_get_grid_index(r_match[i]);
        /*r_orbital[i] = rgrid[i_r_orbital[i]];  */
        r_orbital[i]   = r_match[i];
    }

    /*largest sphere in the basis*/
    max_i_r_orbital = 0;
    for (i=0;i<=nbasis-1;i++)
    {
        if (max_i_r_orbital < i_r_orbital[i])
            max_i_r_orbital = i_r_orbital[i];
    }


    /*check if prin_n array is monotonically increasing*/
    for (i=0;i<=nbasis-2;i++)
    {
        if (prin_n[i]>prin_n[i+1])
            printf("please order your states according to increasing n");

    }

    /* counter for number of orbitals per angular momentum*/
    for (i=0;i<(max_orb_l+1);++i)
        l_counter[i] = 0;

    if (strcmp(nodal_constraint,"off")==0)
    {

        for (i=0;i<nbasis;++i)
        {

            prin_n_ps[i] = orb_l[i] + 1;

        }


    }
    else if (strcmp(nodal_constraint,"on")==0)
    {

        for (i=0;i<nbasis;++i)
        {

            prin_n_ps[i] = orb_l[i] + 1 + l_counter[orb_l[i]];
            l_counter[orb_l[i]] = l_counter[orb_l[i]]+1;

        }

    }
    else
    {

        printf("unknown value for the nodal_constraint\n");
        exit(1);

    }



    for (i = 0; i < nbasis; ++i)
    {
        i_match = i_r_orbital[i];

        if (fabs(phi[i][i_match]) < SMALL)
        {
            printf("error, your orbital matching sphere is to close to the node of %d%d orbital \n",
                   prin_n[i],orb_l[i]);
            exit(1);
        }
        else
        {
            log_deriv[i] = phi_prime[i][i_match]/phi[i][i_match];
        }

    }

    /*set all paw orbitals to scattering ***/
    for (i = 0; i < nbasis; ++i)
    {
        orb_type[i]=scattering;
    }

    scaling_factor = paw_alloc_1d_array(nbasis);
    tr_matrix      = paw_alloc_2d_array(nbasis,nbasis);

}