JDFTx contains a python interface class to the Atomic Simulation Environment (https://wiki.fysik.dtu.dk/ase/), developed by CAMd in DTU. This provides a quick but powerful interface to many features, including phonons and ab-initio molecular dynamics.
The current implementation of the interface is as a force calculator. Potential energies and forces are implemented, but stresses are still under development.
The interface is available with JDFTx source code, under the scripts directory (/jdftx/scripts/ase).
Installing the JDFTx calculator can be done in three steps:
Download and compile JDFTx
See here for more details on compiling JDFTx.
Install Atomic Simulation Environment (ASE):
ASE is not distributed with JDFTx, and requires separate installation. See here about installing ASE.
Add JDFTx interface to PythonPath:
To be able to use the JDFTx interface, python needs to know where the interface file is located. This is done by adding the jdftx/scripts/ase to your PythonPath variable.
In unix based systems, the easiest way to do this is by adding the line
export PYTHONPATH=/path-to-jdftx/scripts/ase:$PYTHONPATH
to your ~/.bashrc or ~/.profile files. Once this is done, you can import the JDFTx calculator simply by
from JDFTx import JDFTx
JDFTx interface needs to know where your executable and pseudopotentials are located. This can be done at runtime by specifying paths to the class constructor, or by setting environment variables in your system.
A JDFTx calculator object uses variables executable and pseudoDir to find the executable and the pseudopotential directory. By default, they are set to the envionment variables $JDFTx and $JDFTx_pseudo. These can be set in the constructor or changed later.
The easiest way to use the interface is to set these environment variables. On Ubuntu, this can be accomplished by to accomplish this is to have the lines
export JDFTx=/path/to/jdftx export JDFTx_pseudo=/path/to/pseudopotential/directory
in your ~/.bashrc or ~/.profile files.
On clusters with resource management programs (e.g. slurm, torque...), you can override the executable with a command that submits a job to the queue. For example, on slurm, the following would work:
calculator = JDFTx(executable='srun /path/to/jdftx')
Take note that when you do that, the command that submits the job (in this case, srun) should not release the shell until the job is completed. For example, in slurm, srun would work, but not sbatch.
Below is a sample python script that uses jdftx through the ASE interfae to calculate the bond length of CO molecule using the BFGS minimization algorithm. Keep in mind that in order for the script to run, you need to modify the paths for the executable and the pseudopotentials.
from ase import Atoms from JDFTx import * d = 1.25 CO = Atoms('CO', positions=[(0, 0, 0), (0, 0, d)], cell=[(10,0,0),(0,10,0),(0,0,15)], pbc = [False, False, False]) # set up JDFTx calculator jdftx_calculator = JDFTx(executable='/path/to/executable', pseudoDir='/path/to/pseudopotentials', commands={"elec-cutoff": 30}) CO.set_calculator(jdftx_calculator) # print the initial total energy print CO.get_potential_energy() # perform structure optimization from ase.optimize import BFGS dyn = BFGS(CO) dyn.run(fmax=0.05)
Output from this script is:
-583.728565039 BFGS: 0 12:37:44 -583.728565 8.6537 BFGS: 1 12:38:44 -584.230224 3.4122 BFGS: 2 12:39:45 -584.274439 2.0316 BFGS: 3 12:40:48 -584.291420 0.2329 BFGS: 4 12:41:50 -584.291665 0.0144
(warning: the exact energies depend on the pseudopotentials you use.)