Solution LAB1 ecutwfc convergence

From Wiki Max
Jump to navigation Jump to search

Convergence of the total energy wrt the kinetic energy cutoff

We can start by modifying the script of the previous exercise in order to loop over different values of the ecutwfc variable. Note that either we do not specify ecutrho (exploiting the fact that the default value is 4*ecutwfc), or we set it explicitly with the correct value (as the default does).

 # set vars
 # Here we choose a reasonable value of nk.
 # Since the kinetic energy cutoff is a property of the pseudopotential (transferability)
 # this should have no (or very little) impact.
 ecutwfc_list="20 30 40 50 60 80 100 120 140 160 200" 
 # main loop
 for ecutwfc  in $ecutwfc_list ; do
     # here we have used the bash built-in arithmetics
     # alternatively one can use e.g. awk
     # ecutrho=`echo $ecutwfc | awk '{print $1*4}'`
     # generate the input file
     cat > $filein <<EOF
       [...]      # note here you can use shell variables
     $nk $nk $nk  0 0 0
     # running
     echo "Running $label"
     $para_prefix $bindir/pw.x $para_postfix < $filein > $fileout

We can then make the script executable (if not yet) and run the calculations. As you can see, the time-to-solution of each run depends quite strongly on the chosen kinetic energy cutoff. The following considerations can be made

  • for each DFT calculation, the time-to-solution (TTS) is roughly linearly proportional to the number of

used k-points.

  • When we use k-grids of the kind $nk $nk $nk 0 0 0 the total number of points is proportional

to $nk^3. k-points are then reduced according to symmetry. Still, the resulting number of points is proportional to the cube of the grid discretisation.

  • Concerning the kinetic energy cutoff: the number of G-vectors is proportional to the power 3/2 of the cutoff value.
  • Each scalar product of wfcs then scales linearly with the number N of G-vectors, while FFTs scale as N*logN .
  • At fixed number of bands and k-points, the overall scaling of the TTS wrt ecutwfc is therefore proportional to the power 3/2

(the refactor including some logN term).

  • This can be seen by plotting the TTS vs ecutwfc for the calculated data.

Data to be plotted can be extracted with a script similar to this:

 $>  cat
 output="#  ecut [Ry]   etot [Ry]   time [sec]"
 for file in $file_list
   ecutwfc=`grep "kinetic-energy cutoff" $file | awk '{print $(NF-1)}'`
   etot=`grep ! $file | awk '{print $(NF-1)}'`
   timing=`grep "PWSCF" $file | grep "WALL" | awk '{print $(NF-3)}' | sed 's/s//'`
   $ecutwfc  $etot   $timing"
 echo "$output" | sort -n

Here are the graphs showing the total energy as well as wall-time vs ecutwfc

Total Energy vs Kinetic energy cutoff Total Energy vs Kinetic energy cutoff (log scale)

Time-to-solution vs Kinetic energy cutoff (log scale)

In the total energy plot we see, especially in the one with log-scale, that requiring a convergence of 0.0001 Ry requires a kinetic energy cutoff in between 120-150 Ry (very large !!).

In the time to solution plot, in double log scale, we see that data are somehow fitted with a linear curve with slope 3/2 (-> power low with exponent 3/2).