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_4(written by Ilian Todorov & Bill Smith) ^114,115. 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 ^{95,98,101,102} which works well simulations of up to 30,000 atoms on up to 100 processors. DL_POLY_4 is based on the Domain Decomposition (DD) strategy ^{73,81,95,98,114,115}, 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 to a DL_POLY_4 simulation with little effort. It should be apparent from these comments that DL_POLY_4 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_4 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_4 supports.

Molecular Systems

DL_POLY_4 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_4 force field includes the following features:

1. All common forms of non-bonded atom-atom (van der Waals) potentials

2. Atom-atom (and site-site) coulombic potentials

3. Metal-metal (local density dependent) potentials ^{20,34,35,77,108,111}

4. Tersoff (local density dependent) potentials (for hydro-carbons) ¹⁰⁹

5. Three-body valence angle and hydrogen bond potentials

6. Four-body inversion potentials

7. Ion core-shell polarasation

8. Tether potentials

9. Chemical bond potentials

10. Valence angle potentials

11. Dihedral angle (and improper dihedral angle) potentials

12. Inversion angle potentials

13. 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_4 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_4 Graphical User Interface (GUI) is the same one that also comes with DL_POLY_Classic, which is written in the Javaprogramming® 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_4 exclusively employs the Domain Decomposition parallelisation strategy ^73,81,95,98 (see Section: Parallelisation).

Molecular Dynamics Algorithms

DL_POLY_4 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 ⁶⁰

1. Langevin constant T,\(\underline{\underline{\mathbf{\sigma}}}\) algorithm ⁷⁵

2. Berendsen constant T,\(\underline{\underline{\mathbf{\sigma}}}\) algorithm ⁹

3. Nosé-Hoover constant T,\(\underline{\underline{\mathbf{\sigma}}}\) algorithm ⁴³

4. Martyna, Tuckerman and Klein (MTK) constant T,\(\underline{\underline{\mathbf{\sigma}}}\) algorithm ⁶⁰.

DL_POLY_Classic features incompatible or unavalable in DL_POLY_4

• 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

Programming Style

The programming style of DL_POLY_4 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_4 is written in free format FORTRAN90. In DL_POLY_4 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_4 exploits the full potential of the modularisation concept in FORTRAN90. Variables having in common description of certain feature or method in DL_POLY_4 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_4 exploits the dynamic array allocation features of FORTRAN90 to assign the necessary array dimensions.

Target Platforms

DL_POLY_4 is intended for distributed memory parallel computers.

Compilation of DL_POLY_4 in parallel mode requires only a FORTRAN90 compiler and Message Passing Interface (MPI) to handle communications. Compilation of DL_POLY_4 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_4 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_4 OUTPUT file, the print out of pressure is in units of katms (kilo-atmospheres) at all times. 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_4 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) 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_4 is used in a DPD mode (see Section Dissipative Particle Dynamics Thermostat and Appendix A) then the meaning of the molecular units is somewhat lost and it is only the interrelationship between units that is important (which can be exploited by the modeller)! The fundamental units for a DPD simulation are related those of mass \([M]\), length \([L]\) and energy \([E]\) - all irrespectively of the actually chosen energy units by the UNITS directive in the FIELD file. Therefore, the DPD unit of time is equivalent to \([L]\sqrt{[M]/[E]}\) while temperature (in the form \(k_{B}T\)) is defined as two-thirds of the kinetic energy of the system’s particles. Similarly, volume is in units of \([L]^{3}\) and pressure in \([E]/[L]^{3}\).

Error Messages

All errors detected by DL_POLY_4 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_4 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_4 package is stored in a UNIX directory structure. The topmost directory is named dl_poly_4.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_4 main user manual and DL_POLY_4 Java GUI manual
source	primary subroutines for the DL_POLY_4 package
build	makefiles to assemble and compile DL_POLY_4 source
cmake	contains files needed for DL_POLY_4 cmake build system
utils	contains a series of scripts needed for testing
execute	the DL_POLY_4 run-time directory
data	example input and output files for DL_POLY_4
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_4 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_4, excluding the utility software is stored. In keeping with the ‘package’ concept of DL_POLY_4, 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_4 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_4 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_4 the CMake system. Building DL_POLY_4 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_4 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_4, 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_4 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_4 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_4. 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 made available on-line at the DL_POLY FTP - ftp://ftp.dl.ac.uk/ccp5/DL_POLY/.

The bench Sub-directory

This directory contains examples of input and output data for DL_POLY_4 that are suitable for benchmarking DL_POLY_4 on large scale computers. These are described in Chapter Examples. Note that these are no longer within the distribution of any DL_POLY version but are made available on-line at the DL_POLY FTP - ftp://ftp.dl.ac.uk/ccp5/DL_POLY/.

The java Sub-directory

The DL_POLY_4 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_4 it is necessary to have internet connection. Log on to the DL_POLY website - http://www.ccp5.ac.uk/DL_POLY/, and follow the links to the DL_POLY_4 registration page, where you will firstly be shown the DL_POLY_4 academic software licence (see Appendix E), which details the terms and conditions under which the code will be supplied. By proceeding further with the registration and download process you are signalling your acceptance of the terms of this licence. Click the ‘Registration’ button to find the registration page, where you will be invited to enter your name, address and e-mail address. The code is supplied free of charge to academic users, but commercial users will be required to purchase a software licence.

Once the online registration has been completed, information on downloading the DL_POLY_4 source code will be sent by e-mail, so it is therefore essential to supply a correct e-mail address.

The data and bench subdirectories of DL_POLY_4 are not issued in the standard package, but can be downloaded directly from the FTP site (in the ccp5/DL_POLY/DL_POLY_4.0/ directory).

Note: Daresbury Laboratory is the sole centre for the distribution of and copies obtained from elsewhere will be regarded as illegal and will not be supported.

OS and Hardware Specific Ports

Note that no support is offered for these highly specific developments!

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_4_news, to which all registered DL_POLY_4 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_4 user, but not on this list you may request to be added by sending a mail message to `majordomo@dl.ac.uk`_ with the one-line message: \(subscribe~dl\_poly\_4\_news\).

The DL_Software Portal is a web based centre for all DL_POLY users to exchange comments and queries. You may access the forum through the DL_POLY website. A registration (and vetting) process is required before you can use the forum, but it is open, in principle, to everyone.