JUSTUS2/Software/Dalton: Difference between revisions

From bwHPC Wiki
Jump to navigation Jump to search
No edit summary
 
(85 intermediate revisions by 4 users not shown)
Line 1: Line 1:
{{Softwarepage|chem/dalton}}
{| width=600px class="wikitable"

{| width=760px class="wikitable"
|-
|-
! Description !! Content
! Description !! Content
Line 5: Line 7:
| module load
| module load
| chem/dalton
| chem/dalton
|-
| Availability
| [[bwUniCluster]]
|-
|-
| License
| License
| GNU Lesser General Public License (LGPL).
| [http://www.daltonprogram.org/www/download.html License/Distribution policy] | [[#License| ...more infos here... ]]
|-
|-
| Citing
| Citing
| [https://daltonprogram.org/citation/ Publications]
| [http://www.daltonprogram.org/www/download.html Citation Includes] | [http://www.daltonprogram.org/www/citation.html Dalton references]
|-
|-
| Links
| Links
| [http://www.daltonprogram.org/index.html Dalton Homepage] | [http://www.daltonprogram.org/www/resources/dalton2013manual.pdf Dalton 2013 Manual]
| [http://www.daltonprogram.org/index.html Homepage] | [https://daltonprogram.org/documentation/ Documentation]
|-
|-
| Graphical Interface
| Graphical Interface
| No
| No
|}
|}
= Description =
= Description =
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, now also with some CCSD capabilites.
<br>
General Features
* 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 MPI parallel for direct Fock matrix constructions and for DFT integrations over grid points
* Effective core-potentials (ECPs)
* Multiscale models (continuum and QM/MM using PE)
* Most sections can exploit point-group symmetry D2h and subgroups
<br>
For more information on features please visit [http://www.daltonprogram.org/www/features.html Description of the Dalton program features] web page.
<br>
<br>
= Versions and Availability =
A list of versions currently available on all bwHPC-C5-Clusters can be obtained from the
<br>
<big>


'''Dalton''' (named after [https://en.wikipedia.org/wiki/John_Dalton John Dalton]) is an ab initio quantum chemistry computer program designed to to allow convenient, automated determination of a large number of molecular properties based on an HF, HF-srDFT, DFT, MP2, CC, CI, MCSCF, or MC-srDFT reference wave function. For additional information on features please visit the [https://daltonprogram.org/features/ Description of the Dalton suite features] web page.
[https://cis-hpc.uni-konstanz.de/prod.cis/ Cluster Information System CIS]


</big>
{{#widget:Iframe
|url=https://cis-hpc.uni-konstanz.de/prod.cis/bwUniCluster/chem/dalton
|width=99%
|height=150
|border=1
}}
<big><p style="color: red;">Open the above links by using the right mouse button and select "open in a new window" or "open in a new tab".</p></big>
On the command line interface of any bwHPC cluster you'll get a list of available versions
by using the command 'module avail chem/dalton'.
<pre>
$ module avail chem/dalton
------------------------ /opt/bwhpc/common/modulefiles -------------------------
chem/dalton/2013
</pre>
<br>
= License =
Code is distributed freely to individuals, but require the users to agree to a personal licence agreement. Site licenses are available, on the condition that the site keeps the source code confidential. Additionally, benchmark licences, valid for a restricted period of time, are available.
<br>
== Obtaining a licence ==
A licence to use the Dalton programs can be obtained after filling in the
<br>
[http://daltonprogram.org/licence/ Dalton2015 Dalton Licence Application Form].
<br>
<br>


= Usage =
= Usage =
== Loading the module ==
== Loading the module ==
See [[Software Modules]] documentation
You can load the default version of ''Dalton'' with the command:

== Input Files ==

For information about how to construct input files (dalinp{.dal} [molinp{.mol} [potinp{.pot}]]) for Dalton, please consult the [https://daltonprogram.org/manuals/dalton2020manual.pdf vendor documentation].

== Environment Variables ==

Environment variables understood by Dalton:
<pre>
<pre>
DALTON_TMPDIR : scratch directory
$ module load chem/dalton
DALTON_USE_GLOBAL_SCRATCH : use global scratch directory, do not copy any files to worker nodes
DALTON_NODELIST : list of nodes, dalton.x will be copied to DALTON_TMPDIR on each node unless
DALTON_USE_GLOBAL_SCRATCH is defined
DALTON_LAUNCHER : launcher for the dalton.x binary (if defined, -N flag not allowed)
</pre>
</pre>


The module will try to load modules it needs to function (e.g. compiler, mpi, numlibs).
If loading the module fails, check if you have already loaded one of those modules,
but not in the version needed for Dalton.
If you wish to load a specific (older) version (if available), you can do so using e.g.
'module load chem/dalton/version' to load the version you desires.
<pre>
$ module avail chem/dalton
------------------------ /opt/bwhpc/common/modulefiles -------------------------
chem/dalton/2013
$ module load chem/dalton/2013
</pre>
== Program Binaries ==
You can find the Dalton binaries in the main folder of the Dalton system.
After loading the Dalton module ('module load chem/dalton/version') it's path is
also set to the local $PATH- and $DALTON_BIN_DIR environments.
$DALTON_BIN_DIR=/opt/bwhpc/common/chem/
<pre>
$ : Example with Dalton 2013
$ echo $DALTON_BIN_DIR
/opt/bwhpc/common/chem/dalton/2013/bin
$ ls -F $DALTON_BIN_DIR
basis/ DALTON.STAT GIT_HASH lsdalton.x* tools/
dalton* dalton.x* lsdalton* lslib_tester.x* VERSION
</pre>
* A '/' at the end of a file name indicates a directory/folder.
* '*' is an executable file.
== Disk Usage ==
== Disk Usage ==
Scratch files are written to the current directory by default.
<font color=red>Please change to a local directory or to '''your local workspace''' (preferred) before starting your calculations.</font>


Scratch files are written to <span style="background:#edeae2;margin:2px;padding:1px;border:1px dotted #808080">$SCRATCH</span> by default. This configuration option can be changed by setting the environment variable <span style="background:#edeae2;margin:2px;padding:1px;border:1px dotted #808080">$DALTON_TMPDIR</span> (e.g., to a dedicated [[workspace]]) before starting your calculations with Dalton.
'dalton_repo' is an example name of a repository you created by using the command 'ws_allocate'.


<pre>
$ cd $(ws_find dalton_repo)
['your-id'-dalton_repo-0]$ pwd
/work/workspace/scratch/'your-id'-dalton_repo-0
['your-id'-dalton_repo-0]$
</pre>
<br>
= Examples =
= Examples =

== bwHPC examples ==
As with all processes that require more than a few minutes to run, non-trivial compute jobs must be submitted to the cluster queuing system.
You can copy a simple interactive example to your '''workspace''' and run it, using 'msub'

Example scripts are available in the directory <span style="background:#edeae2;margin:2px;padding:1px;border:1px dotted #808080">$DALTON_EXA_DIR</span>:
<pre>
<pre>
$ module load chem/dalton # load module
$ cd $(ws_find dalton_repo)
$ ls $DALTON_EXA_DIR # show content of directory $DALTON_EXA_DIR
$ cp $DALTON_EXA_DIR/bwunicluster-dalton-example.moab .
$ cat $DALTON_EXA_DIR/README # show examples README
$ cp bwunicluster-dalton-example.moab mydaltonjob.moab
§ vi mydaltonjob.moab # do your own modifications
$ msub mydaltonjob.moab # start job submission
</pre>
</pre>
It is strongly recommended to use $DALTON_EXA_DIR to find the bwHPC examples.
<br>
=== bwHPC Moab submit script ===
Here is an excerpt from the supplied bwunicluster-dalton-example.moab script as found in $DALTON_EXA_DIR.
{{bwFrameA|
<source lang="bash">
[...]
echo " "
echo "### Copying input test files for job (if required):"
echo " "
cp -vr ${DALTON_EXA_DIR}/ethane-blyp-benchmark.{dal,mol} .

echo " "
echo "### Redefine TMPDIR for storing temporary Dalton files ..."
echo " "
export TMPDIR="${TMP_WORK_DIR}/dalton_tmp"
export DALTON_TMPDIR="${TMP_WORK_DIR}/dalton_tmp"
echo "TMPDIR = ${TMPDIR}"
echo "DALTON_TMPDIR = ${TMPDIR}"
echo " "
echo "### Calling dalton command ..."
echo " "


Run a first simple example job on JUSTUS2:
# Here is the main Dalton command showing how to run a regular
# Dalton job (mpirun is invoked within the 'dalton' script automatically).
# For details on the Dalton job see 'ethane-blyp-benchmark.info'.
# Example job input: ethane-blyp-benchmark.{dal,mol}
# Example job output: bwhpc-example.out ethane-blyp-benchmark.tar.gz.
export workdir=${TMP_WORK_DIR}
cd ${TMP_WORK_DIR}
time $DALTON_BIN_DIR/dalton -N ${MOAB_PROCCOUNT} -o bwhpc-example.out ethane-blyp-benchmark.dal ethane-blyp-benchmark.mol
[...]
</source>
}}
<br>
= Dalton-Specific Environments =
To see a list of all Dalton environments set by the 'module load'-command use 'env | grep DALTON'. Or use the command 'module display chem/dalton'.
<pre>
<pre>
$ module load chem/dalton # load module
$ : Example with Dalton 2013
$ WORKSPACE=`ws_allocate dalton 3` # allocate workspace
$ env | grep DALTON
$ cd $WORKSPACE # change to workspace
DALTON_VERSION=2013
$ cp -a $DALTON_HOME/bwhpc-examples . # copy example files to workspace
DALTON_EXA_DIR=/opt/bwhpc/common/chem/dalton/2013/bwhpc-examples
$ cd bwhpc-examples # change to test directory
DALTON_BIN_DIR=/opt/bwhpc/common/chem/dalton/2013/bin
$ sbatch dalton-2020.0.slurm # submit job
DALTON_HOME=/opt/bwhpc/common/chem/dalton/2013
$ squeue # obtain JOBID
$ scontrol show job <JOBID> # check state of job
$ ls # when job finishes the results will be visible in this directory
</pre>
</pre>
<br>
= Version-Specific Information =
For a more detailed information specific to a specific Dalton version, see the information available via the module system with the command 'module help chem/dalton/version'.
<br>
For a small abstract what Dalton is about use the command 'module whatis chem/dalton/version'.
<br>
<pre>
$ : Dalton 2013 examples
$ module whatis chem/dalton
chem/dalton : Moleculare electronic structure package DALTON 2013
(command 'dalton' and 'lsdalton')
$ :
$ module help chem/dalton
----------- Module Specific Help for 'chem/dalton/2013' -----------
This module provides the quantum chemistry program Dalton
version 2013 (see also http://dirac.chem.sdu.dk/daltonprogram.org/).


= FAQ =
The Dalton2013 suite consists of two separate executables,

'dalton' and 'lsdalton'. The DALTON code is a powerful tool
'''Q:''' What to do if my simulations abort with <span style="background:#edeae2;margin:2px;padding:1px;border:1px dotted #808080"> MEMGET ERROR, insufficient work space in memory </span>?
for a wide range of molecular properties at different levels

of theory (e.g. MCSCF or CC), whereas LSDALTON is a linear-scaling
'''A:''' Increase Dalton's usable work memory with either -mb or -gb on the command line.
HF and DFT code suitable for large molecular systems.

[...]
= Useful links =
Documentation:

* For 'dalton' command line options see output of 'dalton -h'.
* [https://daltonprogram.org/manuals/dalton2020manual.pdf Documentation (english)]
This includes the specification of the memory, the number of workers
* [http://forum.daltonprogram.org Forum (english)]
and how the tmp work dir is used.
* [https://en.wikipedia.org/wiki/Dalton_(program) Wikipedia article (english)]
* An Moab example script for dalton including a short
* [https://daltonprogram.org/tools/ Plugins for Dalton (english)]
example calculation can be found here:
/opt/bwhpc/common/chem/dalton/2013/bwhpc-examples/bwunicluster-dalton-example.moab
You can copy the example and submit it to the queueing system.
[...]
</pre>
----
[[Category:Chemistry software]][[Category:bwUniCluster]]

Latest revision as of 11:30, 23 April 2024

The main documentation is available via module help chem/dalton on the cluster. Most software modules for applications provide working example batch scripts.


Description Content
module load chem/dalton
License GNU Lesser General Public License (LGPL).
Citing Publications
Links Homepage | Documentation
Graphical Interface No

Description

Dalton (named after John Dalton) is an ab initio quantum chemistry computer program designed to to allow convenient, automated determination of a large number of molecular properties based on an HF, HF-srDFT, DFT, MP2, CC, CI, MCSCF, or MC-srDFT reference wave function. For additional information on features please visit the Description of the Dalton suite features web page.


Usage

Loading the module

See Software Modules documentation

Input Files

For information about how to construct input files (dalinp{.dal} [molinp{.mol} [potinp{.pot}]]) for Dalton, please consult the vendor documentation.

Environment Variables

Environment variables understood by Dalton: 

DALTON_TMPDIR             : scratch directory
DALTON_USE_GLOBAL_SCRATCH : use global scratch directory, do not copy any files to worker nodes
DALTON_NODELIST           : list of nodes, dalton.x will be copied to DALTON_TMPDIR on each node unless
                            DALTON_USE_GLOBAL_SCRATCH is defined
DALTON_LAUNCHER           : launcher for the dalton.x binary (if defined, -N flag not allowed)

Disk Usage

Scratch files are written to $SCRATCH by default. This configuration option can be changed by setting the environment variable $DALTON_TMPDIR (e.g., to a dedicated workspace) before starting your calculations with Dalton.

Examples

As with all processes that require more than a few minutes to run, non-trivial compute jobs must be submitted to the cluster queuing system.

Example scripts are available in the directory $DALTON_EXA_DIR: 

$ module load chem/dalton                # load module
$ ls $DALTON_EXA_DIR                     # show content of directory $DALTON_EXA_DIR
$ cat $DALTON_EXA_DIR/README             # show examples README

Run a first simple example job on JUSTUS2: 

$ module load chem/dalton                           # load module
$ WORKSPACE=`ws_allocate dalton 3`                  # allocate workspace
$ cd $WORKSPACE                                     # change to workspace
$ cp -a $DALTON_HOME/bwhpc-examples .               # copy example files to workspace
$ cd bwhpc-examples                                 # change to test directory
$ sbatch dalton-2020.0.slurm                        # submit job
$ squeue                                            # obtain JOBID
$ scontrol show job <JOBID>                         # check state of job
$ ls                                                # when job finishes the results will be visible in this directory

FAQ

Q: What to do if my simulations abort with MEMGET ERROR, insufficient work space in memory ?

A: Increase Dalton's usable work memory with either -mb or -gb on the command line.

Useful links

Retrieved from "https://wiki.bwhpc.de/wiki/index.php?title=JUSTUS2/Software/Dalton&oldid=12713"