Installing GPAW with conda

In short, in a clean environment, everything should work with just five lines:

wget https://repo.anaconda.com/miniconda/Miniconda3-py39_4.12.0-Linux-x86_64.sh
bash Miniconda3-py39_4.12.0-Linux-x86_64.sh

Initialize conda. If it is in the .bashch, source it. If not, source “PATHTOCONDA/miniconda3/etc/profile.d/conda.sh”.

conda create --name gpaw22 python=3.10
conda activate gpaw22
conda install -c conda-forge gpaw=*=*openmpi* openmpi=4.1.2 gcc=12.1.0 ucx

For details, see the description below.

1. Install conda – software and environment management system.

Here is the official instruction: docs.conda.io/projects/conda/en/latest/user-guide/install/linux.html

On July 2022, run these:

wget https://repo.anaconda.com/miniconda/Miniconda3-py39_4.12.0-Linux-x86_64.sh
bash Miniconda3-py39_4.12.0-Linux-x86_64.sh

If you wish to autostart conda, allow it to write to .bashrc.

P.S. Here are good intro to conda:

2. Create a conda virtual environment:

conda create --name gpaw22 python=3.10

If needed, remove the environment as:

conda remove --name gpaw22 --all

You can check the available environments as:

conda env list

3. Activate the virtual environment.

conda activate gpaw22

4. Install gpaw:

Ensure that no interfering modules and environments are loaded.

To purge modules, execute:

module purge

To check whether some code (like mpirun) has an alternative path, try:

which codename

There should be no mpirun, ase, libxc, numpy, scipy, etc. Otherwise, the installation with conda will most probably fail due to conflicting paths.

4.1. It is safer to install using gpaw22.yml file from vliv/conda directory on FEND:

conda env create -f gpaw22.yml

4.2. Pure installation is simple, but might not work:

conda install -c conda-forge gpaw=*=*openmpi*

Recently, there were problems with openmpi. Try downgrading it to version 4.1.2:

conda install -c conda-forge openmpi=4.1.2

To enable the Rose support, for example, on FEND v4 adn v5, install Ucx:

conda install -c conda-forge ucx

If you get an error about GLIBCXX, try upgrading gcc:

conda install -c conda-forge gcc=12.1.0

4.3. To make a quick check of the installation, run “gpaw -P 2 test” or “gpaw info”.

The installation might fail. In case you succeed, save the yml file as:

conda env export | grep -v "^prefix: " > gpaw22.yml

Now you can use it to install gpaw as:

conda env create -f gpaw22.yml

To properly test the installation install pytest and follow wiki.fysik.dtu.dk/gpaw/devel/testing.html. That might take hours.

conda install -c conda-forge pytest pytest-xdist 

5. If needed, install extra packages within your specific conda environment (gpaw22).

To apply D4 dispersion correction:

conda install -c conda-forge dftd4 dftd4-python

To analyze trajectories:

conda install -c conda-forge mdanalysis

To analyze electronic density (some might not work):

pip install git+https://github.com/funkymunkycool/Cube-Toolz.git
pip install git+https://github.com/theochem/grid.git
pip install git+https://github.com/theochem/denspart.git
pip install pybader
pip install cpmd-cube-tools
conda install -c conda-forge chargemol

To use catlearn:

pip install catlearn

6. Run calculations by adding these lines to the submission script:

Note1: Check the path and change the USERNAME

Note2: Use ucx and export variables.

Note3: You may play with the number of openmp threads.

module purge
source "/groups/kemi/USERNAME/miniconda3/etc/profile.d/conda.sh"
conda activate gpaw22
export OMP_NUM_THREADS=1
export OMPI_MCA_pml="^ucx"
export OMPI_MCA_osc="^ucx"
mpirun gpaw python script.py

7. Use scalapack for speeding-up your calculations.

Add the “parallel” keyword to GPAW calculator:

parallel = {'augment_grids':True,'sl_auto':True}

For more options see wiki.fysik.dtu.dk/gpaw/documentation/parallel_runs/parallel_runs.html#manual-parallel. For example, try ELPA  for LCAO mode. See wiki.fysik.dtu.dk/gpaw/documentation/lcao/lcao.html#notes-on-performance.

parallel = {'augment_grids':True,'sl_auto':True,'use_elpa':True}

8. If needed, add fixes.

To do Bayesian error estimation see doublelayer.eu/vilab/2022/03/30/bayesian-error-estimation-for-rpbe/.

To use MLMin/NEB apply corrections from github.com/SUNCAT-Center/CatLearn/pulls

9. Something worth trying:

gpaw-tools:

github.com/lrgresearch/gpaw-tools/

www.sciencedirect.com/science/article/pii/S0927025622000155

ase-notebook:

github.com/chrisjsewell/ase-notebook

ase-notebook.readthedocs.io/en/latest/

gpaw benchmarking:

github.com/OleHolmNielsen/GPAW-benchmark-2021

github.com/mlouhivu/gpaw-benchmarks

members.cecam.org/storage/presentation/Ask_Hjorth_Larsen-1622631504.pdf

Bayesian Error Estimation for RPBE

Here is a trick for making the Bayesian Error Estimation (BEE) with the RPBE functional. Just edit the lines in ASE and GPAW codes by adding RPBE as an exception.

To find the needed files, run

find ./ -name "bee.py"

In ase/dft/bee.py change one line:

class BEEFEnsemble:



            if self.xc in ['BEEF-vdW', 'BEEF', 'PBE', 'RPBE']: # add RPBE
                self.beef_type = 'beefvdw'

In gpaw/xc/bee.py add two lines:

class BEEFEnsemble:
    """BEEF ensemble error estimation."""
    def __init__(self, calc):



        # determine functional and read parameters
        self.xc = self.calc.get_xc_functional()
        if self.xc == 'BEEF-vdW':
            self.bee_type = 1
        elif self.xc == 'RPBE': # catch the RPBE exchange functional
            self.bee_type = 1   # assign BEEF coefficients the RBPE

Below we use BEEF-vdW, RPBE, and PBE dimensionless density (n) with gradient (s) and apply BEEF coefficients (E₀, ΔEᵢ) to evaluate the BEE as the standard deviation for the ensemble total energies with the variable enhancement factor (F(s,θᵢ)).


from ase import Atoms
from ase.dft.bee import BEEFEnsemble
from ase.parallel import parprint
from gpaw import GPAW
import time

for xc in ['BEEF-vdW','RPBE','PBE']:
    start_time = time.time()

    h2 = Atoms('H2',[[0.,0.,0.],[0.,0.,0.741]]) #exp. bond length
    h2.center(vacuum=3)
    cell = h2.get_cell()

    calc = GPAW(xc=xc,txt='H2_{0}.txt'.format(xc))
    h2.calc = calc
    e_h2 = h2.get_potential_energy()
    ens = BEEFEnsemble(calc)
    de_h2 = ens.get_ensemble_energies()
    del h2, calc, ens

    h = Atoms('H')
    h.set_cell(cell)
    h.center()
    calc = GPAW(xc=xc,txt='H_{0}.txt'.format(xc), hund=True)
    h.calc = calc
    e_h = h.get_potential_energy()
    ens = BEEFEnsemble(calc)
    de_h = ens.get_ensemble_energies()
    del h, calc, ens

    E_bind = 2*e_h - e_h2
    dE_bind = 2*de_h[:] - de_h2[:]
    dE_bind = dE_bind.std()
    
    parpting('{0} functional'.format(xc))
    parprint('Time: {0} s'.format(round(time.time()-start_time,0)))
    parprint('E_bind: {0} eV'.format(round(E_bind,4)))
    parprint('Error bar {0} eV'.format(round(dE_bind,4)))

TS09 and D4 corrections with ASE

TS09 and D4 are atomic-charge dependent dispersion corrections (see TS09 PRL paper and D4 homepage for the refs). The D4 code is available at github. According to GPAW documentation, TS09 and D4 show for the S26 test set smaller mean deviation than vdW-DF. Herewith, D4 correction does not depend on the actual calculation as it is added to the calculated energy.

Here is how D4 correction can be added with ASE (see Readme):

from ase.build import molecule 
from ase.calculators.mixing import SumCalculator 
from ase.optimize import BFGS
from dftd4.ase import DFTD4 
from gpaw import GPAW 

atoms = molecule('H2O') 
atoms.center(vacuum=4)

gpaw = GPAW(txt='H2O.txt',xc='PBE') 
atoms.calc = SumCalculator([DFTD4(method='PBE'), gpaw])

#atoms.get_potential_energy()

opt = BFGS(atoms)
opt.run(fmax=0.05)

Let me stress that before choosing TS09 or D4 one should consider all pro and contra. TS09 method used Hirshfeld charges while D4 uses the electronegativity equilibration method to obtain charges. The former naturally accounts for the interfacial charge transfer while the latter does not. TS09 requires vdW radii and is implemented for a limited set on functionals (see ASE code), like PBE, RPBE, and BLYP. D4 supports much more functionals (see parameters). Regarding the vdW radii values for TS09 bare in mind that there are four sources – one in GPAW, two in ASE and one more in ASE.

Here is how TS09 correction can be added with ASE and GPAW:

from ase.build import molecule
from ase.calculators.vdwcorrection import vdWTkatchenko09prl
from ase.data.vdw_alvarez import vdw_radii
from ase.optimize import BFGS
from gpaw.analyse.hirshfeld import HirshfeldPartitioning
from gpaw.analyse.vdwradii import vdWradii
from gpaw import GPAW

atoms = molecule('H2O')
atoms.center(vacuum=4)

gpaw = GPAW(txt='H2O.txt',xc='PBE')
atoms.calc = vdWTkatchenko09prl(HirshfeldPartitioning(gpaw), vdWradii(atoms.get_chemical_symbols(), 'PBE'))

#atoms.get_potential_energy()
opt = BFGS(atoms)
opt.run(fmax=0.05)

P.S. Note that the TS09 and D4 energies are no outputted to the H2O.txt.

Installation of LibXC 4.0.0 trunk + GPAW1.3.0 + ASE

Assume that all the requirements are fulfilled:

  • Python 2.7-3.5
  • NumPy 1.6.1 or later (base N-dimensional array package)
  • ASE 3.15.0 or later (atomic simulation environment)
  • a C-compiler
  • LibXC 2.0.1 or later
  • BLAS and LAPACK libraries

Optional, but highly recommended:

  • SciPy 0.7 or later (library for scientific computing, requirered for some features)
  • an MPI library (required for parallel calculations)
  • FFTW (for increased performance)
  • BLACS and ScaLAPACK

LibXC compilation:

svn co http://www.tddft.org/svn/libxc/trunk/ libxc
cd libxc
autoreconf -i
./configure --enable-shared --prefix=/home/USER/xc
make -j N
make install

The LibXC compilation might not work, and GPAW would complain, so configure as follows:

./configure CFLAGS="-O2 -fPIC" --prefix=/home/USER/xc

After compiling LibXC add these lines to your .bashrc:

export C_INCLUDE_PATH=/home/USER/xc/include
export LIBRARY_PATH=/home/USER/xc/lib
export LD_LIBRARY_PATH=/home/USER/xc/lib

Let’s install ASE using pip, because it is easy.

pip install --upgrade --user ase

Get the GPAW source code and remove in libxc.c in c/xc/ line xc_mgga_x_tb09_set_params(self->functional[0], c);. Them compile GPAW with python setup.py install --user. You might want to add the .local/bin to the path.

Use either Python or Python3, and be consistent with that.

The official guideline also recommends adding these lines to your .bashrc:

export PYTHONPATH=/home/USER/gpaw:$PYTHONPATH
export PATH=/home/USER/tools:$PATH

Don’t forget to get setups. E.g. execute gpaw install-data DIR. After that run the tests.

Transpose paste

Despite python etc we still heavily rely on the tables. Sometimes it is need to transpose a vertical data-set to a horizontal representation. That is easy. In LibreOffice Calc use special paste (Shift+Ctrl+v) and tick transpose and numbers. One can do similar trick in Excel. That is it.

Installation of LibXC 3.0.0 trunk + GPAW1.1.0 + ASE

For a long time we wanted to try SCAN functional implemented in LibXC using GPAW. However, at first, fresh LibXC 3.0.0 did not work. Then we could not compile GPAW. Unit today. Here is a recipe that works for Fedora 25.

First, let’s prepare clean Fedora 25:

sudo dnf groupinstall "Development Tools"
sudo dnf groupinstall 'C Development Tools and Libraries'
sudo dnf install gcc-gfortran python-devel zlib-devel
sudo dnf install python-pip blas-devel lapack-devel atlas-devel openblas-devel rpm-build
sudo dnf install openmpi-devel scalapack-openmpi-devel blacs-openmpi-devel
sudo pip install --upgrade pip
pip install --upgrade --user numpy scipy matplotlib
sudo dnf install nano

Nano is installed in case you don’t like vi or emacs. Some packages might not be needed, but we installed them anyway.

LibXC compilation:

svn co http://www.tddft.org/svn/libxc/trunk/ libxc
cd libxc
autoreconf -i
./configure --enable-shared --prefix=/home/USER/xc
make -j N
make install

After compiling LibXC add these lines to your .bashrc:

export C_INCLUDE_PATH=/home/USER/xc/include
export LIBRARY_PATH=/home/USER/xc/lib
export LD_LIBRARY_PATH=/home/USER/xc/lib

Let’s install ASE using pip, because it is easy.

pip install --upgrade --user ase

Get the GPAW source code and remove in libxc.c in c/xc/ line “xc_mgga_x_tb09_set_params(self->functional[0], c);”. Them compile GPAW with python setup.py install --user.  YOu might want to add the .local/bin to the path.

Don’t forget to get setups. E.g. execute gpaw install-data DIR. After that try this example:


from ase import Atom, Atoms
from gpaw import GPAW
xc = 'MGGA_X_SCAN+MGGA_C_SCAN'
bulk = Atoms([Atom('Li')], pbc=True)
k = 4
g = 8
calc = GPAW(gpts=(g, g, g), kpts=(k, k, k),
xc=xc)#, txt=None)
bulk.set_calculator(calc)
bulk.get_potential_energy()

pdf optimisation

While preparing an online report for the PUT1107 project, I encountered a limit for uploaded pdf-files as low as 3 Mb. Thus, I was forced to reduce the pdf-file size to this limit as follows:

1. I merged a set of articles into one files: pdftk 1.pdf 2.pdf 3.pdf output set.pdf

2. Then I reduced the size of the resulting file: gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.4 -dPDFSETTINGS=/screen -dNOPAUSE -dQUIET -dBATCH -sOutputFile=out.pdf set.pdf

The size was reduced by more than 50% with almost the same visual quality.

Taming the equations in Libreoffice

Working on large documents with many equations in a word processor is a torture. In my case, booklets of chemistry problems require a lot of work. For certain reason I prefer to use LibreOffice. When is needed to reformat all equations in a document the following macro is very useful:

Sub FormulaFontSizeChanger

o = ThisComponent.getEmbeddedObjects()

fontSize = 12

fontFamily = “Arial”

For i = 0 to o.count-1

if (not IsNull(o(i))) and (not IsNull(o(i).Model)) then

o(i).Model.TopMargin = 0

o(i).Model.BottomMargin = 0

o(i).Model.LeftMargin = 0

o(i).Model.RightMargin = 0

o(i).Model.BaseFontHeight = fontSize

o(i).Model.FontNameVariables = fontFamily

o(i).Model.FontVariablesIsItalic = 1

o(i).Model.FontNameFunctions = fontFamily

o(i).Model.FontNameNumbers = fontFamily

o(i).Model.FontNameText = fontFamily

o(i).Component.BaseFontHeight = fontSize

o(i).ExtendedControlOverEmbeddedObject.update()

endif

Next i

End Sub

 

P.S. The script might be useful also when writing a thesis with a lot of chemistry inside and many Zotero references. LaTeX might not be so comfortable, and in Word one is still limited with few math fonts.

Installing Gromacs and Lammps

FFTW:

./configure –enable-float –enable-shared –enable-sse2
make -j N
make install

===

Gromacs:

$ tar xvfz gromacs-x.y.z.tar.gz
$ ls
gromacs-x.y.z
$ mkdir build
$ cd build
$ cmake ../gromacs-x.y.z -DCMAKE_INSTALL_PREFIX=/home/yourUser/opt/gromacs.x.y.z -DGMX_CPU_ACCELERATION=SSE2 -DGMX_SIMD=SSE2
$ make -j N
$ make install

===

LAMMPS:

$ git clone git://git.lammps.org/lammps-ro.git LAMMPS
$ make yes-molecule
$ make mpi

===

To the .bashrc add:

#Gromacs

source /home/yourUser/opt/gromacs.x.y.z/bin/GMXRC
#or source /your/installation/prefix/here/bin/GMXRC

#LAMMPS
export LD_LIBRARY_PATH=~/LAMMPS/src:$LD_LIBRARY_PATH
export PATH=~/LAMMPS/src:$PATH