Dalton

Dalton (named after John Dalton) is an ab initio quantum chemistry computer program. It is capable of calculating various molecular properties using the Hartree–Fock, MP2, MCSCF and coupled cluster theories.

Policy

Dalton has several authors, including Hans Jørgen Aagaard Jensen, Hans Ågren, Trygve Helgaker, and Poul Jørgensen. HPC2N has a site license, allowing our users to use the program.

Citations

All published work with results obtained with programs in the Dalton suite, is required to include a citation. Details of how to cite Dalton 2016 can be found here on Dalton’s page about citations.

Overview

The Dalton suite consists of two separate executables, DALTON and LSDALTON. The DALTON code is a powerful tool for a wide range of molecular properties at different levels of theory, whereas LSDALTON is a linear-scaling HF and DFT code suitable for large molecular systems.

DALTON:

  • First- and second-order methods for geometry optimizations
  • Robust second-order methods for locating transition states
  • Constrained geometry optimizations; bonds, angles and dihedral angles can be fixed during optimizations
  • General numerical derivatives that automatically makes use of the highest order analytical derivative available
  • Vibrational analysis and vibrational averaging, including anharmonic effects
  • HF and DFT code direct and parallel using replication of Fock matrices using MPI for message passing
  • Effective core-potentials (ECPs)

LSDALTON:

  • Efficient and linear-scaling HF and DFT code (OpenMP parallel)
  • Robust and efficient wave-function optimization procedures
  • First-order methods for geometry optimizations (minima and transition structures)
  • A variety of different molecular properties

A longer description of the Dalton programs features can be found here on the Dalton page.

Dalton at HPC2N

On HPC2N we have Dalton available as a module on Kebnekaise. To see the available versions, login to Kebnekaise and do ml spider dalton.

Note that lsdalton is NOT installed.

Usage at HPC2N

To use, load the Dalton module to add it to your environment. You give this command to see which versions of Dalton are available: 

ml spider Dalton

And then this to see how to load a specific version of Dalton and its prerequisites:

ml spider Dalton/<version>

Note

HPC2N has compiled the program with GCC compilers. This is an OpenMP + MPI hybrid build. Dalton provides a few environment variables that refers to various directories, please use them, if needed, and not hard coded pathnames as this will make your life easier when Dalton gets upgraded.

When the dalton module is loaded, you can find most of the environment variables with

  • dalton -h

while a few (like path to the install directory) are found with

  • env | grep -i dalton

NOTE: that DALTON_TMPDIR needs to be defined by the userr.

Important options

There are several options to the script, which can be viewed by typing dalton -h or just dalton when the module is loaded.

Some of the more important ones include:

  • -b directory Prepend this directory to the list of directories where the program should look for basis sets. Needed in case you want to use local modifications of a given basis. The job directory and the basis set library will always be included in the basis set directory list (in that search order).
  • -f dal_mol[_pot] extract dal_mol[_pot].tar.gz archive from WRKDIR into DALTON_TMPDIR before calculation starts
  • -mb mem set dalton max usable work memory to mem Megabytes.
  • -N num Use num MPI processes
  • -o filename Redirect the output normally printed in the DALTON.OUT file in the temporary directory to the file “filename” in the WRKDIR directory. On a computer system with distributed scratch disk but a commonly mounted home directory, this allows you to follow the calculation without having to log into the compute nodes.
  • -w wrkdir Change the working directory to “wrkdir”, that is, change the directory in which the program searches for input files and places the DALTON.OUT file to “wrkdir”.

Serial runs

To run the program, load the module, then use this command:

dalton [options] dalinp{.dal} [molinp{.mol} [potinp{.pot}]]

to run using the shell script dalton, which is the recommended way of running.

Example

Say you have the input file myinput.dal, and the molecule input molinput.mol, you would type this to run

dalton myinput molinput

When the job is finished, the output is copied back as myinput_molinput.out. In addition, the program will copy back a file named myinput_nmolinput.tar.gz. This file contains, in tar’ed and gzip’ed form, a number of useful intergace and post-processing files which may be needed for post-DALTON programs, or for restarting calculations.

Note

If it is anything but a short program, you should ALWAYS run it as a batch script.

Example, batch script

#!/bin/bash
# Change to your own project id
#SBATCH -A hpc2nXXXX-YYY
# Asking for 1 task
#SBATCH -n 1
# Asking for 30 minutes run time 
#SBATCH --time=00:30:00

# Load the Dalton module and its prerequisites - here for DALTON/2020.0 
ml GCC/10.3.0  
ml OpenMPI/4.1.1 
ml DALTON/2020.0 

dalton [options] dalinp{.dal} [molinp{.mol} [potinp{.pot}]]

Submit the script with

sbatch <jobscript>

MPI runs

Note srun and mpirun both works

Example script

Assuming you have an input file dalton_in.dal (if you have a molecule input file, add that one as well)

Change n and DALTON_NUM_MPI_PROCS accordingly.

#!/bin/bash
#SBATCH -J DALTON-test
#SBATCH -A hpc2nXXXX-YYY 
# In this example for 8 tasks 
#SBATCH -n 8
#SBATCH --time=10:30:00

# Load the Dalton module and its prerequisites - here for DALTON/2020.0 
ml GCC/10.3.0 
ml OpenMPI/4.1.1 
ml DALTON/2020.0  

# You can call the tmp dir anything
export DALTON_TMPDIR=<what-you-want>

export DALTON_NUM_MPI_PROCS=8

dalton -N 8 -noappend -t `pwd`/<any tmpdir> [options] dalinp{.dal} [molinp{.mol} [potinp{.pot}]

Submit the script with

sbatch <jobscript>

Additional info