Introduction

The DL_POLY Package

DL_POLY ¹²² is a package of subroutines, programs and data files, designed to facilitate molecular dynamics simulations of macromolecules, polymers, ionic systems and solutions on a distributed memory parallel computer. It is available in two forms: DL_POLY_Classic (written by Bill Smith & Tim Forester, http://www.ccp5.ac.uk/DL_POLY_CLASSIC/) and DL_POLY_5 (written by Ilian Todorov & Bill Smith) ^134,135. Both versions were originally written on behalf of CCP5, the UK’s Collaborative Computational Project on Molecular Simulation, which has been in existence since 1980 ¹¹³ (http://www.ccp5.ac.uk/DL_POLY/).

The two forms of DL_POLY differ primarily in their method of exploiting parallelism. DL_POLY_Classic uses a Replicated Data (RD) strategy ^{114,117,120,121} which works well simulations of up to 30,000 atoms on up to 100 processors. DL_POLY_5 is based on the Domain Decomposition (DD) strategy ^{88,97,114,117,134,135}, and is best suited for large molecular simulations from \(10^{3}\) to \(10^{9}\) atoms on large processor counts. The two packages are reasonably compatible, so that it is possible to scale up from a DL_POLY_Classic simulation to a DL_POLY_5 one with little effort. It should be apparent from these comments that DL_POLY_5 is not intended as a replacement for DL_POLY_Classic.

Users are reminded that we are interested in hearing what other features could be usefully incorporated. We obviously have ideas of our own and CCP5 strongly influences developments, but other input would be welcome nevertheless. We also request that our users respect the integrity of DL_POLY_5 source and not pass it on to third parties. We require that all users of the package register with us, not least because we need to keep everyone abreast of new developments and discovered bugs. We have developed various forms of licence, which we hope will ward off litigation (from both sides), without denying access to genuine scientific users.

Further information on the DL_POLY packages may be obtained from the DL_POLY project website - http://www.ccp5.ac.uk/DL_POLY/.

Functionality

The following is a list of the features DL_POLY_5 supports.

Molecular Systems

DL_POLY_5 will simulate the following molecular species:

• Simple atomic systems and mixtures, e.g. Ne, Ar, Kr, etc.

• Simple unpolarisable point ions, e.g. NaCl, KCl, etc.

• Polarisable point ions and molecules, e.g. MgO, H\(_{2}\)O, etc.

• Simple rigid molecules e.g. CCl\(_{4}\), SF\(_{6}\), Benzene, etc.

• Rigid molecular ions with point charges e.g. KNO\(_{3}\), (NH\(_{4}\))\(_{2}\)SO\(_{4}\), etc.

• Polymers with rigid bonds, e.g. C\(_{n}\)H\(_{2n+2}\)

• Polymers with flexible and rigid bonds and point charges, e.g. proteins, macromolecules etc.

• Silicate glasses and zeolites

• Simple metals and metal alloys, e.g. Al, Ni, Cu, Cu\(_{3}\)Au, etc.

• Covalent systems as hydro-carbons and transition elements, e.g. C, Si, Ge, SiC, SiGe, ets.

Force Field

The DL_POLY_5 force field includes the following features:

#. All common forms of non-bonded atom-atom (van der Waals) potentials, where these also include bead-bead forms of Dissipative Particle Dynamics (DPD) interactions (inclusive of many-body DPD)

#. Atom-atom (and site-site) coulombic potentials, where these can be screened at desired distances as in DPD models

1. Metal-metal (local density dependent) potentials ^{25,39,40,93,127,131}

2. Tersoff (local density dependent) potentials (for hydro-carbons) ¹²⁸

3. Three-body valence angle and hydrogen bond potentials

4. Four-body inversion potentials

5. Ion core-shell polarasation

6. Tether potentials

7. Chemical bond potentials

8. Valence angle potentials

9. Dihedral angle (and improper dihedral angle) potentials

10. Inversion angle potentials

11. External field potentials.

The parameters describing these potentials may be obtained, for example, from the GROMOS ¹³⁹, Dreiding ⁷⁵ or AMBER ¹⁴⁹ forcefield, which share functional forms. It is relatively easy to adapt to user specific force fields.

Boundary Conditions

DL_POLY_5 will accommodate the following boundary conditions:

1. None, e.g. isolated molecules in vacuo

2. Cubic periodic boundaries

3. Orthorhombic periodic boundaries

4. Parallelepiped periodic boundaries

5. Slab (x,y periodic, z non-periodic).

These are described in detail in Appendix B. Note that periodic boundary conditions (PBC) \(1\) and \(5\) above require careful consideration to enable efficient load balancing on a parallel computer.

Java Graphical User Interface

The DL_POLY_5 Graphical User Interface (GUI) is the same one that also comes with DL_POLY_Classic, which is written in the Java programming® language from Sun® Microsystems. A major advantage of this is the free availability of the Java programming environment from Sun®, and also its portability across platforms. The compiled GUI may be run without recompiling on any Java® supported machine. The GUI is an integral component of the DL_POLY suites and is available on the same terms (see the GUI manual ¹¹⁸).

Algorithms

Parallel Algorithms

DL_POLY_5 exclusively employs the Domain Decomposition parallelisation strategy ^{88,97,114,117} (see Section: Parallelisation).

Molecular Dynamics Algorithms

DL_POLY_5 offers a selection of MD integration algorithms based on Velocity Verlet (VV) ⁴. These generate NVE, NVE\(_{kin}\), NVT, NPT and NT ensembles with a selection of thermostats and barostats. Parallel versions of the RATTLE ⁷ and SHAKE ¹²¹ algorithms are used for solving bond constraints. The rotational motion of rigid bodies (RBs) is handled with the “NOSQUISH” algorithm of Miller et al ⁷⁹.

The following MD algorithms are available:

1. Constant E algorithm

2. Evans constant E\(_{kin}\) algorithm ³⁵

3. Langevin constant T algorithm ²

4. Andersen constant T algorithm ⁶

5. Berendsen constant T algorithm ¹¹

6. Nosé-Hoover constant T algorithm ⁵¹

7. Langevin constant T,P algorithm ⁹⁰

8. Berendsen constant T,P algorithm ¹¹

9. Nosé-Hoover constant T,P algorithm ⁵¹

10. Martyna, Tuckerman and Klein (MTK) constant T,P algorithm ⁷³

11. Langevin constant T,\(\underline{\underline{\mathbf{\sigma}}}\) algorithm ⁹⁰

12. Berendsen constant T,\(\underline{\underline{\mathbf{\sigma}}}\) algorithm ¹¹

13. Nosé-Hoover constant T,\(\underline{\underline{\mathbf{\sigma}}}\) algorithm ⁵¹

14. Martyna, Tuckerman and Klein (MTK) constant T,\(\underline{\underline{\mathbf{\sigma}}}\) algorithm ⁷³.

DL_POLY_Classic features incompatible or unavalable in DL_POLY_5

• Force field

  • Rigid bodies connected with constraint links are not available

  • Shell models specification is solely determined by the presence of mass on the shells

  • Dihedral potentials with more than three original parameters (see OPLS) have two artificially added parameters, defining the 1-4 electrostatic and van der Waals scaling factors, which must be placed at fourth and fifth position respectively, extending the original parameter list split by them

• Boundary conditions

  • Truncated octahedral periodic boundaries (imcon \(= 4\)) are not available

  • Rhombic dodecahedral periodic boundaries (imcon \(= 5\)) are not available

  • Hexagonal prism periodic boundaries (imcon \(= 7\)) are not available

• Electrostatics

  • Standard Ewald Summation is not available, but is substituted by Smoothed Particle Mesh Ewald (SPME) summation

  • Hautman-Klein Ewald Summation for 3D non-periodic but 2D periodic systems is not available

• Non-standard functionality

  • Temperature Accelerated Dynamics

  • Hyperdynamics

  • Solvation Energies

  • Path Integral MD (PIMD)

Programming Style

The programming style of DL_POLY_5 is intended to be as uniform as possible. The following stylistic rules apply throughout. Potential contributors of code are requested to note the stylistic convention.

Programming Language

DL_POLY_5 is written in free format FORTRAN90. In DL_POLY_5 we have adopted the convention of explicit type declaration i.e. we have used

Implicit None

in all subroutines. Thus all variables must be given an explicit type: Integer, Real( Kind = wp), etc.

Modularisation and Intent

DL_POLY_5 exploits the full potential of the modularisation concept in FORTRAN90. Variables having in common description of certain feature or method in DL_POLY_5 are grouped in modules. This simplifies subroutines’ calling sequences and decreases error-proneness in programming as subroutines must define what they use and from which module. To decrease error-proneness further, arguments that are passed in calling sequences of functions or subroutines have defined intent, i.e. whether they are to be:

• passed in only (Intent (In)) - the argument is not allowed to be changed by the routine

• passed out only (Intent (Out)) - the “coming in” value of the argument is unimportant

• passed in both directions in and out (Intent (InOut)) - the “coming in” value of the argument is important and the argument is allowed to be changed.

Memory Management

DL_POLY_5 exploits the dynamic array allocation features of FORTRAN90 to assign the necessary array dimensions.

Target Platforms

DL_POLY_5 is intended for distributed memory parallel computers.

Compilation of DL_POLY_5 in parallel mode requires only a FORTRAN90 compiler and Message Passing Interface (MPI) to handle communications. Compilation of DL_POLY_5 in serial mode is also possible and requires only a FORTRAN90 compiler.

Internal Documentation

All subroutines are supplied with a header block of FORTRAN90 comment (!) records giving:

1. The name of the author and/or modifying author

2. The version number or date of production

3. A brief description of the function of the subroutine

4. A copyright statement.

Elsewhere FORTRAN90 comment cards (!) are used liberally.

FORTRAN90 Parameters and Arithmetic Precision

All global parameters defined by the FORTRAN90 parameter statements are specified in the module file: setup_module`, which is included at compilation time in all subroutines requiring the parameters. All parameters specified in setup_module are described by one or more comment cards.

One super-global parameter is defined at compilation time in the kinds_f90 module file specifying the working precision (wp) by kind for real and complex variables and parameters. The default is 64-bit (double) precision, i.e. Real(wp). Users wishing to compile the code with quadruple precision must ensure that their architecture and FORTRAN90 compiler can allow that and then change the default in kinds_f90. Changing the precision to anything else that is allowed by the FORTRAN90 compiler and the machine architecture must also be compliant with the MPI working precision mpi_wp as defined in comms_module (in such cases users must correct for that in there).

Units

Internally all DL_POLY_5 subroutines and functions assume the use of the following defined molecular units:

• The unit of time (\(t_{o}\)) is \(1 \times 10^{-12}\) seconds (i.e. picoseconds)

• The unit of length (\(\ell_{o}\)) is \(1 \times 10^{-10}\) metres (i.e. Ångstroms)

• The unit of mass (\(m_{o}\)) is \(1.6605402 \times 10^{-27}\) kilograms (i.e. Daltons - atomic mass units)

• The unit of charge (\(q_{o}\)) is \(1.60217733 \times 10^{-19}\) Coulombs (i.e. electrons - units of proton charge)

• The unit of energy (\(E_{o}=m_{o}(\ell_{o}/t_{o})^{2}\)) is \(1.6605402 \times 10^{-23}\) Joules (10 J mol\(^{-1}\))

• The unit of pressure (\({\cal P}_{o}=E_{o}\ell_{o}^{-3}\)) is \(1.6605402 \times 10^{7}\) Pascals (\(163.882576\) atmospheres)

• Planck’s constant (\(\hbar\)) which is \(6.350780668 \times E_{o} t_{o}\)  .

In addition, the following conversion factors are used:

• The coulombic conversion factor (\(\gamma_{o}\)) is:

  \[\gamma_{o} = \frac{1}{E_{o}} \left[ \frac{q_{o}^{2}}{4 \pi \epsilon_{o} \ell_{o}} \right] = 138935.4835~~,\]

  such that:

  \[U_{\tt MKS}=E_{o}\gamma_{o}U_{\tt Internal}~~,\]

  where \(U\) represents the configuration energy.

• The Boltzmann factor (\(k_{B}\)) is \(0.831451115~E_{o}\) K:math:^{-1}, such that:

  \[T=E_{kin}/k_{B}\]

  represents the conversion from kinetic energy (in internal units) to temperature (in Kelvin).

Note

In the DL_POLY_5 OUTPUT file, the print out of pressure is in units of katms (kilo-atmospheres) at all times, except when DPD units are in use (which uses energy per unit volume, \([E] [L]^{-3}\)). The unit of energy is either DL_POLY units specified above, or in other units specified by the user at run time (see Section The FIELD File). The default is the DL_POLY unit.

Externally, DL_POLY_5 accepts information in its own specific formatting as described in Section The INPUT Files. Irrespective of formatting rules, all values provided to define input entities are read in DL_POLY units (except otherwise specified as in the case of energy units and, for DPD simulations, temperature units) or their composite mixture representing the corresponding entity physically, i.e. velocities’ components are in Ångstroms/picosecond.

Exception: It should be noted that when DL_POLY_5 is used in DPD mode (see Section Dissipative Particle Dynamics (DPD)) then the meaning of the molecular units is somewhat lost and it is only the inter-relationship between units that is important. This can be exploited by the modeller when using ‘dpd’ with the UNITS directive in the FIELD file! The fundamental units for a DPD simulation are related to those of mass \([M]\), length \([L]\) and energy \([E]\). Therefore, the DPD unit of time is equivalent to \([t] = [L]\sqrt{[M]/[E]}\) while temperature (in the form \(k_{B}T\)) is defined as two-thirds of the mean kinetic energy of the system’s particles. Similarly, volume is in units of \([L]^{3}\) and pressure in \([E]/[L]^{3}\), while velocities and forces are in \([L][t]^{-1} = \sqrt{[M]/[E]}\) and \([M][L][t]^{-2} = [E]/[L]\) respectively.

Error Messages

All errors detected by DL_POLY_5 during run time initiate a call to the subroutine error, which prints an error message in the standard output file and terminates the program. All terminations of the program are global (i.e. every node of the parallel computer will be informed of the termination condition and stop executing).

In addition to terminal error messages, DL_POLY_5 will sometimes print warning messages. These indicate that the code has detected something that is unusual or inconsistent. The detection is non-fatal, but the user should make sure that the warning does represent a harmless condition.

Directory Structure

The entire DL_POLY_5 package is stored in a UNIX directory structure. The topmost directory is named dl_poly_5.nn, where nn is a generation number. Beneath this directory are several sub-directories named: manual, source, build, cmake, utils, execute, data, bench, java, and utility.

Briefly, the content of each sub-directory is as follows:

sub-directory	contents
manual	DL_POLY_5 main user manual and DL_POLY_5 Java GUI manual
source	primary subroutines for the DL_POLY_5 package
build	makefiles to assemble and compile DL_POLY_5 source
cmake	contains files needed for DL_POLY_5 cmake build system
utils	contains a series of scripts needed for testing
execute	the DL_POLY_5 run-time directory
data	example input and output files for DL_POLY_5
bench	large test cases suitable for benchmarking
java	directory of Java and FORTRAN routines for the Java GUI
utility	directory of routines donated by DL_POLY_5 users

A more detailed description of each sub-directory follows.

The source Sub-directory

In this sub-directory all the essential source code for DL_POLY_5, excluding the utility software is stored. In keeping with the ‘package’ concept of DL_POLY_5, it does not contain any complete programs; these are assembled at compile time using an appropriate makefile. The subroutines in this sub-directory are documented in Chapter Source Code.

The build Sub-directory

This sub-directory contains legacy makefiles for the creation (i.e. compilation and linking) of the DL_POLY_5 simulation program. The makefiles supplied select the appropriate subroutines from the source sub-directory and deposit the executable program in the execute directory. Building DL_POLY_5 by using these legacy makefiles is described in Section Compiling and Running.

The cmake Sub-directory

This sub-directory contains necessary scripts and information needed for DL_POLY_5 the CMake system. Building DL_POLY_5 with cmake is described in Section Compiling and Running.

The utils Sub-directory

This sub-directory contains a framework of scripts needed by DL_POLY_5 developers for testing purposes. The general user is welcome to look and learn from it. The scripts are the documentation themselves.

The execute Sub-directory

In the supplied version of DL_POLY_5, this sub-directory contains only a few macros for copying and storing data from and to the data sub-directory and for submitting programs for execution (see Appendix C). However, if the DL_POLY_5 program is assembled by using a legacy makefile, the executable will be placed in this sub-directory and could be used from here. Then output files from a job run in here will also appear here, so users may find it convenient to use this sub-directory as originally intended. (The experienced user is not at all required to use DL_POLY_5 this way however.)

The data Sub-directory

This sub-directory contains examples of input and output files for testing the released version of DL_POLY_5. The examples of input data are copied into the execute sub-directory when a program is being tested. The test cases are documented in Chapter Examples. Note that these are no longer within the distribution of any DL_POLY version but are downloaded when building with testing enabled in cmake.

The java Sub-directory

The DL_POLY_5 Java Graphical User Interface (GUI) is based on the Java® language developed by Sun®. The Java® source code for this GUI is to be found in this sub-directory. The source is complete and sufficient to create a working GUI, provided the user has installed the Java® Development Kit, (1.7 or above) which is available free from Sun® at http://java.sun.com/. The GUI, once compiled, may be executed on any machine where Java® is installed ¹¹⁸.

The utility Sub-directory

This sub-directory contains assorted routines donated by DL_POLY users. Potential users should note that these routines are unsupported and come without any guarantee or liability whatsoever. They should be regarded as potentially useful resources to be hacked into shape as needed by the user. Some of the various routines in this sub-directory are documented in the DL_POLY_Classic User Manual. Users who devise their own utilities are advised to store them in the utility sub-directory.

Obtaining the Source Code

To obtain a copy of DL_POLY_5 visit the DL_POLY GitLab website - https://gitlab.com/ccp5/dl-poly/, and follow instructions within i.e. the Building notes.

OS and Hardware Specific Ports

Note that no support is offered for these highly specific developments! However, the DL_POLY GitLab has plenty of notes on specific builds and offers the opportunity to submit requests, filed as Issues within GitLab.

Other Information

The DL_POLY website - http://www.ccp5.ac.uk/DL_POLY/, provides additional information in the form of

1. Access to all documentation (including licences)

2. Frequently asked questions

3. Bug reports

4. Access to the DL_Software portal.

Daresbury Laboratory also maintains a associated electronic mailing list, dl_poly_5_news, to which all registered DL_POLY_5 users are automatically subscribed. It is via this list that error reports and announcements of new versions are made. If you are a DL_POLY_5 user, but not on this list you may sign up by filling your details in the form - http://www.ccp5.ac.uk/DL_POLY/, and submitting it.