| 1 |
|
\documentclass[11pt]{article} |
| 2 |
|
\usepackage{amsmath} |
| 3 |
< |
\usepackage{amssymb} |
| 3 |
> |
\usepackage{amssymb} |
| 4 |
|
\usepackage{endfloat} |
| 5 |
|
\usepackage{listings} |
| 6 |
< |
\usepackage{palatino} |
| 6 |
> |
\usepackage{berkeley} |
| 7 |
|
\usepackage{graphicx} |
| 8 |
|
\usepackage[ref]{overcite} |
| 9 |
|
\usepackage{setspace} |
| 22 |
|
xleftmargin=0.5in, xrightmargin=0.5in,captionpos=b, % |
| 23 |
|
abovecaptionskip=0.5cm, belowcaptionskip=0.5cm} |
| 24 |
|
\renewcommand{\lstlistingname}{Scheme} |
| 25 |
< |
\title{{\sc oopse}: An Open Source Object-Oriented Parallel Simulation |
| 25 |
> |
\title{{\sc oopse}: An Object-Oriented Parallel Simulation |
| 26 |
|
Engine for Molecular Dynamics} |
| 27 |
|
|
| 28 |
|
\author{Matthew A. Meineke, Charles F. Vardeman II, Teng Lin,\\ |
| 31 |
|
University of Notre Dame\\ |
| 32 |
|
Notre Dame, Indiana 46556} |
| 33 |
|
|
| 34 |
< |
\date{\today} |
| 34 |
> |
\date{September 20, 2004} |
| 35 |
|
\maketitle |
| 36 |
|
|
| 37 |
|
\begin{abstract} |
| 38 |
< |
We detail the capabilities of a new open-source parallel simulation |
| 39 |
< |
progrm for MD ({\sc oopse}) that can work with atom types that are missing from other popular packages. In |
| 40 |
< |
particular, {\sc oopse} is capable of performing efficient orientational |
| 41 |
< |
dynamics on dipolar or rigid body systems, and it can handle simulations of metallic |
| 42 |
< |
systems using the embedded atom method ({\sc eam}). |
| 38 |
> |
{\sc oopse} is a new molecular dynamics simulation program which is |
| 39 |
> |
capable of efficiently integrating equations of motion for atom types |
| 40 |
> |
with orientational degrees of freedom (e.g. ``sticky'' atoms and point |
| 41 |
> |
dipoles). Transition metals can also be simulated using the embedded |
| 42 |
> |
atom method ({\sc eam}) potential included in the code. Parallel |
| 43 |
> |
simulations are carried out using the force-based decomposition |
| 44 |
> |
method. Simulations are specified using a very simple C-based |
| 45 |
> |
meta-data language. A number of advanced integrators are included, |
| 46 |
> |
and the basic integrator for orientational dynamics provides |
| 47 |
> |
substantial improvements over older quaternion-based schemes. |
| 48 |
|
\end{abstract} |
| 49 |
|
|
| 50 |
|
\section{\label{sec:intro}Introduction} |
| 51 |
|
|
| 52 |
< |
When choosing to simulate a chemical system with molecular dynamics, |
| 53 |
< |
there are a variety of options available. For simple systems, one |
| 54 |
< |
might consider writing one's own programming code. However, as systems |
| 55 |
< |
grow larger and more complex, building and maintaining code for the |
| 56 |
< |
simulations becomes a time consuming task. In such cases it is usually |
| 57 |
< |
more convenient for a researcher to turn to pre-existing simulation |
| 58 |
< |
packages. These packages, such as {\sc amber}\cite{pearlman:1995} and |
| 59 |
< |
{\sc charmm}\cite{Brooks83}, provide powerful tools for researchers to |
| 60 |
< |
conduct simulations of their systems without spending their time |
| 61 |
< |
developing a code base to conduct their research. This then frees them |
| 62 |
< |
to perhaps explore experimental analogues to their models. |
| 52 |
> |
There are a number of excellent molecular dynamics packages available |
| 53 |
> |
to the chemical physics |
| 54 |
> |
community.\cite{Brooks83,MacKerell98,pearlman:1995,Gromacs,Gromacs3,DL_POLY,Tinker,Paradyn,namd,macromodel} |
| 55 |
> |
All of these packages are stable, polished programs which solve many |
| 56 |
> |
problems of interest. Most are now capable of performing molecular |
| 57 |
> |
dynamics simulations on parallel computers. Some have source code |
| 58 |
> |
which is freely available to the entire scientific community. Few, |
| 59 |
> |
however, are capable of efficiently integrating the equations of |
| 60 |
> |
motion for atom types with orientational degrees of freedom |
| 61 |
> |
(e.g. point dipoles, and ``sticky'' atoms). And only one of the |
| 62 |
> |
programs referenced can handle transition metal force fields like the |
| 63 |
> |
Embedded Atom Method ({\sc eam}). The direction our research program |
| 64 |
> |
has taken us now involves the use of atoms with orientational degrees |
| 65 |
> |
of freedom as well as transition metals. Since these simulation |
| 66 |
> |
methods may be of some use to other researchers, we have decided to |
| 67 |
> |
release our program (and all related source code) to the scientific |
| 68 |
> |
community. |
| 69 |
|
|
| 70 |
< |
Despite their utility, problems with these packages arise when |
| 71 |
< |
researchers try to develop techniques or energetic models that the |
| 72 |
< |
code was not originally designed to simulate. Examples of techniques |
| 73 |
< |
and energetics not commonly implemented include; dipole-dipole |
| 74 |
< |
interactions, rigid body dynamics, and metallic potentials. When faced |
| 75 |
< |
with these obstacles, a researcher must either develop their own code |
| 76 |
< |
or license and extend one of the commercial packages. What we have |
| 77 |
< |
elected to do is develop a body of simulation code capable of |
| 78 |
< |
implementing the types of models upon which our research is based. |
| 70 |
> |
This paper communicates the algorithmic details of our program, which |
| 71 |
> |
we have been calling the Object-Oriented Parallel Simulation Engine |
| 72 |
> |
(i.e. {\sc oopse}). We have structured this paper to first discuss |
| 73 |
> |
the underlying concepts in this simulation package |
| 74 |
> |
(Sec. \ref{oopseSec:IOfiles}). The empirical energy functions |
| 75 |
> |
implemented are discussed in Sec.~\ref{oopseSec:empiricalEnergy}. |
| 76 |
> |
Sec.~\ref{oopseSec:mechanics} describes the various Molecular Dynamics |
| 77 |
> |
algorithms {\sc oopse} implements in the integration of Hamilton's |
| 78 |
> |
equations of motion. Program design considerations for parallel |
| 79 |
> |
computing are presented in |
| 80 |
> |
Sec.~\ref{oopseSec:parallelization}. Concluding remarks are presented |
| 81 |
> |
in Sec.~\ref{oopseSec:conclusion}. |
| 82 |
|
|
| 83 |
< |
In developing {\sc oopse}, we have adhered to the precepts of Open |
| 70 |
< |
Source development, and are releasing our source code with a |
| 71 |
< |
permissive license. It is our intent that by doing so, other |
| 72 |
< |
researchers might benefit from our work, and add their own |
| 73 |
< |
contributions to the package. The license under which {\sc oopse} is |
| 74 |
< |
distributed allows any researcher to download and modify the source |
| 75 |
< |
code for their own use. In this way further development of {\sc oopse} |
| 76 |
< |
is not limited to only the models of interest to ourselves, but also |
| 77 |
< |
those of the community of scientists who contribute back to the |
| 78 |
< |
project. |
| 83 |
> |
\section{\label{oopseSec:IOfiles}Concepts \& Files} |
| 84 |
|
|
| 85 |
< |
We have structured this paper to first discuss the empirical energy |
| 86 |
< |
functions that {\sc oopse } implements in |
| 87 |
< |
Sec.~\ref{oopseSec:empiricalEnergy}. Following that is a discussion of |
| 88 |
< |
the various input and output files associated with the package |
| 89 |
< |
(Sec.~\ref{oopseSec:IOfiles}). Sec.~\ref{oopseSec:mechanics} |
| 90 |
< |
elucidates the various Molecular Dynamics algorithms {\sc oopse} |
| 86 |
< |
implements in the integration of the Newtonian equations of |
| 87 |
< |
motion. Program design |
| 88 |
< |
considerations are presented in Sec.~\ref{oopseSec:design}. And |
| 89 |
< |
lastly, Sec.~\ref{oopseSec:conclusion} concludes the chapter. |
| 85 |
> |
A simulation in {\sc oopse} is built using a few fundamental |
| 86 |
> |
conceptual building blocks most of which are chemically intuitive. |
| 87 |
> |
The basic unit of a simulation is an {\tt atom}. The parameters |
| 88 |
> |
describing an {\tt atom} have been generalized to make it as flexible |
| 89 |
> |
as possible; this means that in addition to translational degrees of |
| 90 |
> |
freedom, {\tt Atoms} may also have {\it orientational} degrees of freedom. |
| 91 |
|
|
| 92 |
< |
\section{\label{oopseSec:IOfiles}Concepts \& Files} |
| 92 |
> |
The fundamental (static) properties of {\tt atoms} are defined by the |
| 93 |
> |
{\tt forceField} chosen for the simulation. The atomic properties |
| 94 |
> |
specified by a {\tt forceField} might include (but are not limited to) |
| 95 |
> |
charge, $\sigma$ and $\epsilon$ values for Lennard-Jones interactions, |
| 96 |
> |
the strength of the dipole moment ($\mu$), the mass, and the moments |
| 97 |
> |
of inertia. Other more complicated properties of atoms might also be |
| 98 |
> |
specified by the {\tt forceField}. |
| 99 |
|
|
| 100 |
< |
\subsection{{\sc bass} and Model Files} |
| 100 |
> |
{\tt Atoms} can be grouped together in many ways. A {\tt rigidBody} |
| 101 |
> |
contains atoms that exert no forces on one another and which move as a |
| 102 |
> |
single rigid unit. A {\tt cutoffGroup} may contain atoms which |
| 103 |
> |
function together as a (rigid {\it or} non-rigid) unit for potential |
| 104 |
> |
energy calculations, |
| 105 |
> |
\begin{equation} |
| 106 |
> |
V_{ab} = s(r_{ab}) \sum_{i \in a} \sum_{j \in b} V_{ij}(r_{ij}) |
| 107 |
> |
\end{equation} |
| 108 |
> |
Here, $a$ and $b$ are two {\tt cutoffGroups} containing multiple atoms |
| 109 |
> |
($a = \left\{i\right\}$ and $b = \left\{j\right\}$). $s(r_{ab})$ is a |
| 110 |
> |
generalized switching function which insures that the atoms in the two |
| 111 |
> |
{\tt cutoffGroups} are treated identically as the two groups enter or |
| 112 |
> |
leave an interaction region. |
| 113 |
|
|
| 114 |
< |
Every {\sc oopse} simulation begins with a Bizarre Atom Simulation |
| 115 |
< |
Syntax ({\sc bass}) file. {\sc bass} is a script syntax that is parsed |
| 116 |
< |
by {\sc oopse} at runtime. The {\sc bass} file allows for the user to |
| 117 |
< |
completely describe the system they wish to simulate, as well as tailor |
| 99 |
< |
{\sc oopse}'s behavior during the simulation. {\sc bass} files are |
| 100 |
< |
denoted with the extension |
| 101 |
< |
\texttt{.bass}, an example file is shown in |
| 102 |
< |
Scheme~\ref{sch:bassExample}. |
| 114 |
> |
{\tt Atoms} may also be grouped in more traditional ways into {\tt |
| 115 |
> |
bonds}, {\tt bends}, and {\tt torsions}. These groupings allow the |
| 116 |
> |
correct choice of interaction parameters for short-range interactions |
| 117 |
> |
to be chosen from the definitions in the {\tt forceField}. |
| 118 |
|
|
| 119 |
< |
\begin{lstlisting}[float,caption={[An example of a complete {\sc bass} file] An example showing a complete {\sc bass} file.},label={sch:bassExample}] |
| 119 |
> |
All of these groups of {\tt atoms} are brought together in the {\tt |
| 120 |
> |
molecule}, which is the fundamental structure for setting up and {\sc |
| 121 |
> |
oopse} simulation. {\tt Molecules} contain lists of {\tt atoms} |
| 122 |
> |
followed by listings of the other atomic groupings ({\tt bonds}, {\tt |
| 123 |
> |
bends}, {\tt torsions}, {\tt rigidBodies}, and {\tt cutoffGroups}) |
| 124 |
> |
which relate the atoms to one another. |
| 125 |
|
|
| 126 |
+ |
Simulations often involve heterogeneous collections of molecules. To |
| 127 |
+ |
specify a mixture of {\tt molecule} types, {\sc oopse} uses {\tt |
| 128 |
+ |
components}. Even simulations containing only one type of molecule |
| 129 |
+ |
must specify a single {\tt component}. |
| 130 |
+ |
|
| 131 |
+ |
Starting a simulation requires two types of information: {\it |
| 132 |
+ |
meta-data}, which describes the types of objects present in the |
| 133 |
+ |
simulation, and {\it configuration} information, which describes the |
| 134 |
+ |
initial state of these objects. The meta-data is given to {\sc oopse} |
| 135 |
+ |
using a C-based syntax that is parsed at the beginning of the |
| 136 |
+ |
simulation. Configuration information is specified using an extended |
| 137 |
+ |
XYZ file format. Both the meta-data and configuration file formats |
| 138 |
+ |
are described in the following sections. |
| 139 |
+ |
|
| 140 |
+ |
\subsection{Meta-data Files} |
| 141 |
+ |
|
| 142 |
+ |
{\sc oopse} uses a C-based script syntax to parse the meta-data files |
| 143 |
+ |
at run time. These files allow the user to completely describe the |
| 144 |
+ |
system they wish to simulate, as well as tailor {\sc oopse}'s behavior |
| 145 |
+ |
during the simulation. Meta-data files are typically denoted with the |
| 146 |
+ |
extension {\tt .md} (which can stand for Meta-Data or Molecular |
| 147 |
+ |
Dynamics or Molecule Definition depending on the user's mood). An |
| 148 |
+ |
example meta-data file is shown in Scheme~\ref{sch:mdExample}. |
| 149 |
+ |
|
| 150 |
+ |
\begin{lstlisting}[float,caption={[An example of a complete meta-data |
| 151 |
+ |
file] An example showing a complete meta-data |
| 152 |
+ |
file.},label={sch:mdExample}] |
| 153 |
+ |
|
| 154 |
|
molecule{ |
| 155 |
|
name = "Ar"; |
| 156 |
|
nAtoms = 1; |
| 166 |
|
nMol = 108; |
| 167 |
|
} |
| 168 |
|
|
| 169 |
< |
initialConfig = "./argon.init"; |
| 169 |
> |
initialConfig = "./argon.in"; |
| 170 |
|
|
| 171 |
|
forceField = "LJ"; |
| 172 |
|
ensemble = "NVE"; // specify the simulation ensemble |
| 177 |
|
|
| 178 |
|
\end{lstlisting} |
| 179 |
|
|
| 180 |
< |
Within the \texttt{.bass} file it is necessary to provide a complete |
| 180 |
> |
Within the meta-data file it is necessary to provide a complete |
| 181 |
|
description of the molecule before it is actually placed in the |
| 182 |
< |
simulation. The {\sc bass} syntax was originally developed with this |
| 183 |
< |
goal in mind, and allows for the specification of all the atoms in a |
| 184 |
< |
molecular prototype, as well as any bonds, bends, or torsions. These |
| 185 |
< |
descriptions can become lengthy for complex molecules, and it would be |
| 186 |
< |
inconvenient to duplicate the simulation at the beginning of each {\sc |
| 187 |
< |
bass} script. Addressing this issue {\sc bass} allows for the |
| 188 |
< |
inclusion of model files at the top of a \texttt{.bass} file. These |
| 189 |
< |
model files, denoted with the \texttt{.mdl} extension, allow the user |
| 190 |
< |
to describe a molecular prototype once, then simply include it into |
| 143 |
< |
each simulation containing that molecule. Returning to the example in |
| 144 |
< |
Scheme~\ref{sch:bassExample}, the \texttt{.mdl} file's contents would |
| 145 |
< |
be Scheme~\ref{sch:mdlExample}, and the new \texttt{.bass} file would |
| 146 |
< |
become Scheme~\ref{sch:bassExPrime}. |
| 182 |
> |
simulation. {\sc oopse}'s meta-data syntax was originally developed |
| 183 |
> |
with this goal in mind, and allows for the use of {\it include files} |
| 184 |
> |
to specify all atoms in a molecular prototype, as well as any bonds, |
| 185 |
> |
bends, or torsions. Include files allow the user to describe a |
| 186 |
> |
molecular prototype once, then simply include it into each simulation |
| 187 |
> |
containing that molecule. Returning to the example in |
| 188 |
> |
Scheme~\ref{sch:mdExample}, the include file's contents would be |
| 189 |
> |
Scheme~\ref{sch:mdIncludeExample}, and the new meta-data file would |
| 190 |
> |
become Scheme~\ref{sch:mdExPrime}. |
| 191 |
|
|
| 192 |
< |
\begin{lstlisting}[float,caption={An example \texttt{.mdl} file.},label={sch:mdlExample}] |
| 192 |
> |
\begin{lstlisting}[float,caption={An example molecule definition in an |
| 193 |
> |
include file.},label={sch:mdIncludeExample}] |
| 194 |
|
|
| 195 |
|
molecule{ |
| 196 |
|
name = "Ar"; |
| 203 |
|
|
| 204 |
|
\end{lstlisting} |
| 205 |
|
|
| 206 |
< |
\begin{lstlisting}[float,caption={Revised {\sc bass} example.},label={sch:bassExPrime}] |
| 206 |
> |
\begin{lstlisting}[float,caption={Revised meta-data example.},label={sch:mdExPrime}] |
| 207 |
|
|
| 208 |
< |
#include "argon.mdl" |
| 208 |
> |
#include "argon.md" |
| 209 |
|
|
| 210 |
|
nComponents = 1; |
| 211 |
|
component{ |
| 213 |
|
nMol = 108; |
| 214 |
|
} |
| 215 |
|
|
| 216 |
< |
initialConfig = "./argon.init"; |
| 216 |
> |
initialConfig = "./argon.in"; |
| 217 |
|
|
| 218 |
|
forceField = "LJ"; |
| 219 |
|
ensemble = "NVE"; |
| 224 |
|
|
| 225 |
|
\end{lstlisting} |
| 226 |
|
|
| 227 |
< |
\subsection{\label{oopseSec:atomsMolecules}Atoms, Molecules and Rigid Bodies} |
| 227 |
> |
\subsection{\label{oopseSec:atomsMolecules}Atoms, Molecules, and other |
| 228 |
> |
ways of grouping atoms} |
| 229 |
|
|
| 230 |
< |
The basic unit of an {\sc oopse} simulation is the atom. The |
| 231 |
< |
parameters describing the atom are generalized to make the atom as |
| 232 |
< |
flexible a representation as possible. They may represent specific |
| 233 |
< |
atoms of an element, or be used for collections of atoms such as |
| 234 |
< |
methyl and carbonyl groups. The atoms are also capable of having |
| 235 |
< |
directional components associated with them (\emph{e.g.}~permanent |
| 236 |
< |
dipoles). Charges, permanent dipoles, and Lennard-Jones parameters for |
| 237 |
< |
a given atom type are set in the force field parameter files. |
| 238 |
< |
|
| 239 |
< |
Atoms can be collected into secondary structures such as rigid bodies |
| 240 |
< |
or molecules. The molecule is a way for {\sc oopse} to keep track of |
| 241 |
< |
the atoms in a simulation in logical manner. Molecular units store the |
| 196 |
< |
identities of all the atoms and rigid bodies associated with |
| 197 |
< |
themselves, and are responsible for the evaluation of their own |
| 198 |
< |
internal interactions (\emph{i.e.}~bonds, bends, and torsions). Scheme |
| 199 |
< |
\ref{sch:mdlExample} shows how one creates a molecule in a ``model'' or |
| 200 |
< |
\texttt{.mdl} file. The position of the atoms given in the |
| 201 |
< |
declaration are relative to the origin of the molecule, and is used |
| 202 |
< |
when creating a system containing the molecule. |
| 230 |
> |
As mentioned above, the fundamental unit for an {\sc oopse} simulation |
| 231 |
> |
is the {\tt atom}. Atoms can be collected into secondary structures |
| 232 |
> |
such as {\tt rigidBodies}, {\tt cutoffGroups}, or {\tt molecules}. The |
| 233 |
> |
{\tt molecule} is a way for {\sc oopse} to keep track of the atoms in |
| 234 |
> |
a simulation in logical manner. Molecular units store the identities |
| 235 |
> |
of all the atoms and rigid bodies associated with themselves, and they |
| 236 |
> |
are responsible for the evaluation of their own internal interactions |
| 237 |
> |
(\emph{i.e.}~bonds, bends, and torsions). Scheme |
| 238 |
> |
\ref{sch:mdIncludeExample} shows how one creates a molecule in an |
| 239 |
> |
included meta-data file. The positions of the atoms given in the |
| 240 |
> |
declaration are relative to the origin of the molecule, and the origin |
| 241 |
> |
is used when creating a system containing the molecule. |
| 242 |
|
|
| 243 |
< |
As stated previously, one of the features that sets {\sc oopse} apart |
| 244 |
< |
from most of the current molecular simulation packages is the ability |
| 245 |
< |
to handle rigid body dynamics. Rigid bodies are non-spherical |
| 246 |
< |
particles or collections of particles that have a constant internal |
| 243 |
> |
One of the features that sets {\sc oopse} apart from most of the |
| 244 |
> |
current molecular simulation packages is the ability to handle rigid |
| 245 |
> |
body dynamics. Rigid bodies are non-spherical particles or collections |
| 246 |
> |
of particles (e.g. $\mbox{C}_{60}$) that have a constant internal |
| 247 |
|
potential and move collectively.\cite{Goldstein01} They are not |
| 248 |
|
included in most simulation packages because of the algorithmic |
| 249 |
< |
complexity involved in propagating orientational degrees of |
| 250 |
< |
freedom. Until recently, integrators which propagate orientational |
| 251 |
< |
motion have had energy conservation problems when compared to those available for translational |
| 252 |
< |
motion. |
| 249 |
> |
complexity involved in propagating orientational degrees of freedom. |
| 250 |
> |
Integrators which propagate orientational motion with an acceptable |
| 251 |
> |
level of energy conservation for molecular dynamics are relatively |
| 252 |
> |
new inventions. |
| 253 |
|
|
| 254 |
|
Moving a rigid body involves determination of both the force and |
| 255 |
|
torque applied by the surroundings, which directly affect the |
| 259 |
|
the rigid body is simply the sum of these external forces. |
| 260 |
|
Accumulation of the total torque on the rigid body is more complex |
| 261 |
|
than the force because the torque is applied to the center of mass of |
| 262 |
< |
the rigid body. The torque on rigid body $i$ is |
| 262 |
> |
the rigid body. The space-fixed torque on rigid body $i$ is |
| 263 |
|
\begin{equation} |
| 264 |
|
\boldsymbol{\tau}_i= |
| 265 |
|
\sum_{a}\biggl[(\mathbf{r}_{ia}-\mathbf{r}_i)\times \mathbf{f}_{ia} |
| 281 |
|
$\psi$.\cite{Goldstein01} In order to avoid numerical instabilities |
| 282 |
|
inherent in using the Euler angles, the four parameter ``quaternion'' |
| 283 |
|
scheme is often used. The elements of $\mathsf{A}$ can be expressed as |
| 284 |
< |
arithmetic operations involving the four quaternions ($q_0, q_1, q_2,$ |
| 285 |
< |
and $q_3$).\cite{allen87:csl} Use of quaternions also leads to |
| 284 |
> |
arithmetic operations involving the four quaternions ($q_w, q_x, q_y,$ |
| 285 |
> |
and $q_z$).\cite{allen87:csl} Use of quaternions also leads to |
| 286 |
|
performance enhancements, particularly for very small |
| 287 |
|
systems.\cite{Evans77} |
| 288 |
|
|
| 289 |
< |
{\sc oopse} utilizes a relatively new scheme that propagates the |
| 290 |
< |
entire nine parameter rotation matrix. Further discussion |
| 291 |
< |
on this choice can be found in Sec.~\ref{oopseSec:integrate}. An example |
| 292 |
< |
definition of a rigid body can be seen in Scheme |
| 289 |
> |
Rather than use one of the previously stated methods, {\sc oopse} |
| 290 |
> |
utilizes a relatively new scheme that propagates the entire nine |
| 291 |
> |
parameter rotation matrix. Further discussion on this choice can be |
| 292 |
> |
found in Sec.~\ref{oopseSec:integrate}. An example definition of a |
| 293 |
> |
rigid body can be seen in Scheme |
| 294 |
|
\ref{sch:rigidBody}. |
| 295 |
|
|
| 296 |
< |
\begin{lstlisting}[float,caption={[Defining rigid bodies]A sample definition of a molecule containing a rigid body},label={sch:rigidBody}] |
| 296 |
> |
\begin{lstlisting}[float,caption={[Defining rigid bodies]A sample |
| 297 |
> |
definition of a molecule containing a rigid body and a cutoff |
| 298 |
> |
group},label={sch:rigidBody}] |
| 299 |
|
molecule{ |
| 300 |
|
name = "TIP3P"; |
| 301 |
|
nAtoms = 3; |
| 317 |
|
nMembers = 3; |
| 318 |
|
members(0, 1, 2); |
| 319 |
|
} |
| 320 |
+ |
|
| 321 |
+ |
nCutoffGroups = 1; |
| 322 |
+ |
cutoffGroup[0]{ |
| 323 |
+ |
nMembers = 3; |
| 324 |
+ |
members(0, 1, 2); |
| 325 |
+ |
} |
| 326 |
|
} |
| 327 |
|
\end{lstlisting} |
| 328 |
|
|
| 329 |
< |
\subsection{\label{sec:miscConcepts}Putting a Script Together} |
| 329 |
> |
\subsection{\label{sec:miscConcepts}Creating a Metadata File} |
| 330 |
|
|
| 331 |
< |
The actual creation of a {\sc bass} script requires several key components. The first part of the script needs to be the declaration of all of the molecule prototypes used in the simulation. This is typically done through the inclusion of {\tt .mdl} files. Only the molecules actually present in the simulation need to be declared, however {\sc bass} allows for the declaration of more molecules than are needed. This gives the user the ability to build up a library of commonly used molecules into a single {\tt .mdl} file. |
| 331 |
> |
The actual creation of a metadata file requires several key |
| 332 |
> |
components. The first part of the file needs to be the declaration of |
| 333 |
> |
all of the molecule prototypes used in the simulation. This is |
| 334 |
> |
typically done through included meta-data files. Only the molecules |
| 335 |
> |
actually present in the simulation need to be declared; however, {\sc |
| 336 |
> |
oopse} allows for the declaration of more molecules than are |
| 337 |
> |
needed. This gives the user the ability to build up a library of |
| 338 |
> |
commonly used molecules into a single include file. |
| 339 |
|
|
| 340 |
< |
Once all prototypes are declared, the ordering of the rest of the script is less stringent. Typically, the next to follow the molecular prototypes are the component statements. These statements specify which molecules are present within the simulation. The number of components must first be declared before the first component block statement (an example is seen in Sch.~\ref{sch:bassExPrime}). The component blocks tell {\sc oopse} the number of molecules that will be in the simulation, and the order in which the components blocks are declared sets the ordering of the real atoms within the simulation as well as in the output files. |
| 340 |
> |
Once all prototypes are declared, the ordering of the rest of the |
| 341 |
> |
script is less stringent. The molecular composition of the simulation |
| 342 |
> |
is specified with {\tt component} statements. Each different type of |
| 343 |
> |
molecule present in the simulation is considered a separate |
| 344 |
> |
component. The number of components must be declared before the first |
| 345 |
> |
component block statement (an example is shown in |
| 346 |
> |
Sch.~\ref{sch:mdExPrime}). The component blocks tell {\sc oopse} the |
| 347 |
> |
number of molecules that will be in the simulation, and the order in |
| 348 |
> |
which the components blocks are declared sets the ordering of the real |
| 349 |
> |
atoms in the configuration file as well as in the output files. The |
| 350 |
> |
remainder of the script then sets the various simulation parameters |
| 351 |
> |
for the system of interest. |
| 352 |
|
|
| 353 |
< |
The remainder of the script then sets the various simulation parameters for the system of interest. The required set of parameters that must be present in all simulations is given in Table~\ref{table:reqParams}. The {\tt ensemble} statement is responsible for selecting the integration method used for the calculation of the equations of motion. An in depth discussion of the various methods available in {\sc oopse} can be found in Sec.~\ref{oopseSec:mechanics}. The {\tt forceField} statement is important for the selection of which forces will be used in the course of the simulation. {\sc oopse} supports several force fields, as outlined in Sec.~\ref{oopseSec:empericalEnergy}. The force fields are interchangeable between simulations, with the only requirement being that all atoms needed by the simulation are defined within the selected force field. The time step between force evaluations is set with the {\tt dt} parameter, and {\tt runTime} will set the time length of the simulation. Note, that {\tt runTime} is an absolute time, meaning if the simulation is started at t = 10.0~ns with a {\tt runTime} of 25.0~ns, the simulation will only run for an additional 15.0~ns. The final required parameter, is the {\tt initialConfig} statement. This will set the initial coordinates for the system, as well as the initial time if the {\tt useInitalTime = true;} flag is given. The format of the file specified in {\tt initialConfig}, is given in Sec.~\ref{oopseSec:coordFiles}. Additional parameters are summarized in Table~\ref{table:genParams}. |
| 353 |
> |
The required set of parameters that must be present in all simulations |
| 354 |
> |
is given in Table~\ref{table:reqParams}. Since the user can use {\sc |
| 355 |
> |
oopse} to perform energy minimizations as well as molecular dynamics |
| 356 |
> |
simulations, one of the {\tt minimizer} or {\tt ensemble} keywords |
| 357 |
> |
must be present. The {\tt ensemble} keyword is responsible for |
| 358 |
> |
selecting the integration method used for the calculation of the |
| 359 |
> |
equations of motion. An in depth discussion of the various methods |
| 360 |
> |
available in {\sc oopse} can be found in |
| 361 |
> |
Sec.~\ref{oopseSec:mechanics}. The {\tt minimizer} keyword selects |
| 362 |
> |
which minimization method to use, and more details on the choices of |
| 363 |
> |
minimizer parameters can be found in |
| 364 |
> |
Sec.~\ref{oopseSec:minimizer}. The {\tt forceField} statement is |
| 365 |
> |
important for the selection of which forces will be used in the course |
| 366 |
> |
of the simulation. {\sc oopse} supports several force fields, as |
| 367 |
> |
outlined in Sec.~\ref{oopseSec:empiricalEnergy}. The force fields are |
| 368 |
> |
interchangeable between simulations, with the only requirement being |
| 369 |
> |
that all atoms needed by the simulation are defined within the |
| 370 |
> |
selected force field. |
| 371 |
|
|
| 372 |
+ |
For molecular dynamics simulations, the time step between force |
| 373 |
+ |
evaluations is set with the {\tt dt} parameter, and {\tt runTime} will |
| 374 |
+ |
set the time length of the simulation. Note, that {\tt runTime} is an |
| 375 |
+ |
absolute time, meaning if the simulation is started at t = 10.0~ns |
| 376 |
+ |
with a {\tt runTime} of 25.0~ns, the simulation will only run for an |
| 377 |
+ |
additional 15.0~ns. |
| 378 |
+ |
|
| 379 |
+ |
For energy minimizations, it is not necessary to specify {\tt dt} or |
| 380 |
+ |
{\tt runTime}. |
| 381 |
+ |
|
| 382 |
+ |
The final required parameter is the {\tt initialConfig} |
| 383 |
+ |
statement. This will set the initial coordinates for the system, as |
| 384 |
+ |
well as the initial time if the {\tt useInitalTime} flag is set to |
| 385 |
+ |
{\tt true}. The format of the file specified in {\tt initialConfig}, |
| 386 |
+ |
is given in Sec.~\ref{oopseSec:coordFiles}. Additional parameters are |
| 387 |
+ |
summarized in Table~\ref{table:genParams}. |
| 388 |
+ |
|
| 389 |
+ |
It is important to note the fundamental units in all files which are |
| 390 |
+ |
read and written by {\sc oopse}. Energies are in $\mbox{kcal |
| 391 |
+ |
mol}^{-1}$, distances are in $\mbox{\AA}$, times are in $\mbox{fs}$, |
| 392 |
+ |
translational velocities are in $\mbox{\AA~fs}^{-1}$, and masses are |
| 393 |
+ |
in $\mbox{amu}$. Orientational degrees of freedom are described using |
| 394 |
+ |
quaternions (unitless, but $q_w^2 + q_x^2 + q_y^2 + q_z^2 = 1$), |
| 395 |
+ |
body-fixed angular momenta ($\mbox{amu \AA}^{2} \mbox{radians |
| 396 |
+ |
fs}^{-1}$), and body-fixed moments of inertia ($\mbox{amu \AA}^{2}$). |
| 397 |
+ |
|
| 398 |
|
\begin{table} |
| 399 |
< |
\caption{The Global Keywords: Required Parameters} |
| 399 |
> |
\caption{Meta-data Keywords: Required Parameters} |
| 400 |
|
\label{table:reqParams} |
| 401 |
|
\begin{center} |
| 402 |
|
% Note when adding or removing columns, the \hsize numbers must add up to the total number |
| 409 |
|
|
| 410 |
|
{\bf keyword} & {\bf units} & {\bf use} & {\bf remarks} \\ \hline |
| 411 |
|
|
| 412 |
< |
{\tt forceField} & string & Sets the force field. & Possible force fields are "DUFF", "LJ", and "EAM". \\ |
| 304 |
< |
{\tt ensemble} & string & Sets the ensemble. & Possible ensembles are "NVE", "NVT", "NPTi", "NPTf", and "NPTxyz".\\ |
| 305 |
< |
{\tt dt} & fs & Sets the time step. & Selection of {\tt dt} should be small enough to sample the fastest motion of the simulation. \\ |
| 412 |
> |
{\tt forceField} & string & Sets the force field. & Possible force fields are DUFF, LJ, and EAM. \\ |
| 413 |
|
{\tt nComponents} & integer & Sets the number of components. & Needs to appear before the first {\tt Component} block. \\ |
| 414 |
|
{\tt initialConfig} & string & Sets the file containing the initial configuration. & Can point to any file containing the configuration in the correct order. \\ |
| 415 |
< |
{\tt runTime} & fs & Sets the time at which the simulation should end. & This is an absolute time, and will end the simulation when the current time meets or exceeds the {\tt runTime}. \\ |
| 415 |
> |
{\tt minimizer}& string & Chooses a minimizer & Possible minimizers |
| 416 |
> |
are SD and CG. Either {\tt ensemble} or {\tt minimizer} must be specified. \\ |
| 417 |
> |
{\tt ensemble} & string & Sets the ensemble. & Possible ensembles are |
| 418 |
> |
NVE, NVT, NPTi, NPTf, and NPTxyz. Either {\tt ensemble} |
| 419 |
> |
or {\tt minimizer} must be specified. \\ |
| 420 |
> |
{\tt dt} & fs & Sets the time step. & Selection of {\tt dt} should be |
| 421 |
> |
small enough to sample the fastest motion of the simulation. ({\tt |
| 422 |
> |
dt} is required for molecular dynamics simulations)\\ |
| 423 |
> |
{\tt runTime} & fs & Sets the time at which the simulation should |
| 424 |
> |
end. & This is an absolute time, and will end the simulation when the |
| 425 |
> |
current time meets or exceeds the {\tt runTime}. ({\tt runTime} is |
| 426 |
> |
required for molecular dynamics simulations)\\ |
| 427 |
|
|
| 310 |
– |
|
| 428 |
|
\end{tabularx} |
| 429 |
|
\end{center} |
| 430 |
|
\end{table} |
| 431 |
|
|
| 432 |
|
\begin{table} |
| 433 |
< |
\caption{The Global Keywords: General Parameters} |
| 433 |
> |
\caption{Meta-data Keywords: General Parameters} |
| 434 |
|
\label{table:genParams} |
| 435 |
|
\begin{center} |
| 436 |
|
% Note when adding or removing columns, the \hsize numbers must add up to the total number |
| 443 |
|
|
| 444 |
|
{\bf keyword} & {\bf units} & {\bf use} & {\bf remarks} \\ \hline |
| 445 |
|
|
| 446 |
< |
{\tt finalConfig} & string & Option to set the name of the final output file. & Useful when stringing simulations together. Defaults to the {\tt .bass} file with an {\tt .eor} extension. \\ |
| 447 |
< |
{\tt useInitialTime} & logical & Sets whether the initial time is taken from the {\tt .init} file. & Useful when recovering a simulation from a crashed processor. Default is false. \\ |
| 448 |
< |
{\tt sampleTime} & fs & Sets the frequency at which the {\tt .dump} file is written. & Default sets the frequency to the {\tt runTime}. \\ |
| 449 |
< |
{\tt statusTime} & fs & Sets the frequency at which the {\tt .stat} file is written. & Defaults sets the frequency to the {\tt sampleTime}. \\ |
| 450 |
< |
{\tt LJrcut} & $\mbox{\AA}$ & Manually sets the Lennard-Jones cutoff. & Defaults to $2.5\sigma_L$, where $\sigma_L$ is the largest LJ $\sigma$ in the simulation. \\ |
| 451 |
< |
{\tt electrostaticCutoffRadius}& & & \\ |
| 452 |
< |
& $\mbox{\AA}$ & Manually sets the cutoff used by the electrostatic potentials. & Defaults to $15\mbox{\AA}$ \\ |
| 453 |
< |
{\tt electrostaticSkinThickness} & & & \\ |
| 454 |
< |
& $\mbox{\AA}$ & Manually sets the skin thickness for the electrostatic switching function. & Defaults to 5~\% of the {\tt electrostaticSkinThickness}. \\ |
| 455 |
< |
{\tt useReactionField} & logical & Turns the reaction field correction on/off. & Default is "false". \\ |
| 446 |
> |
{\tt finalConfig} & string & Sets the name of the final |
| 447 |
> |
output file. & Useful when stringing simulations together. Defaults to |
| 448 |
> |
the root name of the initial meta-data file but with an {\tt .eor} |
| 449 |
> |
extension. \\ |
| 450 |
> |
{\tt useInitialTime} & logical & Sets whether the initial time is taken from the {\tt .in} file. & Useful when recovering a simulation from a crashed processor. Default is false. \\ |
| 451 |
> |
{\tt sampleTime} & fs & Sets the frequency at which the {\tt .dump} |
| 452 |
> |
file is written. & The default is equal to the {\tt runTime}. \\ |
| 453 |
> |
{\tt statusTime} & fs & Sets the frequency at which the {\tt .stat} |
| 454 |
> |
file is written. & The default is equal to the {\tt sampleTime}. \\ |
| 455 |
> |
{\tt cutoffRadius} & $\mbox{\AA}$ & Manually sets the cutoff radius & |
| 456 |
> |
Defaults to $15\mbox{\AA}$ for systems containing charges or dipoles or to $2.5 |
| 457 |
> |
\sigma_{L}$, where $\sigma_{L}$ is the largest LJ $\sigma$ in the |
| 458 |
> |
simulation. \\ |
| 459 |
> |
{\tt switchingRadius} & $\mbox{\AA}$ & Manually sets the inner radius for the switching function. & Defaults to 95~\% of the {\tt cutoffRadius}. \\ |
| 460 |
> |
{\tt useReactionField} & logical & Turns the reaction field correction on/off. & Default is false. \\ |
| 461 |
|
{\tt dielectric} & unitless & Sets the dielectric constant for reaction field. & If {\tt useReactionField} is true, then {\tt dielectric} must be set. \\ |
| 462 |
|
{\tt usePeriodicBoundaryConditions} & & & \\ |
| 463 |
< |
& logical & Turns periodic boundary conditions on/off. & Default is "true". \\ |
| 464 |
< |
{\tt seed } & integer & Sets the seed value for the random number generator. & The seed needs to be at least 9 digits long. The default is to take the seed from the CPU clock. |
| 463 |
> |
& logical & Turns periodic boundary conditions on/off. & Default is true. \\ |
| 464 |
> |
{\tt seed } & integer & Sets the seed value for the random number |
| 465 |
> |
generator. & The seed needs to be at least 9 digits long. The default |
| 466 |
> |
is to take the seed from the CPU clock. \\ |
| 467 |
> |
{\tt forceFieldVariant} & string & Sets the name of the variant of the |
| 468 |
> |
force field. & {\sc eam} has three variants: {\tt u3}, {\tt u6}, and |
| 469 |
> |
{\tt VC}. |
| 470 |
|
|
| 471 |
|
\end{tabularx} |
| 472 |
|
\end{center} |
| 473 |
|
\end{table} |
| 474 |
|
|
| 475 |
|
|
| 349 |
– |
|
| 476 |
|
\subsection{\label{oopseSec:coordFiles}Coordinate Files} |
| 477 |
|
|
| 478 |
|
The standard format for storage of a systems coordinates is a modified |
| 479 |
|
xyz-file syntax, the exact details of which can be seen in |
| 480 |
|
Scheme~\ref{sch:dumpFormat}. As all bonding and molecular information |
| 481 |
< |
is stored in the \texttt{.bass} and \texttt{.mdl} files, the |
| 482 |
< |
coordinate files are simply the complete set of coordinates for each |
| 483 |
< |
atom at a given simulation time. One important note, although the |
| 484 |
< |
simulation propagates the complete rotation matrix, directional |
| 485 |
< |
entities are written out using quanternions, to save space in the |
| 486 |
< |
output files. |
| 481 |
> |
is stored in the meta-data files, the coordinate files contain only |
| 482 |
> |
the coordinates of the objects which move independently during the |
| 483 |
> |
simulation. It is important to note that {\it not all atoms} are |
| 484 |
> |
capable of independent motion. Atoms which are part of rigid bodies |
| 485 |
> |
are not ``integrable objects'' in the equations of motion; the rigid |
| 486 |
> |
bodies themselves are the integrable objects. Therefore, the |
| 487 |
> |
coordinate file contains coordinates of all the {\tt |
| 488 |
> |
integrableObjects} in the system. For systems without rigid bodies, |
| 489 |
> |
this is simply the coordinates of all the atoms. |
| 490 |
|
|
| 491 |
< |
\begin{lstlisting}[float,caption={[The format of the coordinate files]Shows the format of the coordinate files. The fist line is the number of atoms. The second line begins with the time stamp followed by the three $\mathsf{H}$ column vectors. It is important to note, that for extended system ensembles, additional information pertinent to the integrators may be stored on this line as well. The next lines are the atomic coordinates for all atoms in the system. First is the name followed by position, velocity, quanternions, and lastly, body fixed angular momentum.},label=sch:dumpFormat] |
| 491 |
> |
It is important to note that although the simulation propagates the |
| 492 |
> |
complete rotation matrix, directional entities are written out using |
| 493 |
> |
quaternions to save space in the output files. All objects (atoms, |
| 494 |
> |
orientational atoms, and rigid bodies) are given quaternions and |
| 495 |
> |
angular momenta in coordinate files which are output by OOPSE, but it |
| 496 |
> |
is not necessary for the user to specify the quaternions or angular |
| 497 |
> |
momenta for atoms without orientational degrees of freedom. |
| 498 |
|
|
| 499 |
< |
nAtoms |
| 499 |
> |
\begin{lstlisting}[float,caption={[The format of the coordinate |
| 500 |
> |
files] An example of the format of the coordinate files. The fist line |
| 501 |
> |
is the number of {\tt integrableObjects} (freely-moving atoms and |
| 502 |
> |
rigid bodies). The second line begins with the time stamp followed by |
| 503 |
> |
the three $\mathsf{H}$ column vectors. It is important to note that |
| 504 |
> |
for extended system ensembles, additional information pertinent to the |
| 505 |
> |
integrators may be stored on this line as well. The next lines are the |
| 506 |
> |
coordinates for all integrable objects in the system. The name of the |
| 507 |
> |
integrable object is followed by position, velocity, quaternions, and |
| 508 |
> |
lastly, body fixed angular momentum.},label=sch:dumpFormat] |
| 509 |
> |
|
| 510 |
> |
nIntegrable |
| 511 |
|
time; Hxx Hyx Hzx; Hxy Hyy Hzy; Hxz Hyz Hzz; |
| 512 |
< |
Name1 x y z vx vy vz q0 q1 q2 q3 jx jy jz |
| 513 |
< |
Name2 x y z vx vy vz q0 q1 q2 q3 jx jy jz |
| 512 |
> |
Name1 x y z vx vy vz qw qx qy qz jx jy jz |
| 513 |
> |
Name2 x y z vx vy vz qw qx qy qz jx jy jz |
| 514 |
|
etc... |
| 515 |
|
|
| 516 |
|
\end{lstlisting} |
| 517 |
|
|
| 518 |
+ |
The {\tt name} field for atoms is simply the atom type as specified in |
| 519 |
+ |
the meta-data file. The {\tt name} field for a rigid body is |
| 520 |
+ |
specified as {\tt MOLTYPE\_RB\_N}, to specify that this is {\tt |
| 521 |
+ |
rigidBody} N in a molecule of type MOLTYPE. In simulations with rigid |
| 522 |
+ |
body models of water, a sample coordinate line might be: |
| 523 |
|
|
| 524 |
< |
There are three major files used by {\sc oopse} written in the |
| 525 |
< |
coordinate format, they are as follows: the initialization file |
| 526 |
< |
(\texttt{.init}), the simulation trajectory file (\texttt{.dump}), and |
| 376 |
< |
the final coordinates of the simulation (\texttt{.eor}). The initialization file is |
| 377 |
< |
necessary for {\sc oopse} to start the simulation with the proper |
| 378 |
< |
coordinates, and is generated before the simulation run. The |
| 379 |
< |
trajectory file is created at the beginning of the simulation, and is |
| 380 |
< |
used to store snapshots of the simulation at regular intervals. The |
| 381 |
< |
first frame is a duplication of the |
| 382 |
< |
\texttt{.init} file, and each subsequent frame is appended to the file |
| 383 |
< |
at an interval specified in the \texttt{.bass} file with the |
| 384 |
< |
\texttt{sampleTime} flag. The final coordinate file is the end of run file. The |
| 385 |
< |
\texttt{.eor} file stores the final configuration of the system for a |
| 386 |
< |
given simulation. The file is updated at the same time as the |
| 387 |
< |
\texttt{.dump} file, however, it only contains the most recent |
| 388 |
< |
frame. In this way, an \texttt{.eor} file may be used as the |
| 389 |
< |
initialization file to a second simulation in order to continue a |
| 390 |
< |
simulation or recover one from a processor that has crashed during the |
| 391 |
< |
course of the run. |
| 524 |
> |
\begin{tt} |
| 525 |
> |
TIP3P\_RB\_0 x y z vx vy vz qw qx qy qz jx jy jz |
| 526 |
> |
\end{tt} |
| 527 |
|
|
| 528 |
< |
\subsection{\label{oopseSec:initCoords}Generation of Initial Coordinates} |
| 528 |
> |
which tells the program that the rigid body representing a TIP3P |
| 529 |
> |
molecule (rigid body \# 0) is listed on that line. |
| 530 |
|
|
| 531 |
< |
As was stated in Sec.~\ref{oopseSec:coordFiles}, an initialization |
| 532 |
< |
file is needed to provide the starting coordinates for a |
| 533 |
< |
simulation. Several helper programs are provided with {\sc oopse} to illustrate possible build routes. However, as each simulation is different, system creation is left to the end user. The {\tt .init} file must list the atoms in the correct order or {\sc oopse} will give an atom mismatch error. |
| 531 |
> |
There are three files used by {\sc oopse} which are written in the |
| 532 |
> |
coordinate format. They are: the initial coordinate file |
| 533 |
> |
(\texttt{.in}), the simulation trajectory file (\texttt{.dump}), and |
| 534 |
> |
the final coordinates or ``end-of-run'' for the simulation |
| 535 |
> |
(\texttt{.eor}). The initial coordinate file is necessary for {\sc |
| 536 |
> |
oopse} to start the simulation with the proper coordinates, and this |
| 537 |
> |
file must be generated by the user before the simulation run. The |
| 538 |
> |
trajectory (or ``dump'') file is updated during simulation and is used |
| 539 |
> |
to store snapshots of the coordinates at regular intervals. The first |
| 540 |
> |
frame is a duplication of the |
| 541 |
> |
\texttt{.in} file, and each subsequent frame is appended to the file |
| 542 |
> |
at an interval specified in the meta-data file with the |
| 543 |
> |
\texttt{sampleTime} flag. The final coordinate file is the |
| 544 |
> |
``end-of-run'' file. The \texttt{.eor} file stores the final |
| 545 |
> |
configuration of the system for a given simulation. The file is |
| 546 |
> |
updated at the same time as the \texttt{.dump} file, but it only |
| 547 |
> |
contains the most recent frame. In this way, an \texttt{.eor} file may |
| 548 |
> |
be used to initialize a second simulation should it be necessary to |
| 549 |
> |
recover from a crash or power outage. |
| 550 |
|
|
| 551 |
< |
The correct ordering of the atoms relies on the ordering of atoms and molecules within the model and {\sc bass} scripts. {\sc oopse} expects the order to comply with the following guidelines: |
| 551 |
> |
\subsection{\label{oopseSec:initCoords}Generation of Initial Coordinates} |
| 552 |
> |
|
| 553 |
> |
As was stated in Sec.~\ref{oopseSec:coordFiles}, an initial coordinate |
| 554 |
> |
file is needed to provide the starting coordinates for a simulation. |
| 555 |
> |
Since each simulation is different, system creation is left to the end |
| 556 |
> |
user; however, we have included a few sample programs which make some |
| 557 |
> |
specialized structures. The {\tt .in} file must list the integrable |
| 558 |
> |
objects in the correct order. The ordering of the integrable objects |
| 559 |
> |
relies on the ordering of molecules within the meta-data file. {\sc |
| 560 |
> |
oopse} expects the order to comply with the following guidelines: |
| 561 |
|
\begin{enumerate} |
| 562 |
< |
\item All of the molecules of the first declared component are given before proceeding to the molecules of the second component, and so on for all declared components. |
| 563 |
< |
\item The ordering of the atoms for each molecule follows the order declared in the molecule's declaration within the model file. |
| 562 |
> |
\item All of the molecules of the first declared component are given |
| 563 |
> |
before proceeding to the molecules of the second component, and so on |
| 564 |
> |
for all subsequently declared components. |
| 565 |
> |
\item The ordering of the atoms for each molecule follows the order |
| 566 |
> |
declared in the molecule's declaration within the model file. |
| 567 |
> |
\item Only atoms which are not members of a {\tt rigidBody} are |
| 568 |
> |
included. |
| 569 |
> |
\item Rigid Body coordinates for a molecule are listed immediately |
| 570 |
> |
after the the other atoms in a molecule. Some molecules may be |
| 571 |
> |
entirely rigid, in which case, only the rigid body coordinates are |
| 572 |
> |
given. |
| 573 |
|
\end{enumerate} |
| 574 |
< |
An example is given in Scheme~\ref{sch:initEx1} resulting in the {\tt .init} file shown in Scheme~\ref{sch:initEx2}. |
| 574 |
> |
An example is given in the meta-data file in Scheme~\ref{sch:initEx1} |
| 575 |
> |
which results in the {\tt .in} file shown in Scheme~\ref{sch:initEx2}. |
| 576 |
|
|
| 577 |
< |
\begin{lstlisting}[float,caption={This scheme illustrates the declaration of the $\text{I}_2$ molecule and the HCl molecule. The two molecules are then included into a simulation.}, label=sch:initEx1] |
| 577 |
> |
\begin{lstlisting}[float,caption={Example declaration of the |
| 578 |
> |
$\text{I}_2$ molecule and the HCl molecule. The two molecules are then |
| 579 |
> |
included into a simulation.}, label=sch:initEx1] |
| 580 |
|
|
| 581 |
|
molecule{ |
| 582 |
|
name = "I2"; |
| 618 |
|
nMol = 1; |
| 619 |
|
} |
| 620 |
|
|
| 621 |
< |
initialConfig = "mixture.init"; |
| 621 |
> |
initialConfig = "mixture.in"; |
| 622 |
|
|
| 623 |
|
\end{lstlisting} |
| 624 |
|
|
| 625 |
< |
\begin{lstlisting}[float,caption={This is the contents of the {\tt mixture.init} file matching the declarations in Scheme~\ref{sch:initEx1}. Note that even though $\text{I}_2$ is declared before HCl, the {\tt .init} file follows the order in which the components were included.},label=sch:initEx2] |
| 625 |
> |
\begin{lstlisting}[float,caption={The contents of the {\tt |
| 626 |
> |
mixture.in} file matching the declarations in |
| 627 |
> |
Scheme~\ref{sch:initEx1}. Note that even though $\text{I}_2$ is |
| 628 |
> |
declared before HCl, the {\tt .in} file follows the order {\it in |
| 629 |
> |
which the components were included}.},label=sch:initEx2] |
| 630 |
|
|
| 631 |
|
10 |
| 632 |
|
0.0; 10.0 0.0 0.0; 0.0 10.0 0.0; 0.0 0.0 10.0; |
| 648 |
|
|
| 649 |
|
The last output file generated by {\sc oopse} is the statistics |
| 650 |
|
file. This file records such statistical quantities as the |
| 651 |
< |
instantaneous temperature, volume, pressure, etc. It is written out |
| 652 |
< |
with the frequency specified in the \texttt{.bass} file with the |
| 651 |
> |
instantaneous temperature (in $K$), volume (in $\mbox{\AA}^{3}$), |
| 652 |
> |
pressure (in $\mbox{atm}$), etc. It is written out with the frequency |
| 653 |
> |
specified in the meta-data file with the |
| 654 |
|
\texttt{statusTime} keyword. The file allows the user to observe the |
| 655 |
|
system variables as a function of simulation time while the simulation |
| 656 |
|
is in progress. One useful function the statistics file serves is to |
| 657 |
< |
monitor the conserved quantity of a given simulation ensemble, this |
| 658 |
< |
allows the user to observe the stability of the integrator. The |
| 657 |
> |
monitor the conserved quantity of a given simulation ensemble, |
| 658 |
> |
allowing the user to gauge the stability of the integrator. The |
| 659 |
|
statistics file is denoted with the \texttt{.stat} file extension. |
| 660 |
|
|
| 661 |
+ |
\section{\label{oopseSec:empiricalEnergy}The Empirical Energy |
| 662 |
+ |
Functions} |
| 663 |
|
|
| 664 |
< |
\section{\label{oopseSec:empiricalEnergy}The Empirical Energy Functions} |
| 664 |
> |
Like many simulation packages, {\sc oopse} splits the potential energy |
| 665 |
> |
into the short-ranged (bonded) portion and a long-range (non-bonded) |
| 666 |
> |
potential, |
| 667 |
> |
\begin{equation} |
| 668 |
> |
V = V_{\mathrm{short-range}} + V_{\mathrm{long-range}}. |
| 669 |
> |
\end{equation} |
| 670 |
> |
The short-ranged portion includes the explicit bonds, bends, and |
| 671 |
> |
torsions which have been defined in the meta-data file for the |
| 672 |
> |
molecules which are present in the simulation. The functional forms and |
| 673 |
> |
parameters for these interactions are defined by the force field which |
| 674 |
> |
is chosen. |
| 675 |
|
|
| 676 |
< |
\ |
| 676 |
> |
Calculating the long-range (non-bonded) potential involves a sum over |
| 677 |
> |
all pairs of atoms (except for those atoms which are involved in a |
| 678 |
> |
bond, bend, or torsion with each other). If done poorly, calculating |
| 679 |
> |
the the long-range interactions for $N$ atoms would involve $N(N-1)/2$ |
| 680 |
> |
evaluations of atomic distances. To reduce the number of distance |
| 681 |
> |
evaluations between pairs of atoms, {\sc oopse} uses a switched cutoff |
| 682 |
> |
with Verlet neighbor lists.\cite{allen87:csl} It is well known that |
| 683 |
> |
neutral groups which contain charges will exhibit pathological forces |
| 684 |
> |
unless the cutoff is applied to the neutral groups evenly instead of |
| 685 |
> |
to the individual atoms.\cite{leach01:mm} {\sc oopse} allows users to |
| 686 |
> |
specify cutoff groups which may contain an arbitrary number of atoms |
| 687 |
> |
in the molecule. Atoms in a cutoff group are treated as a single unit |
| 688 |
> |
for the evaluation of the switching function: |
| 689 |
> |
\begin{equation} |
| 690 |
> |
V_{\mathrm{long-range}} = \sum_{a} \sum_{b>a} s(r_{ab}) \sum_{i \in a} \sum_{j \in b} V_{ij}(r_{ij}), |
| 691 |
> |
\end{equation} |
| 692 |
> |
where $r_{ab}$ is the distance between the centers of mass of the two |
| 693 |
> |
cutoff groups ($a$ and $b$). |
| 694 |
> |
|
| 695 |
> |
The sums over $a$ and $b$ are over the cutoff groups that are present |
| 696 |
> |
in the simulation. Atoms which are not explicitly defined as members |
| 697 |
> |
of a {\tt cutoffGroup} are treated as a group consisting of only one |
| 698 |
> |
atom. The switching function, $s(r)$ is the standard cubic switching |
| 699 |
> |
function, |
| 700 |
> |
\begin{equation} |
| 701 |
> |
S(r) = |
| 702 |
> |
\begin{cases} |
| 703 |
> |
1 & \text{if $r \le r_{\text{sw}}$},\\ |
| 704 |
> |
\frac{(r_{\text{cut}} + 2r - 3r_{\text{sw}})(r_{\text{cut}} - r)^2} |
| 705 |
> |
{(r_{\text{cut}} - r_{\text{sw}})^2} |
| 706 |
> |
& \text{if $r_{\text{sw}} < r \le r_{\text{cut}}$}, \\ |
| 707 |
> |
0 & \text{if $r > r_{\text{cut}}$.} |
| 708 |
> |
\end{cases} |
| 709 |
> |
\label{eq:dipoleSwitching} |
| 710 |
> |
\end{equation} |
| 711 |
> |
Here, $r_{\text{sw}}$ is the {\tt switchingRadius}, or the distance |
| 712 |
> |
beyond which interactions are reduced, and $r_{\text{cut}}$ is the |
| 713 |
> |
{\tt cutoffRadius}, or the distance at which interactions are |
| 714 |
> |
truncated. |
| 715 |
> |
|
| 716 |
> |
Users of {\sc oopse} do not need to specify the {\tt cutoffRadius} or |
| 717 |
> |
{\tt switchingRadius}. In simulations containing only Lennard-Jones |
| 718 |
> |
atoms, the cutoff radius has a default value of $2.5\sigma_{ii}$, |
| 719 |
> |
where $\sigma_{ii}$ is the largest Lennard-Jones length parameter |
| 720 |
> |
present in the simulation. In simulations containing charged or |
| 721 |
> |
dipolar atoms, the default cutoff radius is $15 \mbox{\AA}$. |
| 722 |
> |
|
| 723 |
> |
The {\tt switchingRadius} is set to a default value of 95\% of the |
| 724 |
> |
{\tt cutoffRadius}. In the special case of a simulation containing |
| 725 |
> |
{\it only} Lennard-Jones atoms, the default switching radius takes the |
| 726 |
> |
same value as the cutoff radius, and {\sc oopse} will use a shifted |
| 727 |
> |
potential to remove discontinuities in the potential at the cutoff. |
| 728 |
> |
Both radii may be specified in the meta-data file. |
| 729 |
> |
|
| 730 |
> |
Force fields can be added to {\sc oopse}, although it comes with a few |
| 731 |
> |
simple examples (Lennard-Jones, {\sc duff}, {\sc water}, and {\sc |
| 732 |
> |
eam}) which are explained in the following sections. |
| 733 |
> |
|
| 734 |
|
\subsection{\label{sec:LJPot}The Lennard Jones Force Field} |
| 735 |
|
|
| 736 |
|
The most basic force field implemented in {\sc oopse} is the |
| 737 |
< |
Lennard-Jones force field, which mimics the van der Waals interaction at |
| 738 |
< |
long distances, and uses an empirical repulsion at short |
| 737 |
> |
Lennard-Jones force field, which mimics the van der Waals interaction |
| 738 |
> |
at long distances and uses an empirical repulsion at short |
| 739 |
|
distances. The Lennard-Jones potential is given by: |
| 740 |
|
\begin{equation} |
| 741 |
|
V_{\text{LJ}}(r_{ij}) = |
| 748 |
|
where $r_{ij}$ is the distance between particles $i$ and $j$, |
| 749 |
|
$\sigma_{ij}$ scales the length of the interaction, and |
| 750 |
|
$\epsilon_{ij}$ scales the well depth of the potential. Scheme |
| 751 |
< |
\ref{sch:LJFF} gives an example \texttt{.bass} file that |
| 751 |
> |
\ref{sch:LJFF} gives an example meta-data file that |
| 752 |
|
sets up a system of 108 Ar particles to be simulated using the |
| 753 |
|
Lennard-Jones force field. |
| 754 |
|
|
| 755 |
< |
\begin{lstlisting}[float,caption={[Invocation of the Lennard-Jones force field] A sample system using the Lennard-Jones force field.},label={sch:LJFF}] |
| 755 |
> |
\begin{lstlisting}[float,caption={[Invocation of the Lennard-Jones |
| 756 |
> |
force field] A sample meta-data file for a small Lennard-Jones |
| 757 |
> |
simulation.},label={sch:LJFF}] |
| 758 |
|
|
| 759 |
< |
#include "argon.mdl" |
| 759 |
> |
#include "argon.md" |
| 760 |
|
|
| 761 |
|
nComponents = 1; |
| 762 |
|
component{ |
| 764 |
|
nMol = 108; |
| 765 |
|
} |
| 766 |
|
|
| 767 |
< |
initialConfig = "./argon.init"; |
| 767 |
> |
initialConfig = "./argon.in"; |
| 768 |
|
|
| 769 |
|
forceField = "LJ"; |
| 770 |
|
\end{lstlisting} |
| 771 |
|
|
| 523 |
– |
Because this potential is calculated between all pairs, the force |
| 524 |
– |
evaluation can become computationally expensive for large systems. To |
| 525 |
– |
keep the pair evaluations to a manageable number, {\sc oopse} employs |
| 526 |
– |
a cut-off radius.\cite{allen87:csl} The cutoff radius can either be |
| 527 |
– |
specified in the \texttt{.bass} file, or left as its default value of |
| 528 |
– |
$2.5\sigma_{ii}$, where $\sigma_{ii}$ is the largest Lennard-Jones |
| 529 |
– |
length parameter present in the simulation. Truncating the calculation |
| 530 |
– |
at $r_{\text{cut}}$ introduces a discontinuity into the potential |
| 531 |
– |
energy and the force. To offset this discontinuity in the potential, |
| 532 |
– |
the energy value at $r_{\text{cut}}$ is subtracted from the |
| 533 |
– |
potential. This causes the potential to go to zero smoothly at the |
| 534 |
– |
cut-off radius, and preserves conservation of energy in integrating |
| 535 |
– |
the equations of motion. There still remains a discontinuity in the derivative (the forces), however, this does not significantly affect the dynamics. |
| 536 |
– |
|
| 772 |
|
Interactions between dissimilar particles requires the generation of |
| 773 |
< |
cross term parameters for $\sigma$ and $\epsilon$. These are |
| 774 |
< |
calculated through the Lorentz-Berthelot mixing |
| 773 |
> |
cross term parameters for $\sigma$ and $\epsilon$. These parameters |
| 774 |
> |
are determined using the Lorentz-Berthelot mixing |
| 775 |
|
rules:\cite{allen87:csl} |
| 776 |
|
\begin{equation} |
| 777 |
|
\sigma_{ij} = \frac{1}{2}[\sigma_{ii} + \sigma_{jj}], |
| 786 |
|
\subsection{\label{oopseSec:DUFF}Dipolar Unified-Atom Force Field} |
| 787 |
|
|
| 788 |
|
The dipolar unified-atom force field ({\sc duff}) was developed to |
| 789 |
< |
simulate lipid bilayers. The simulations require a model capable of |
| 790 |
< |
forming bilayers, while still being sufficiently computationally |
| 791 |
< |
efficient to allow large systems ($\sim$100's of phospholipids, |
| 792 |
< |
$\sim$1000's of waters) to be simulated for long times |
| 793 |
< |
($\sim$10's of nanoseconds). |
| 794 |
< |
|
| 795 |
< |
With this goal in mind, {\sc duff} has no point |
| 796 |
< |
charges. Charge-neutral distributions were replaced with dipoles, |
| 797 |
< |
while most atoms and groups of atoms were reduced to Lennard-Jones |
| 798 |
< |
interaction sites. This simplification cuts the length scale of long |
| 799 |
< |
range interactions from $\frac{1}{r}$ to $\frac{1}{r^3}$, removing the need for the computationally expensive Ewald sum. Instead, we Verlet neighbor-lists and cutoff radii are used for the dipolar interactions, or a reaction field is added to mimic longer range interactions. |
| 789 |
> |
simulate lipid bilayers. These types of simulations require a model |
| 790 |
> |
capable of forming bilayers, while still being sufficiently |
| 791 |
> |
computationally efficient to allow large systems ($\sim$100's of |
| 792 |
> |
phospholipids, $\sim$1000's of waters) to be simulated for long times |
| 793 |
> |
($\sim$10's of nanoseconds). With this goal in mind, {\sc duff} has no |
| 794 |
> |
point charges. Charge-neutral distributions are replaced with dipoles, |
| 795 |
> |
while most atoms and groups of atoms are reduced to Lennard-Jones |
| 796 |
> |
interaction sites. This simplification reduces the length scale of |
| 797 |
> |
long range interactions from $\frac{1}{r}$ to $\frac{1}{r^3}$, |
| 798 |
> |
removing the need for the computationally expensive Ewald |
| 799 |
> |
sum. Instead, Verlet neighbor-lists and cutoff radii are used for the |
| 800 |
> |
dipolar interactions, and, if desired, a reaction field may be added |
| 801 |
> |
to mimic longer range interactions. |
| 802 |
|
|
| 803 |
|
As an example, lipid head-groups in {\sc duff} are represented as |
| 804 |
< |
point dipole interaction sites. By placing a dipole at the head |
| 805 |
< |
group's center of mass, our model mimics the charge separation found |
| 806 |
< |
in common phospholipid head groups such as |
| 807 |
< |
phosphatidylcholine.\cite{Cevc87} Additionally, a large Lennard-Jones |
| 808 |
< |
site is located at the pseudoatom's center of mass. The model is |
| 809 |
< |
illustrated by the red atom in Fig.~\ref{oopseFig:lipidModel}. The |
| 810 |
< |
water model we use to complement the dipoles of the lipids is our |
| 811 |
< |
reparameterization\cite{fennell04} of the soft sticky dipole (SSD) model of Ichiye |
| 804 |
> |
point dipole interaction sites. Placing a dipole at the head group's |
| 805 |
> |
center of mass mimics the charge separation found in common |
| 806 |
> |
phospholipid head groups such as phosphatidylcholine.\cite{Cevc87} |
| 807 |
> |
Additionally, a large Lennard-Jones site is located at the |
| 808 |
> |
pseudoatom's center of mass. The model is illustrated by the red atom |
| 809 |
> |
in Fig.~\ref{oopseFig:lipidModel}. The water model we use to |
| 810 |
> |
complement the dipoles of the lipids is a |
| 811 |
> |
reparameterization\cite{fennell04} of the soft sticky dipole (SSD) |
| 812 |
> |
model of Ichiye |
| 813 |
|
\emph{et al.}\cite{liu96:new_model} |
| 814 |
|
|
| 815 |
|
\begin{figure} |
| 816 |
|
\centering |
| 817 |
< |
\includegraphics[width=\linewidth]{twoChainFig.pdf} |
| 818 |
< |
\caption[A representation of a lipid model in {\sc duff}]{A representation of the lipid model. $\phi$ is the torsion angle, $\theta$ % |
| 819 |
< |
is the bend angle, and $\mu$ is the dipole moment of the head group.} |
| 817 |
> |
\includegraphics[width=\linewidth]{lipidModel.eps} |
| 818 |
> |
\caption[A representation of a lipid model in {\sc duff}]{A |
| 819 |
> |
representation of the lipid model. $\phi$ is the torsion angle, |
| 820 |
> |
$\theta$ is the bend angle, and $\mu$ is the dipole moment of the head |
| 821 |
> |
group.} |
| 822 |
|
\label{oopseFig:lipidModel} |
| 823 |
|
\end{figure} |
| 824 |
|
|
| 825 |
< |
We have used a set of scalable parameters to model the alkyl groups |
| 826 |
< |
with Lennard-Jones sites. For this, we have borrowed parameters from |
| 827 |
< |
the TraPPE force field of Siepmann |
| 828 |
< |
\emph{et al}.\cite{Siepmann1998} TraPPE is a unified-atom |
| 829 |
< |
representation of n-alkanes, which is parametrized against phase |
| 830 |
< |
equilibria using Gibbs ensemble Monte Carlo simulation |
| 831 |
< |
techniques.\cite{Siepmann1998} One of the advantages of TraPPE is that |
| 832 |
< |
it generalizes the types of atoms in an alkyl chain to keep the number |
| 833 |
< |
of pseudoatoms to a minimum; the parameters for a unified atom such as |
| 834 |
< |
$\text{CH}_2$ do not change depending on what species are bonded to |
| 595 |
< |
it. |
| 825 |
> |
A set of scalable parameters has been used to model the alkyl groups |
| 826 |
> |
with Lennard-Jones sites. For this, parameters from the TraPPE force |
| 827 |
> |
field of Siepmann \emph{et al.}\cite{Siepmann1998} have been |
| 828 |
> |
utilized. TraPPE is a unified-atom representation of n-alkanes which |
| 829 |
> |
is parametrized against phase equilibria using Gibbs ensemble Monte |
| 830 |
> |
Carlo simulation techniques.\cite{Siepmann1998} One of the advantages |
| 831 |
> |
of TraPPE is that it generalizes the types of atoms in an alkyl chain |
| 832 |
> |
to keep the number of pseudoatoms to a minimum; thus, the parameters |
| 833 |
> |
for a unified atom such as $\text{CH}_2$ do not change depending on |
| 834 |
> |
what species are bonded to it. |
| 835 |
|
|
| 836 |
< |
TraPPE and {\sc duff} also constrain all bonds to be of fixed length. Typically, |
| 837 |
< |
bond vibrations are the fastest motions in a molecular dynamic |
| 838 |
< |
simulation. Small time steps between force evaluations must be used to |
| 839 |
< |
ensure adequate energy conservation in the bond degrees of freedom. By |
| 840 |
< |
constraining the bond lengths, larger time steps may be used when |
| 841 |
< |
integrating the equations of motion. A simulation using {\sc duff} is |
| 842 |
< |
illustrated in Scheme \ref{sch:DUFF}. |
| 836 |
> |
As is required by TraPPE, {\sc duff} also constrains all bonds to be |
| 837 |
> |
of fixed length. Typically, bond vibrations are the fastest motions in |
| 838 |
> |
a molecular dynamic simulation. With these vibrations present, small |
| 839 |
> |
time steps between force evaluations must be used to ensure adequate |
| 840 |
> |
energy conservation in the bond degrees of freedom. By constraining |
| 841 |
> |
the bond lengths, larger time steps may be used when integrating the |
| 842 |
> |
equations of motion. A simulation using {\sc duff} is illustrated in |
| 843 |
> |
Scheme \ref{sch:DUFF}. |
| 844 |
|
|
| 845 |
< |
\begin{lstlisting}[float,caption={[Invocation of {\sc duff}]A portion of a \texttt{.bass} file showing a simulation utilizing {\sc duff}},label={sch:DUFF}] |
| 845 |
> |
\begin{lstlisting}[float,caption={[Invocation of {\sc duff}]A portion |
| 846 |
> |
of a meta-data file showing a simulation utilizing {\sc |
| 847 |
> |
duff}},label={sch:DUFF}] |
| 848 |
|
|
| 849 |
< |
#include "water.mdl" |
| 850 |
< |
#include "lipid.mdl" |
| 849 |
> |
#include "water.md" |
| 850 |
> |
#include "lipid.md" |
| 851 |
|
|
| 852 |
|
nComponents = 2; |
| 853 |
|
component{ |
| 860 |
|
nMol = 1936; |
| 861 |
|
} |
| 862 |
|
|
| 863 |
< |
initialConfig = "bilayer.init"; |
| 863 |
> |
initialConfig = "bilayer.in"; |
| 864 |
|
|
| 865 |
|
forceField = "DUFF"; |
| 866 |
|
|
| 886 |
|
\label{eq:internalPotential} |
| 887 |
|
\end{equation} |
| 888 |
|
Here $V_{\text{bend}}$ is the bend potential for all 1, 3 bonded pairs |
| 889 |
< |
within the molecule $I$, and $V_{\text{torsion}}$ is the torsion potential |
| 890 |
< |
for all 1, 4 bonded pairs. The pairwise portions of the internal |
| 891 |
< |
potential are excluded for atom pairs that are involved in the same bond, bend, or torsion. All other atom pairs within the molecule are subject to the LJ pair potential. |
| 889 |
> |
within the molecule $I$, and $V_{\text{torsion}}$ is the torsion |
| 890 |
> |
potential for all 1, 4 bonded pairs. The pairwise portions of the |
| 891 |
> |
non-bonded interactions are excluded for atom pairs that are involved |
| 892 |
> |
in the smae bond, bend, or torsion. All other atom pairs within a |
| 893 |
> |
molecule are subject to the LJ pair potential. |
| 894 |
|
|
| 651 |
– |
|
| 895 |
|
The bend potential of a molecule is represented by the following function: |
| 896 |
|
\begin{equation} |
| 897 |
< |
V_{\text{bend}}(\theta_{ijk}) = k_{\theta}( \theta_{ijk} - \theta_0 )^2, \label{eq:bendPot} |
| 897 |
> |
V_{\text{bend}}(\theta_{ijk}) = k_{\theta}( \theta_{ijk} - \theta_0 |
| 898 |
> |
)^2, \label{eq:bendPot} |
| 899 |
|
\end{equation} |
| 900 |
|
where $\theta_{ijk}$ is the angle defined by atoms $i$, $j$, and $k$ |
| 901 |
|
(see Fig.~\ref{oopseFig:lipidModel}), $\theta_0$ is the equilibrium |
| 935 |
|
k_3 &= 4c_3. |
| 936 |
|
\end{align*} |
| 937 |
|
By recasting the potential as a power series, repeated trigonometric |
| 938 |
< |
evaluations are avoided during the calculation of the potential energy. |
| 938 |
> |
evaluations are avoided during the calculation of the potential |
| 939 |
> |
energy. |
| 940 |
|
|
| 941 |
|
|
| 942 |
< |
The cross potential between molecules $I$ and $J$, $V^{IJ}_{\text{Cross}}$, is |
| 943 |
< |
as follows: |
| 942 |
> |
The cross potential between molecules $I$ and $J$, |
| 943 |
> |
$V^{IJ}_{\text{Cross}}$, is as follows: |
| 944 |
|
\begin{equation} |
| 945 |
|
V^{IJ}_{\text{Cross}} = |
| 946 |
|
\sum_{i \in I} \sum_{j \in J} |
| 970 |
|
Here $\mathbf{r}_{ij}$ is the vector starting at atom $i$ pointing |
| 971 |
|
towards $j$, and $\boldsymbol{\Omega}_i$ and $\boldsymbol{\Omega}_j$ |
| 972 |
|
are the orientational degrees of freedom for atoms $i$ and $j$ |
| 973 |
< |
respectively. $|\mu_i|$ is the magnitude of the dipole moment of atom |
| 974 |
< |
$i$, $\boldsymbol{\hat{u}}_i$ is the standard unit orientation vector |
| 975 |
< |
of $\boldsymbol{\Omega}_i$, and $\boldsymbol{\hat{r}}_{ij}$ is the |
| 976 |
< |
unit vector pointing along $\mathbf{r}_{ij}$ |
| 973 |
> |
respectively. The magnitude of the dipole moment of atom $i$ is |
| 974 |
> |
$|\mu_i|$, $\boldsymbol{\hat{u}}_i$ is the standard unit orientation |
| 975 |
> |
vector of $\boldsymbol{\Omega}_i$, and $\boldsymbol{\hat{r}}_{ij}$ is |
| 976 |
> |
the unit vector pointing along $\mathbf{r}_{ij}$ |
| 977 |
|
($\boldsymbol{\hat{r}}_{ij}=\mathbf{r}_{ij}/|\mathbf{r}_{ij}|$). |
| 978 |
|
|
| 979 |
< |
To improve computational efficiency of the dipole-dipole interactions, |
| 980 |
< |
{\sc oopse} employs an electrostatic cutoff radius. This parameter can |
| 736 |
< |
be set in the \texttt{.bass} file, and controls the length scale over |
| 737 |
< |
which dipole interactions are felt. To compensate for the |
| 738 |
< |
discontinuity in the potential and the forces at the cutoff radius, we |
| 739 |
< |
have implemented a switching function to smoothly scale the |
| 740 |
< |
dipole-dipole interaction at the cutoff. |
| 741 |
< |
\begin{equation} |
| 742 |
< |
S(r_{ij}) = |
| 743 |
< |
\begin{cases} |
| 744 |
< |
1 & \text{if $r_{ij} \le r_t$},\\ |
| 745 |
< |
\frac{(r_{\text{cut}} + 2r_{ij} - 3r_t)(r_{\text{cut}} - r_{ij})^2} |
| 746 |
< |
{(r_{\text{cut}} - r_t)^2} |
| 747 |
< |
& \text{if $r_t < r_{ij} \le r_{\text{cut}}$}, \\ |
| 748 |
< |
0 & \text{if $r_{ij} > r_{\text{cut}}$.} |
| 749 |
< |
\end{cases} |
| 750 |
< |
\label{eq:dipoleSwitching} |
| 751 |
< |
\end{equation} |
| 752 |
< |
Here $S(r_{ij})$ scales the potential at a given $r_{ij}$, and $r_t$ |
| 753 |
< |
is the taper radius some given thickness less than the electrostatic |
| 754 |
< |
cutoff. The switching thickness can be set in the \texttt{.bass} file. |
| 979 |
> |
\subsubsection{\label{oopseSec:SSD}The {\sc duff} Water Models: SSD/E |
| 980 |
> |
and SSD/RF} |
| 981 |
|
|
| 756 |
– |
\subsubsection{\label{oopseSec:SSD}The {\sc duff} Water Models: SSD/E and SSD/RF} |
| 757 |
– |
|
| 982 |
|
In the interest of computational efficiency, the default solvent used |
| 983 |
|
by {\sc oopse} is the extended Soft Sticky Dipole (SSD/E) water |
| 984 |
|
model.\cite{fennell04} The original SSD was developed by Ichiye |
| 1037 |
|
can be found in the original SSD |
| 1038 |
|
articles.\cite{liu96:new_model,liu96:monte_carlo,chandra99:ssd_md,Ichiye03} |
| 1039 |
|
|
| 1040 |
+ |
\begin{figure} |
| 1041 |
+ |
\centering |
| 1042 |
+ |
\includegraphics[width=\linewidth]{waterAngle.eps} |
| 1043 |
+ |
\caption[Coordinate definition for the SSD/E water model]{Coordinates |
| 1044 |
+ |
for the interaction between two SSD/E water molecules. $\theta_{ij}$ |
| 1045 |
+ |
is the angle that $r_{ij}$ makes with the $\hat{z}$ vector in the |
| 1046 |
+ |
body-fixed frame for molecule $i$. The $\hat{z}$ vector bisects the |
| 1047 |
+ |
HOH angle in each water molecule. } |
| 1048 |
+ |
\label{oopseFig:ssd} |
| 1049 |
+ |
\end{figure} |
| 1050 |
+ |
|
| 1051 |
+ |
|
| 1052 |
|
Since SSD/E is a single-point {\it dipolar} model, the force |
| 1053 |
|
calculations are simplified significantly relative to the standard |
| 1054 |
|
{\it charged} multi-point models. In the original Monte Carlo |
| 1055 |
|
simulations using this model, Ichiye {\it et al.} reported that using |
| 1056 |
|
SSD decreased computer time by a factor of 6-7 compared to other |
| 1057 |
< |
models.\cite{liu96:new_model} What is most impressive is that these savings |
| 1058 |
< |
did not come at the expense of accurate depiction of the liquid state |
| 1059 |
< |
properties. Indeed, SSD/E maintains reasonable agreement with the Head-Gordon |
| 1060 |
< |
diffraction data for the structural features of liquid |
| 1061 |
< |
water.\cite{hura00,liu96:new_model} Additionally, the dynamical properties |
| 1062 |
< |
exhibited by SSD/E agree with experiment better than those of more |
| 1063 |
< |
computationally expensive models (like TIP3P and |
| 1064 |
< |
SPC/E).\cite{chandra99:ssd_md} The combination of speed and accurate depiction |
| 1065 |
< |
of solvent properties makes SSD/E a very attractive model for the |
| 1066 |
< |
simulation of large scale biochemical simulations. |
| 1057 |
> |
models.\cite{liu96:new_model} What is most impressive is that these |
| 1058 |
> |
savings did not come at the expense of accurate depiction of the |
| 1059 |
> |
liquid state properties. Indeed, SSD/E maintains reasonable agreement |
| 1060 |
> |
with the Head-Gordon diffraction data for the structural features of |
| 1061 |
> |
liquid water.\cite{hura00,liu96:new_model} Additionally, the dynamical |
| 1062 |
> |
properties exhibited by SSD/E agree with experiment better than those |
| 1063 |
> |
of more computationally expensive models (like TIP3P and |
| 1064 |
> |
SPC/E).\cite{chandra99:ssd_md} The combination of speed and accurate |
| 1065 |
> |
depiction of solvent properties makes SSD/E a very attractive model |
| 1066 |
> |
for the simulation of large scale biochemical simulations. |
| 1067 |
|
|
| 1068 |
|
Recent constant pressure simulations revealed issues in the original |
| 1069 |
|
SSD model that led to lower than expected densities at all target |
| 1072 |
|
exhibits improved liquid structure and transport behavior. If the use |
| 1073 |
|
of a reaction field long-range interaction correction is desired, it |
| 1074 |
|
is recommended that the parameters be modified to those of the SSD/RF |
| 1075 |
< |
model (an SSD variant parameterized for reaction field). Solvent parameters can be easily modified in an accompanying |
| 1076 |
< |
\texttt{.bass} file as illustrated in the scheme below. A table of the |
| 1077 |
< |
parameter values and the drawbacks and benefits of the different |
| 1078 |
< |
density corrected SSD models can be found in |
| 1079 |
< |
reference~\cite{fennell04}. |
| 1075 |
> |
model (an SSD variant parameterized for reaction field). These solvent |
| 1076 |
> |
parameters are listed and can be easily modified in the {\sc duff} |
| 1077 |
> |
force field file ({\tt DUFF.frc}). A table of the parameter values |
| 1078 |
> |
and the drawbacks and benefits of the different density corrected SSD |
| 1079 |
> |
models can be found in reference~\citen{fennell04}. |
| 1080 |
|
|
| 1081 |
< |
\begin{lstlisting}[float,caption={[A simulation of {\sc ssd} water]A portion of a \texttt{.bass} file showing a simulation including {\sc ssd} water.},label={sch:ssd}] |
| 1081 |
> |
\subsection{\label{oopseSec:WATER}The {\sc water} Force Field} |
| 1082 |
|
|
| 1083 |
< |
#include "water.mdl" |
| 1084 |
< |
|
| 1085 |
< |
nComponents = 1; |
| 1086 |
< |
component{ |
| 1087 |
< |
type = "SSD_water"; |
| 1088 |
< |
nMol = 864; |
| 1089 |
< |
} |
| 1090 |
< |
|
| 1091 |
< |
initialConfig = "liquidWater.init"; |
| 1092 |
< |
|
| 1093 |
< |
forceField = "DUFF"; |
| 1094 |
< |
|
| 1095 |
< |
/* |
| 1096 |
< |
* The following two flags set the cutoff |
| 1097 |
< |
* radius for the electrostatic forces |
| 1098 |
< |
* as well as the skin thickness of the switching |
| 1099 |
< |
* function. |
| 1100 |
< |
*/ |
| 1101 |
< |
|
| 1102 |
< |
electrostaticCutoffRadius = 9.2; |
| 867 |
< |
electrostaticSkinThickness = 1.38; |
| 868 |
< |
|
| 869 |
< |
\end{lstlisting} |
| 870 |
< |
|
| 1083 |
> |
In addition to the {\sc duff} force field's solvent description, a |
| 1084 |
> |
separate {\sc water} force field has been included for simulating most |
| 1085 |
> |
of the common rigid-body water models. This force field includes the |
| 1086 |
> |
simple and point-dipolar models (SSD, SSD1, SSD/E, SSD/RF, and DPD |
| 1087 |
> |
water), as well as the common charge-based models (SPC, SPC/E, TIP3P, |
| 1088 |
> |
TIP4P, and |
| 1089 |
> |
TIP5P).\cite{liu96:new_model,Ichiye03,fennell04,Marrink01,Berendsen81,Berendsen87,Jorgensen83,Mahoney00} |
| 1090 |
> |
In order to handle these models, charge-charge interactions were |
| 1091 |
> |
included in the force-loop: |
| 1092 |
> |
\begin{equation} |
| 1093 |
> |
V_{\text{charge}}(r_{ij}) = \sum_{ij}\frac{q_iq_je^2}{r_{ij}}, |
| 1094 |
> |
\end{equation} |
| 1095 |
> |
where $q$ represents the charge on particle $i$ or $j$, and $e$ is the |
| 1096 |
> |
charge of an electron in Coulombs. As with the other pair |
| 1097 |
> |
interactions, charges can be simulated with a pure cutoff or a |
| 1098 |
> |
reaction field. The {\sc water} force field can be easily expanded |
| 1099 |
> |
through modification of the {\sc water} force field file ({\tt |
| 1100 |
> |
WATER.frc}). By adding atom types and inserting the appropriate |
| 1101 |
> |
parameters, it is possible to extend the force field to handle rigid |
| 1102 |
> |
molecules other than water. |
| 1103 |
|
|
| 1104 |
|
\subsection{\label{oopseSec:eam}Embedded Atom Method} |
| 1105 |
|
|
| 1106 |
< |
{\sc oopse} implements a potential that |
| 1107 |
< |
describes bonding transition metal |
| 1108 |
< |
systems\cite{Finnis84,Ercolessi88,Chen90,Qi99,Ercolessi02} and has attractive interaction which models ``Embedding'' |
| 1109 |
< |
a positively charged metal ion in the electron density due to the |
| 1106 |
> |
{\sc oopse} implements a potential that describes bonding in |
| 1107 |
> |
transition metal |
| 1108 |
> |
systems.~\cite{Finnis84,Ercolessi88,Chen90,Qi99,Ercolessi02} This |
| 1109 |
> |
potential has an attractive interaction which models ``Embedding'' a |
| 1110 |
> |
positively charged pseudo-atom core in the electron density due to the |
| 1111 |
|
free valance ``sea'' of electrons created by the surrounding atoms in |
| 1112 |
< |
the system. A mostly-repulsive pairwise part of the potential |
| 1113 |
< |
describes the interaction of the positively charged metal core ions |
| 1114 |
< |
with one another. A particular potential description called the |
| 1115 |
< |
Embedded Atom Method\cite{Daw84,FBD86,johnson89,Lu97}({\sc eam}) that has |
| 1116 |
< |
particularly wide adoption has been selected for inclusion in {\sc oopse}. A |
| 1117 |
< |
good review of {\sc eam} and other metallic potential formulations was written |
| 1118 |
< |
by Voter.\cite{voter} |
| 1112 |
> |
the system. A pairwise part of the potential (which is primarily |
| 1113 |
> |
repulsive) describes the interaction of the positively charged metal |
| 1114 |
> |
core ions with one another. The Embedded Atom Method ({\sc |
| 1115 |
> |
eam})~\cite{Daw84,FBD86,johnson89,Lu97} has been widely adopted in the |
| 1116 |
> |
materials science community and has been included in {\sc oopse}. A |
| 1117 |
> |
good review of {\sc eam} and other formulations of metallic potentials |
| 1118 |
> |
was given by Voter.\cite{Voter:95} |
| 1119 |
|
|
| 1120 |
|
The {\sc eam} potential has the form: |
| 1121 |
< |
\begin{eqnarray} |
| 1122 |
< |
V & = & \sum_{i} F_{i}\left[\rho_{i}\right] + \sum_{i} \sum_{j \neq i} |
| 1123 |
< |
\phi_{ij}({\bf r}_{ij}), \\ |
| 1124 |
< |
\rho_{i} & = & \sum_{j \neq i} f_{j}({\bf r}_{ij}), |
| 1125 |
< |
\end{eqnarray} |
| 893 |
< |
where $F_{i} $ is the embedding function that equates the energy |
| 1121 |
> |
\begin{equation} |
| 1122 |
> |
V = \sum_{i} F_{i}\left[\rho_{i}\right] + \sum_{i} \sum_{j \neq i} |
| 1123 |
> |
\phi_{ij}({\bf r}_{ij}) |
| 1124 |
> |
\end{equation} |
| 1125 |
> |
where $F_{i} $ is an embedding functional that approximates the energy |
| 1126 |
|
required to embed a positively-charged core ion $i$ into a linear |
| 1127 |
|
superposition of spherically averaged atomic electron densities given |
| 1128 |
< |
by $\rho_{i}$. $\phi_{ij}$ is a primarily repulsive pairwise |
| 1129 |
< |
interaction between atoms $i$ and $j$. In the original formulation of |
| 1130 |
< |
{\sc eam}\cite{Daw84}, $\phi_{ij}$ was an entirely repulsive term, |
| 1131 |
< |
however in later refinements to {\sc eam} have shown that non-uniqueness |
| 1132 |
< |
between $F$ and $\phi$ allow for more general forms for |
| 1133 |
< |
$\phi$.\cite{Daw89} There is a cutoff distance, $r_{cut}$, which |
| 1134 |
< |
limits the summations in the {\sc eam} equation to the few dozen atoms |
| 1128 |
> |
by $\rho_{i}$, |
| 1129 |
> |
\begin{equation} |
| 1130 |
> |
\rho_{i} = \sum_{j \neq i} f_{j}({\bf r}_{ij}), |
| 1131 |
> |
\end{equation} |
| 1132 |
> |
Since the density at site $i$ ($\rho_i$) must be computed before the |
| 1133 |
> |
embedding functional can be evaluated, {\sc eam} and the related |
| 1134 |
> |
transition metal potentials require two loops through the atom pairs |
| 1135 |
> |
to compute the inter-atomic forces. |
| 1136 |
> |
|
| 1137 |
> |
The pairwise portion of the potential, $\phi_{ij}$, is a primarily |
| 1138 |
> |
repulsive interaction between atoms $i$ and $j$. In the original |
| 1139 |
> |
formulation of {\sc eam}\cite{Daw84}, $\phi_{ij}$ was an entirely |
| 1140 |
> |
repulsive term; however later refinements to {\sc eam} allowed for |
| 1141 |
> |
more general forms for $\phi$.\cite{Daw89} The effective cutoff |
| 1142 |
> |
distance, $r_{{\text cut}}$ is the distance at which the values of |
| 1143 |
> |
$f(r)$ and $\phi(r)$ drop to zero for all atoms present in the |
| 1144 |
> |
simulation. In practice, this distance is fairly small, limiting the |
| 1145 |
> |
summations in the {\sc eam} equation to the few dozen atoms |
| 1146 |
|
surrounding atom $i$ for both the density $\rho$ and pairwise $\phi$ |
| 1147 |
< |
interactions. Foiles \emph{et al}.~fit {\sc eam} potentials for the fcc |
| 1148 |
< |
metals Cu, Ag, Au, Ni, Pd, Pt and alloys of these metals.\cite{FBD86} |
| 1149 |
< |
These fits are included in {\sc oopse}. |
| 1147 |
> |
interactions. |
| 1148 |
> |
|
| 1149 |
> |
In computing forces for alloys, mixing rules as outlined by |
| 1150 |
> |
Johnson~\cite{johnson89} are used to compute the heterogenous pair |
| 1151 |
> |
potential, |
| 1152 |
> |
\begin{eqnarray} |
| 1153 |
> |
\label{eq:johnson} |
| 1154 |
> |
\phi_{ab}(r)=\frac{1}{2}\left( |
| 1155 |
> |
\frac{f_{b}(r)}{f_{a}(r)}\phi_{aa}(r)+ |
| 1156 |
> |
\frac{f_{a}(r)}{f_{b}(r)}\phi_{bb}(r) |
| 1157 |
> |
\right). |
| 1158 |
> |
\end{eqnarray} |
| 1159 |
> |
No mixing rule is needed for the densities, since the density at site |
| 1160 |
> |
$i$ is simply the linear sum of density contributions of all the other |
| 1161 |
> |
atoms. |
| 1162 |
> |
|
| 1163 |
> |
The {\sc eam} force field has a number of variants in the literature. |
| 1164 |
> |
Foiles, Baskes and Daw fit {\sc eam} potentials for Cu, Ag, Au, Ni, |
| 1165 |
> |
Pd, Pt and alloys of these metals.\cite{FBD86} These fits are included |
| 1166 |
> |
in {\sc oopse} as the {\tt u3} variant of the {\sc eam} force field. |
| 1167 |
> |
Voter and Chen reparamaterized a set of {\sc eam} functions which do a |
| 1168 |
> |
better job of predicting melting points.\cite{Voter:87} These |
| 1169 |
> |
functions are included in {\sc oopse} as the {\tt VC} variant of the |
| 1170 |
> |
{\sc eam} force field. An additional set of functions (the |
| 1171 |
> |
``Universal 6'' functions) are included in {\sc oopse} as the {\tt u6} |
| 1172 |
> |
variant of {\sc eam}. In general, to specify one variant of a force |
| 1173 |
> |
field, the user would need a single line in the meta-data file to |
| 1174 |
> |
select the {\tt forceFieldVariant}. For example, to specify the |
| 1175 |
> |
Voter-Chen variant of the {\sc eam} force field, the user would add |
| 1176 |
> |
the {\tt forceFieldVariant = "VC";} line to the meta-data file. |
| 1177 |
> |
|
| 1178 |
> |
The potential files used by the {\sc eam} force field are in the |
| 1179 |
> |
standard {\tt funcfl} format, which is the format utilized by a number |
| 1180 |
> |
of other codes (e.g. ParaDyn~\cite{Paradyn}, {\sc dynamo 86}). It |
| 1181 |
> |
should be noted that the energy units in these files are in eV, not |
| 1182 |
> |
$\mbox{kcal mol}^{-1}$ as in the rest of the {\sc oopse} force field |
| 1183 |
> |
files. |
| 1184 |
|
|
| 1185 |
|
\subsection{\label{oopseSec:pbc}Periodic Boundary Conditions} |
| 1186 |
|
|
| 1187 |
|
\newcommand{\roundme}{\operatorname{round}} |
| 1188 |
|
|
| 1189 |
< |
\textit{Periodic boundary conditions} are widely used to simulate bulk properties with a relatively small number of particles. The |
| 1190 |
< |
simulation box is replicated throughout space to form an infinite |
| 1189 |
> |
\textit{Periodic boundary conditions} are widely used to simulate bulk |
| 1190 |
> |
properties with a relatively small number of particles. In this method |
| 1191 |
> |
the simulation box is replicated throughout space to form an infinite |
| 1192 |
|
lattice. During the simulation, when a particle moves in the primary |
| 1193 |
|
cell, its image in other cells move in exactly the same direction with |
| 1194 |
|
exactly the same orientation. Thus, as a particle leaves the primary |
| 1195 |
|
cell, one of its images will enter through the opposite face. If the |
| 1196 |
|
simulation box is large enough to avoid ``feeling'' the symmetries of |
| 1197 |
|
the periodic lattice, surface effects can be ignored. The available |
| 1198 |
< |
periodic cells in OOPSE are cubic, orthorhombic and parallelepiped. We |
| 1199 |
< |
use a $3 \times 3$ matrix, $\mathsf{H}$, to describe the shape and |
| 1200 |
< |
size of the simulation box. $\mathsf{H}$ is defined: |
| 1198 |
> |
periodic cells in {\sc oopse} are cubic, orthorhombic and |
| 1199 |
> |
parallelepiped. {\sc oopse} use a $3 \times 3$ matrix, $\mathsf{H}$, |
| 1200 |
> |
to describe the shape and size of the simulation box. $\mathsf{H}$ is |
| 1201 |
> |
defined: |
| 1202 |
|
\begin{equation} |
| 1203 |
|
\mathsf{H} = ( \mathbf{h}_x, \mathbf{h}_y, \mathbf{h}_z ), |
| 1204 |
|
\end{equation} |
| 1215 |
|
\end{align} |
| 1216 |
|
The vector $\mathbf{s}$ is now a vector expressed as the number of box |
| 1217 |
|
lengths in the $\mathbf{h}_x$, $\mathbf{h}_y$, and $\mathbf{h}_z$ |
| 1218 |
< |
directions. To find the minimum image of a vector $\mathbf{r}$, we |
| 1219 |
< |
first convert it to its corresponding vector in box space, and then, |
| 1220 |
< |
cast each element to lie in the range $[-0.5,0.5]$: |
| 1218 |
> |
directions. To find the minimum image of a vector $\mathbf{r}$, {\sc |
| 1219 |
> |
oopse} first converts it to its corresponding vector in box space, and |
| 1220 |
> |
then casts each element to lie in the range $[-0.5,0.5]$: |
| 1221 |
|
\begin{equation} |
| 1222 |
|
s_{i}^{\prime}=s_{i}-\roundme(s_{i}), |
| 1223 |
|
\end{equation} |
| 1233 |
|
Here $\lfloor x \rfloor$ is the floor operator, and gives the largest |
| 1234 |
|
integer value that is not greater than $x$, and $\lceil x \rceil$ is |
| 1235 |
|
the ceiling operator, and gives the smallest integer that is not less |
| 1236 |
< |
than $x$. For example, $\roundme(3.6)=4$, $\roundme(3.1)=3$, |
| 958 |
< |
$\roundme(-3.6)=-4$, $\roundme(-3.1)=-3$. |
| 1236 |
> |
than $x$. |
| 1237 |
|
|
| 1238 |
< |
Finally, we obtain the minimum image coordinates $\mathbf{r}^{\prime}$ by |
| 1239 |
< |
transforming back to real space, |
| 1238 |
> |
Finally, the minimum image coordinates $\mathbf{r}^{\prime}$ are |
| 1239 |
> |
obtained by transforming back to real space, |
| 1240 |
|
\begin{equation} |
| 1241 |
|
\mathbf{r}^{\prime}=\mathsf{H}^{-1}\mathbf{s}^{\prime}.% |
| 1242 |
|
\end{equation} |
| 1243 |
|
In this way, particles are allowed to diffuse freely in $\mathbf{r}$, |
| 1244 |
< |
but their minimum images, $\mathbf{r}^{\prime}$ are used to compute |
| 1244 |
> |
but their minimum images, or $\mathbf{r}^{\prime}$, are used to compute |
| 1245 |
|
the inter-atomic forces. |
| 1246 |
|
|
| 1247 |
|
|
| 1249 |
|
\section{\label{oopseSec:mechanics}Mechanics} |
| 1250 |
|
|
| 1251 |
|
\subsection{\label{oopseSec:integrate}Integrating the Equations of Motion: the |
| 1252 |
< |
DLM method} |
| 1252 |
> |
{\sc dlm} method} |
| 1253 |
|
|
| 1254 |
|
The default method for integrating the equations of motion in {\sc |
| 1255 |
|
oopse} is a velocity-Verlet version of the symplectic splitting method |
| 1256 |
|
proposed by Dullweber, Leimkuhler and McLachlan |
| 1257 |
< |
(DLM).\cite{Dullweber1997} When there are no directional atoms or |
| 1257 |
> |
({\sc dlm}).\cite{Dullweber1997} When there are no directional atoms or |
| 1258 |
|
rigid bodies present in the simulation, this integrator becomes the |
| 1259 |
|
standard velocity-Verlet integrator which is known to sample the |
| 1260 |
|
microcanonical (NVE) ensemble.\cite{Frenkel1996} |
| 1261 |
|
|
| 1262 |
|
Previous integration methods for orientational motion have problems |
| 1263 |
< |
that are avoided in the DLM method. Direct propagation of the Euler |
| 1263 |
> |
that are avoided in the {\sc dlm} method. Direct propagation of the Euler |
| 1264 |
|
angles has a known $1/\sin\theta$ divergence in the equations of |
| 1265 |
< |
motion for $\phi$ and $\psi$,\cite{allen87:csl} leading to |
| 1266 |
< |
numerical instabilities any time one of the directional atoms or rigid |
| 1267 |
< |
bodies has an orientation near $\theta=0$ or $\theta=\pi$. More |
| 1268 |
< |
modern quaternion-based integration methods have relatively poor |
| 1269 |
< |
energy conservation. While quaternions work well for orientational |
| 1270 |
< |
motion in other ensembles, the microcanonical ensemble has a |
| 1271 |
< |
constant energy requirement that is quite sensitive to errors in the |
| 1272 |
< |
equations of motion. An earlier implementation of {\sc oopse} |
| 1273 |
< |
utilized quaternions for propagation of rotational motion; however, a |
| 1274 |
< |
detailed investigation showed that they resulted in a steady drift in |
| 997 |
< |
the total energy, something that has been observed by |
| 998 |
< |
Laird {\it et al.}\cite{Laird97} |
| 1265 |
> |
motion for $\phi$ and $\psi$,\cite{allen87:csl} leading to numerical |
| 1266 |
> |
instabilities any time one of the directional atoms or rigid bodies |
| 1267 |
> |
has an orientation near $\theta=0$ or $\theta=\pi$. Quaternion-based |
| 1268 |
> |
integration methods work well for propagating orientational motion; |
| 1269 |
> |
however, energy conservation concerns arise when using the |
| 1270 |
> |
microcanonical (NVE) ensemble. An earlier implementation of {\sc |
| 1271 |
> |
oopse} utilized quaternions for propagation of rotational motion; |
| 1272 |
> |
however, a detailed investigation showed that they resulted in a |
| 1273 |
> |
steady drift in the total energy, something that has been observed by |
| 1274 |
> |
Laird {\it et al.}\cite{Laird97} |
| 1275 |
|
|
| 1276 |
|
The key difference in the integration method proposed by Dullweber |
| 1277 |
|
\emph{et al.} is that the entire $3 \times 3$ rotation matrix is |
| 1345 |
|
represented by ${\bf j}$. This equation of motion for angular momenta |
| 1346 |
|
is equivalent to the more familiar body-fixed forms, |
| 1347 |
|
\begin{eqnarray} |
| 1348 |
< |
\dot{j_{x}} & = & \tau^b_x(t) + |
| 1349 |
< |
\left(\overleftrightarrow{\mathsf{I}}_{yy} - \overleftrightarrow{\mathsf{I}}_{zz} \right) j_y j_z, \\ |
| 1350 |
< |
\dot{j_{y}} & = & \tau^b_y(t) + |
| 1351 |
< |
\left(\overleftrightarrow{\mathsf{I}}_{zz} - \overleftrightarrow{\mathsf{I}}_{xx} \right) j_z j_x,\\ |
| 1352 |
< |
\dot{j_{z}} & = & \tau^b_z(t) + |
| 1353 |
< |
\left(\overleftrightarrow{\mathsf{I}}_{xx} - \overleftrightarrow{\mathsf{I}}_{yy} \right) j_x j_y, |
| 1348 |
> |
\dot{j_{x}} & = & \tau^b_x(t) - |
| 1349 |
> |
\left(\overleftrightarrow{\mathsf{I}}_{yy}^{-1} - \overleftrightarrow{\mathsf{I}}_{zz}^{-1} \right) j_y j_z, \\ |
| 1350 |
> |
\dot{j_{y}} & = & \tau^b_y(t) - |
| 1351 |
> |
\left(\overleftrightarrow{\mathsf{I}}_{zz}^{-1} - \overleftrightarrow{\mathsf{I}}_{xx}^{-1} \right) j_z j_x,\\ |
| 1352 |
> |
\dot{j_{z}} & = & \tau^b_z(t) - |
| 1353 |
> |
\left(\overleftrightarrow{\mathsf{I}}_{xx}^{-1} - \overleftrightarrow{\mathsf{I}}_{yy}^{-1} \right) j_x j_y, |
| 1354 |
|
\end{eqnarray} |
| 1355 |
|
which utilize the body-fixed torques, ${\bf \tau}^b$. Torques are |
| 1356 |
|
most easily derived in the space-fixed frame, |
| 1368 |
|
Here $\hat{\bf u}$ is a unit vector pointing along the principal axis |
| 1369 |
|
of the particle in the space-fixed frame. |
| 1370 |
|
|
| 1371 |
< |
The DLM method uses a Trotter factorization of the orientational |
| 1371 |
> |
The {\sc dlm} method uses a Trotter factorization of the orientational |
| 1372 |
|
propagator. This has three effects: |
| 1373 |
|
\begin{enumerate} |
| 1374 |
|
\item the integrator is area-preserving in phase space (i.e. it is |
| 1462 |
|
+ \frac{h}{2} {\bf \tau}^b(t + h) . |
| 1463 |
|
\end{align*} |
| 1464 |
|
|
| 1465 |
< |
The matrix rotations used in the DLM method end up being more costly |
| 1466 |
< |
computationally than the simpler arithmetic quaternion |
| 1467 |
< |
propagation. With the same time step, a 1000-molecule water simulation |
| 1468 |
< |
shows an average 7\% increase in computation time using the DLM method |
| 1469 |
< |
in place of quaternions. This cost is more than justified when |
| 1470 |
< |
comparing the energy conservation of the two methods as illustrated in |
| 1471 |
< |
Fig.~\ref{timestep}. |
| 1465 |
> |
The matrix rotations used in the {\sc dlm} method end up being more |
| 1466 |
> |
costly computationally than the simpler arithmetic quaternion |
| 1467 |
> |
propagation. With the same time step, a 1024-molecule water simulation |
| 1468 |
> |
incurs an average 12\% increase in computation time using the {\sc |
| 1469 |
> |
dlm} method in place of quaternions. This cost is more than justified |
| 1470 |
> |
when comparing the energy conservation achieved by the two |
| 1471 |
> |
methods. Figure ~\ref{quatdlm} provides a comparative analysis of the |
| 1472 |
> |
{\sc dlm} method versus the traditional quaternion scheme. |
| 1473 |
|
|
| 1474 |
|
\begin{figure} |
| 1475 |
|
\centering |
| 1476 |
< |
\includegraphics[width=\linewidth]{timeStep.pdf} |
| 1477 |
< |
\caption[Energy conservation for quaternion versus DLM dynamics]{Energy conservation using quaternion based integration versus |
| 1478 |
< |
the method proposed by Dullweber \emph{et al.} with increasing time |
| 1479 |
< |
step. For each time step, the dotted line is total energy using the |
| 1480 |
< |
DLM integrator, and the solid line comes from the quaternion |
| 1481 |
< |
integrator. The larger time step plots are shifted up from the true |
| 1482 |
< |
energy baseline for clarity.} |
| 1483 |
< |
\label{timestep} |
| 1476 |
> |
\includegraphics[width=\linewidth]{quatvsdlm.eps} |
| 1477 |
> |
\caption[Energy conservation analysis of the {\sc dlm} and quaternion |
| 1478 |
> |
integration methods]{Analysis of the energy conservation of the {\sc |
| 1479 |
> |
dlm} and quaternion integration methods. $\delta \mathrm{E}_1$ is the |
| 1480 |
> |
linear drift in energy over time and $\delta \mathrm{E}_0$ is the |
| 1481 |
> |
standard deviation of energy fluctuations around this drift. All |
| 1482 |
> |
simulations were of a 1024-molecule simulation of SSD water at 298 K |
| 1483 |
> |
starting from the same initial configuration. Note that the {\sc dlm} |
| 1484 |
> |
method provides more than an order of magnitude improvement in both |
| 1485 |
> |
the energy drift and the size of the energy fluctuations when compared |
| 1486 |
> |
with the quaternion method at any given time step. At time steps |
| 1487 |
> |
larger than 4 fs, the quaternion scheme resulted in rapidly rising |
| 1488 |
> |
energies which eventually lead to simulation failure. Using the {\sc |
| 1489 |
> |
dlm} method, time steps up to 8 fs can be taken before this behavior |
| 1490 |
> |
is evident.} |
| 1491 |
> |
\label{quatdlm} |
| 1492 |
|
\end{figure} |
| 1493 |
|
|
| 1494 |
< |
In Fig.~\ref{timestep}, the resulting energy drift at various time |
| 1495 |
< |
steps for both the DLM and quaternion integration schemes is |
| 1496 |
< |
compared. All of the 1000 molecule water simulations started with the |
| 1497 |
< |
same configuration, and the only difference was the method for |
| 1498 |
< |
handling rotational motion. At time steps of 0.1 and 0.5 fs, both |
| 1499 |
< |
methods for propagating molecule rotation conserve energy fairly well, |
| 1500 |
< |
with the quaternion method showing a slight energy drift over time in |
| 1501 |
< |
the 0.5 fs time step simulation. At time steps of 1 and 2 fs, the |
| 1502 |
< |
energy conservation benefits of the DLM method are clearly |
| 1503 |
< |
demonstrated. Thus, while maintaining the same degree of energy |
| 1504 |
< |
conservation, one can take considerably longer time steps, leading to |
| 1505 |
< |
an overall reduction in computation time. |
| 1494 |
> |
In Fig.~\ref{quatdlm}, $\delta \mbox{E}_1$ is a measure of the linear |
| 1495 |
> |
energy drift in units of $\mbox{kcal mol}^{-1}$ per particle over a |
| 1496 |
> |
nanosecond of simulation time, and $\delta \mbox{E}_0$ is the standard |
| 1497 |
> |
deviation of the energy fluctuations in units of $\mbox{kcal |
| 1498 |
> |
mol}^{-1}$ per particle. In the top plot, it is apparent that the |
| 1499 |
> |
energy drift is reduced by a significant amount (2 to 3 orders of |
| 1500 |
> |
magnitude improvement at all tested time steps) by chosing the {\sc |
| 1501 |
> |
dlm} method over the simple non-symplectic quaternion integration |
| 1502 |
> |
method. In addition to this improvement in energy drift, the |
| 1503 |
> |
fluctuations in the total energy are also dampened by 1 to 2 orders of |
| 1504 |
> |
magnitude by utilizing the {\sc dlm} method. |
| 1505 |
> |
|
| 1506 |
> |
Although the {\sc dlm} method is more computationally expensive than |
| 1507 |
> |
the traditional quaternion scheme for propagating a single time step, |
| 1508 |
> |
consideration of the computational cost for a long simulation with a |
| 1509 |
> |
particular level of energy conservation is in order. A plot of energy |
| 1510 |
> |
drift versus computational cost was generated |
| 1511 |
> |
(Fig.~\ref{cpuCost}). This figure provides an estimate of the CPU time |
| 1512 |
> |
required under the two integration schemes for 1 nanosecond of |
| 1513 |
> |
simulation time for the model 1024-molecule system. By chosing a |
| 1514 |
> |
desired energy drift value it is possible to determine the CPU time |
| 1515 |
> |
required for both methods. If a $\delta \mbox{E}_1$ of $1 \times |
| 1516 |
> |
10^{-3} \mbox{kcal mol}^{-1}$ per particle is desired, a nanosecond of |
| 1517 |
> |
simulation time will require ~19 hours of CPU time with the {\sc dlm} |
| 1518 |
> |
integrator, while the quaternion scheme will require ~154 hours of CPU |
| 1519 |
> |
time. This demonstrates the computational advantage of the integration |
| 1520 |
> |
scheme utilized in {\sc oopse}. |
| 1521 |
> |
|
| 1522 |
> |
\begin{figure} |
| 1523 |
> |
\centering |
| 1524 |
> |
\includegraphics[width=\linewidth]{compCost.eps} |
| 1525 |
> |
\caption[Energy drift as a function of required simulation run |
| 1526 |
> |
time]{Energy drift as a function of required simulation run time. |
| 1527 |
> |
$\delta \mathrm{E}_1$ is the linear drift in energy over time. |
| 1528 |
> |
Simulations were performed on a single 2.5 GHz Pentium 4 |
| 1529 |
> |
processor. Simulation time comparisons can be made by tracing |
| 1530 |
> |
horizontally from one curve to the other. For example, a simulation |
| 1531 |
> |
that takes ~24 hours using the {\sc dlm} method will take roughly 210 |
| 1532 |
> |
hours using the simple quaternion method if the same degree of energy |
| 1533 |
> |
conservation is desired.} |
| 1534 |
> |
\label{cpuCost} |
| 1535 |
> |
\end{figure} |
| 1536 |
|
|
| 1537 |
|
There is only one specific keyword relevant to the default integrator, |
| 1538 |
|
and that is the time step for integrating the equations of motion. |
| 1539 |
|
|
| 1540 |
|
\begin{center} |
| 1541 |
|
\begin{tabular}{llll} |
| 1542 |
< |
{\bf variable} & {\bf {\tt .bass} keyword} & {\bf units} & {\bf |
| 1542 |
> |
{\bf variable} & {\bf Meta-data keyword} & {\bf units} & {\bf |
| 1543 |
|
default value} \\ |
| 1544 |
|
$h$ & {\tt dt = 2.0;} & fs & none |
| 1545 |
|
\end{tabular} |
| 1549 |
|
|
| 1550 |
|
{\sc oopse} implements a number of extended system integrators for |
| 1551 |
|
sampling from other ensembles relevant to chemical physics. The |
| 1552 |
< |
integrator can selected with the {\tt ensemble} keyword in the |
| 1553 |
< |
{\tt .bass} file: |
| 1552 |
> |
integrator can be selected with the {\tt ensemble} keyword in the |
| 1553 |
> |
meta-data file: |
| 1554 |
|
|
| 1555 |
|
\begin{center} |
| 1556 |
|
\begin{tabular}{lll} |
| 1557 |
< |
{\bf Integrator} & {\bf Ensemble} & {\bf {\tt .bass} line} \\ |
| 1557 |
> |
{\bf Integrator} & {\bf Ensemble} & {\bf Meta-data instruction} \\ |
| 1558 |
|
NVE & microcanonical & {\tt ensemble = NVE; } \\ |
| 1559 |
|
NVT & canonical & {\tt ensemble = NVT; } \\ |
| 1560 |
|
NPTi & isobaric-isothermal & {\tt ensemble = NPTi;} \\ |
| 1569 |
|
The relatively well-known Nos\'e-Hoover thermostat\cite{Hoover85} is |
| 1570 |
|
implemented in {\sc oopse}'s NVT integrator. This method couples an |
| 1571 |
|
extra degree of freedom (the thermostat) to the kinetic energy of the |
| 1572 |
< |
system, and has been shown to sample the canonical distribution in the |
| 1573 |
< |
system degrees of freedom while conserving a quantity that is, to |
| 1572 |
> |
system and it has been shown to sample the canonical distribution in |
| 1573 |
> |
the system degrees of freedom while conserving a quantity that is, to |
| 1574 |
|
within a constant, the Helmholtz free energy.\cite{melchionna93} |
| 1575 |
|
|
| 1576 |
|
NPT algorithms attempt to maintain constant pressure in the system by |
| 1594 |
|
|
| 1595 |
|
\begin{center} |
| 1596 |
|
\begin{tabular}{llll} |
| 1597 |
< |
{\bf variable} & {\bf {\tt .bass} keyword} & {\bf units} & {\bf |
| 1597 |
> |
{\bf variable} & {\bf Meta-data instruction} & {\bf units} & {\bf |
| 1598 |
|
default value} \\ |
| 1599 |
|
$T_{\mathrm{target}}$ & {\tt targetTemperature = 300;} & K & none \\ |
| 1600 |
|
$P_{\mathrm{target}}$ & {\tt targetPressure = 1;} & atm & none \\ |
| 1640 |
|
\end{equation} |
| 1641 |
|
Here, $f$ is the total number of degrees of freedom in the system, |
| 1642 |
|
\begin{equation} |
| 1643 |
< |
f = 3 N + 3 N_{\mathrm{orient}} - N_{\mathrm{constraints}}, |
| 1643 |
> |
f = 3 N + 2 N_{\mathrm{linear}} + 3 N_{\mathrm{non-linear}} - N_{\mathrm{constraints}}, |
| 1644 |
|
\end{equation} |
| 1645 |
|
and $K$ is the total kinetic energy, |
| 1646 |
|
\begin{equation} |
| 1647 |
|
K = \sum_{i=1}^{N} \frac{1}{2} m_i {\bf v}_i^T \cdot {\bf v}_i + |
| 1648 |
< |
\sum_{i=1}^{N_{\mathrm{orient}}} \frac{1}{2} {\bf j}_i^T \cdot |
| 1648 |
> |
\sum_{i=1}^{N_{\mathrm{linear}}+N_{\mathrm{non-linear}}} \frac{1}{2} {\bf j}_i^T \cdot |
| 1649 |
|
\overleftrightarrow{\mathsf{I}}_i^{-1} \cdot {\bf j}_i. |
| 1650 |
|
\end{equation} |
| 1651 |
+ |
$N_{\mathrm{linear}}$ is the number of linear rotors (i.e. with two |
| 1652 |
+ |
non-zero moments of inertia), and $N_{\mathrm{non-linear}}$ is the |
| 1653 |
+ |
number of non-linear rotors (i.e. with three non-zero moments of |
| 1654 |
+ |
inertia). |
| 1655 |
|
|
| 1656 |
|
In eq.(\ref{eq:nosehooverext}), $\tau_T$ is the time constant for |
| 1657 |
|
relaxation of the temperature to the target value. To set values for |
| 1658 |
|
$\tau_T$ or $T_{\mathrm{target}}$ in a simulation, one would use the |
| 1659 |
< |
{\tt tauThermostat} and {\tt targetTemperature} keywords in the {\tt |
| 1660 |
< |
.bass} file. The units for {\tt tauThermostat} are fs, and the units |
| 1661 |
< |
for the {\tt targetTemperature} are degrees K. The integration of |
| 1662 |
< |
the equations of motion is carried out in a velocity-Verlet style 2 |
| 1659 |
> |
{\tt tauThermostat} and {\tt targetTemperature} keywords in the |
| 1660 |
> |
meta-data file. The units for {\tt tauThermostat} are fs, and the |
| 1661 |
> |
units for the {\tt targetTemperature} are degrees K. The integration |
| 1662 |
> |
of the equations of motion is carried out in a velocity-Verlet style 2 |
| 1663 |
|
part algorithm: |
| 1664 |
|
|
| 1665 |
|
{\tt moveA:} |
| 1689 |
|
Here $\mathrm{rotate}(h * {\bf j} |
| 1690 |
|
\overleftrightarrow{\mathsf{I}}^{-1})$ is the same symplectic Trotter |
| 1691 |
|
factorization of the three rotation operations that was discussed in |
| 1692 |
< |
the section on the DLM integrator. Note that this operation modifies |
| 1692 |
> |
the section on the {\sc dlm} integrator. Note that this operation modifies |
| 1693 |
|
both the rotation matrix $\mathsf{A}$ and the angular momentum ${\bf |
| 1694 |
|
j}$. {\tt moveA} propagates velocities by a half time step, and |
| 1695 |
|
positional degrees of freedom by a full time step. The new positions |
| 1696 |
|
(and orientations) are then used to calculate a new set of forces and |
| 1697 |
|
torques in exactly the same way they are calculated in the {\tt |
| 1698 |
< |
doForces} portion of the DLM integrator. |
| 1698 |
> |
doForces} portion of the {\sc dlm} integrator. |
| 1699 |
|
|
| 1700 |
|
Once the forces and torques have been obtained at the new time step, |
| 1701 |
|
the temperature, velocities, and the extended system variable can be |
| 1721 |
|
\chi(t + h) \right) . |
| 1722 |
|
\end{align*} |
| 1723 |
|
|
| 1724 |
< |
Since ${\bf v}(t + h)$ and ${\bf j}(t + h)$ are required to caclculate |
| 1724 |
> |
Since ${\bf v}(t + h)$ and ${\bf j}(t + h)$ are required to calculate |
| 1725 |
|
$T(t + h)$ as well as $\chi(t + h)$, they indirectly depend on their |
| 1726 |
|
own values at time $t + h$. {\tt moveB} is therefore done in an |
| 1727 |
|
iterative fashion until $\chi(t + h)$ becomes self-consistent. The |
| 1749 |
|
\subsection{\label{sec:NPTi}Constant-pressure integration with |
| 1750 |
|
isotropic box deformations (NPTi)} |
| 1751 |
|
|
| 1752 |
< |
To carry out isobaric-isothermal ensemble calculations {\sc oopse} |
| 1752 |
> |
To carry out isobaric-isothermal ensemble calculations, {\sc oopse} |
| 1753 |
|
implements the Melchionna modifications to the Nos\'e-Hoover-Andersen |
| 1754 |
< |
equations of motion,\cite{melchionna93} |
| 1754 |
> |
equations of motion.\cite{melchionna93} The equations of motion are |
| 1755 |
> |
the same as NVT with the following exceptions: |
| 1756 |
|
|
| 1757 |
|
\begin{eqnarray} |
| 1758 |
|
\dot{{\bf r}} & = & {\bf v} + \eta \left( {\bf r} - {\bf R}_0 \right), \\ |
| 1759 |
|
\dot{{\bf v}} & = & \frac{{\bf f}}{m} - (\eta + \chi) {\bf v}, \\ |
| 1440 |
– |
\dot{\mathsf{A}} & = & \mathsf{A} \cdot |
| 1441 |
– |
\mbox{ skew}\left(\overleftrightarrow{I}^{-1} \cdot {\bf j}\right),\\ |
| 1442 |
– |
\dot{{\bf j}} & = & {\bf j} \times \left( \overleftrightarrow{I}^{-1} |
| 1443 |
– |
\cdot {\bf j} \right) - \mbox{ rot}\left(\mathsf{A}^{T} \cdot \frac{\partial |
| 1444 |
– |
V}{\partial \mathsf{A}} \right) - \chi {\bf j}, \\ |
| 1445 |
– |
\dot{\chi} & = & \frac{1}{\tau_{T}^2} \left( |
| 1446 |
– |
\frac{T}{T_{\mathrm{target}}} - 1 \right) ,\\ |
| 1760 |
|
\dot{\eta} & = & \frac{1}{\tau_{B}^2 f k_B T_{\mathrm{target}}} V \left( P - |
| 1761 |
|
P_{\mathrm{target}} \right), \\ |
| 1762 |
|
\dot{\mathcal{V}} & = & 3 \mathcal{V} \eta . |
| 1783 |
|
\overleftrightarrow{\mathsf{W}}(t). |
| 1784 |
|
\end{equation} |
| 1785 |
|
The kinetic contribution to the pressure tensor utilizes the {\it |
| 1786 |
< |
outer} product of the velocities denoted by the $\otimes$ symbol. The |
| 1786 |
> |
outer} product of the velocities, denoted by the $\otimes$ symbol. The |
| 1787 |
|
stress tensor is calculated from another outer product of the |
| 1788 |
|
inter-atomic separation vectors (${\bf r}_{ij} = {\bf r}_j - {\bf |
| 1789 |
|
r}_i$) with the forces between the same two atoms, |
| 1791 |
|
\overleftrightarrow{\mathsf{W}}(t) = \sum_{i} \sum_{j>i} {\bf r}_{ij}(t) |
| 1792 |
|
\otimes {\bf f}_{ij}(t). |
| 1793 |
|
\end{equation} |
| 1794 |
+ |
In systems containing cutoff groups, the stress tensor is computed |
| 1795 |
+ |
between the centers-of-mass of the cutoff groups: |
| 1796 |
+ |
\begin{equation} |
| 1797 |
+ |
\overleftrightarrow{\mathsf{W}}(t) = \sum_{a} \sum_{b} {\bf r}_{ab}(t) |
| 1798 |
+ |
\otimes {\bf f}_{ab}(t). |
| 1799 |
+ |
\end{equation} |
| 1800 |
+ |
where ${\bf r}_{ab}$ is the distance between the centers of mass, and |
| 1801 |
+ |
\begin{equation} |
| 1802 |
+ |
{\bf f}_{ab} = s(r_{ab}) \sum_{i \in a} \sum_{j \in b} {\bf f}_{ij} + |
| 1803 |
+ |
s^{\prime}(r_{ab}) \frac{{\bf r}_{ab}}{|r_{ab}|} \sum_{i \in a} \sum_{j |
| 1804 |
+ |
\in b} V_{ij}({\bf r}_{ij}). |
| 1805 |
+ |
\end{equation} |
| 1806 |
+ |
|
| 1807 |
|
The instantaneous pressure is then simply obtained from the trace of |
| 1808 |
< |
the Pressure tensor, |
| 1808 |
> |
the pressure tensor, |
| 1809 |
|
\begin{equation} |
| 1810 |
< |
P(t) = \frac{1}{3} \mathrm{Tr} \left( \overleftrightarrow{\mathsf{P}}(t). |
| 1811 |
< |
\right) |
| 1810 |
> |
P(t) = \frac{1}{3} \mathrm{Tr} \left( \overleftrightarrow{\mathsf{P}}(t) |
| 1811 |
> |
\right). |
| 1812 |
|
\end{equation} |
| 1813 |
|
|
| 1814 |
|
In eq.(\ref{eq:melchionna1}), $\tau_B$ is the time constant for |
| 1815 |
|
relaxation of the pressure to the target value. To set values for |
| 1816 |
|
$\tau_B$ or $P_{\mathrm{target}}$ in a simulation, one would use the |
| 1817 |
< |
{\tt tauBarostat} and {\tt targetPressure} keywords in the {\tt .bass} |
| 1817 |
> |
{\tt tauBarostat} and {\tt targetPressure} keywords in the meta-data |
| 1818 |
|
file. The units for {\tt tauBarostat} are fs, and the units for the |
| 1819 |
|
{\tt targetPressure} are atmospheres. Like in the NVT integrator, the |
| 1820 |
|
integration of the equations of motion is carried out in a |
| 1821 |
< |
velocity-Verlet style 2 part algorithm: |
| 1821 |
> |
velocity-Verlet style two part algorithm with only the following |
| 1822 |
> |
differences: |
| 1823 |
|
|
| 1824 |
|
{\tt moveA:} |
| 1825 |
|
\begin{align*} |
| 1499 |
– |
T(t) &\leftarrow \left\{{\bf v}(t)\right\}, \left\{{\bf j}(t)\right\} ,\\ |
| 1500 |
– |
% |
| 1826 |
|
P(t) &\leftarrow \left\{{\bf r}(t)\right\}, \left\{{\bf v}(t)\right\} ,\\ |
| 1827 |
|
% |
| 1828 |
|
{\bf v}\left(t + h / 2\right) &\leftarrow {\bf v}(t) |
| 1829 |
|
+ \frac{h}{2} \left( \frac{{\bf f}(t)}{m} - {\bf v}(t) |
| 1830 |
|
\left(\chi(t) + \eta(t) \right) \right), \\ |
| 1831 |
|
% |
| 1507 |
– |
{\bf j}\left(t + h / 2 \right) &\leftarrow {\bf j}(t) |
| 1508 |
– |
+ \frac{h}{2} \left( {\bf \tau}^b(t) - {\bf j}(t) |
| 1509 |
– |
\chi(t) \right), \\ |
| 1510 |
– |
% |
| 1511 |
– |
\mathsf{A}(t + h) &\leftarrow \mathrm{rotate}\left(h * |
| 1512 |
– |
{\bf j}(t + h / 2) \overleftrightarrow{\mathsf{I}}^{-1} |
| 1513 |
– |
\right) ,\\ |
| 1514 |
– |
% |
| 1515 |
– |
\chi\left(t + h / 2 \right) &\leftarrow \chi(t) + |
| 1516 |
– |
\frac{h}{2 \tau_T^2} \left( \frac{T(t)}{T_{\mathrm{target}}} - 1 |
| 1517 |
– |
\right) ,\\ |
| 1518 |
– |
% |
| 1832 |
|
\eta(t + h / 2) &\leftarrow \eta(t) + \frac{h |
| 1833 |
|
\mathcal{V}(t)}{2 N k_B T(t) \tau_B^2} \left( P(t) |
| 1834 |
|
- P_{\mathrm{target}} \right), \\ |
| 1842 |
|
\mathsf{H}(t). |
| 1843 |
|
\end{align*} |
| 1844 |
|
|
| 1845 |
< |
Most of these equations are identical to their counterparts in the NVT |
| 1533 |
< |
integrator, but the propagation of positions to time $t + h$ |
| 1845 |
> |
The propagation of positions to time $t + h$ |
| 1846 |
|
depends on the positions at the same time. {\sc oopse} carries out |
| 1847 |
|
this step iteratively (with a limit of 5 passes through the iterative |
| 1848 |
|
loop). Also, the simulation box $\mathsf{H}$ is scaled uniformly for |
| 1851 |
|
h / 2$. Reshaping the box uniformly also scales the volume of |
| 1852 |
|
the box by |
| 1853 |
|
\begin{equation} |
| 1854 |
< |
\mathcal{V}(t + h) \leftarrow e^{ - 3 h \eta(t + h /2)}. |
| 1855 |
< |
\mathcal{V}(t) |
| 1854 |
> |
\mathcal{V}(t + h) \leftarrow e^{ - 3 h \eta(t + h /2)} \times |
| 1855 |
> |
\mathcal{V}(t). |
| 1856 |
|
\end{equation} |
| 1857 |
|
|
| 1858 |
|
The {\tt doForces} step for the NPTi integrator is exactly the same as |
| 1859 |
< |
in both the DLM and NVT integrators. Once the forces and torques have |
| 1859 |
> |
in both the {\sc dlm} and NVT integrators. Once the forces and torques have |
| 1860 |
|
been obtained at the new time step, the velocities can be advanced to |
| 1861 |
|
the same time value. |
| 1862 |
|
|
| 1863 |
|
{\tt moveB:} |
| 1864 |
|
\begin{align*} |
| 1553 |
– |
T(t + h) &\leftarrow \left\{{\bf v}(t + h)\right\}, |
| 1554 |
– |
\left\{{\bf j}(t + h)\right\} ,\\ |
| 1555 |
– |
% |
| 1865 |
|
P(t + h) &\leftarrow \left\{{\bf r}(t + h)\right\}, |
| 1866 |
|
\left\{{\bf v}(t + h)\right\}, \\ |
| 1867 |
|
% |
| 1559 |
– |
\chi\left(t + h \right) &\leftarrow \chi\left(t + h / |
| 1560 |
– |
2 \right) + \frac{h}{2 \tau_T^2} \left( \frac{T(t+h)} |
| 1561 |
– |
{T_{\mathrm{target}}} - 1 \right), \\ |
| 1562 |
– |
% |
| 1868 |
|
\eta(t + h) &\leftarrow \eta(t + h / 2) + |
| 1869 |
|
\frac{h \mathcal{V}(t + h)}{2 N k_B T(t + h) |
| 1870 |
|
\tau_B^2} \left( P(t + h) - P_{\mathrm{target}} \right), \\ |
| 1881 |
|
\end{align*} |
| 1882 |
|
|
| 1883 |
|
Once again, since ${\bf v}(t + h)$ and ${\bf j}(t + h)$ are required |
| 1884 |
< |
to caclculate $T(t + h)$, $P(t + h)$, $\chi(t + h)$, and $\eta(t + |
| 1884 |
> |
to calculate $T(t + h)$, $P(t + h)$, $\chi(t + h)$, and $\eta(t + |
| 1885 |
|
h)$, they indirectly depend on their own values at time $t + h$. {\tt |
| 1886 |
|
moveB} is therefore done in an iterative fashion until $\chi(t + h)$ |
| 1887 |
|
and $\eta(t + h)$ become self-consistent. The relative tolerance for |
| 1921 |
|
{\it shape} as well as in the volume of the box. This method utilizes |
| 1922 |
|
the full $3 \times 3$ pressure tensor and introduces a tensor of |
| 1923 |
|
extended variables ($\overleftrightarrow{\eta}$) to control changes to |
| 1924 |
< |
the box shape. The equations of motion for this method are |
| 1924 |
> |
the box shape. The equations of motion for this method differ from |
| 1925 |
> |
those of NPTi as follows: |
| 1926 |
|
\begin{eqnarray} |
| 1927 |
|
\dot{{\bf r}} & = & {\bf v} + \overleftrightarrow{\eta} \cdot \left( {\bf r} - {\bf R}_0 \right), \\ |
| 1928 |
|
\dot{{\bf v}} & = & \frac{{\bf f}}{m} - (\overleftrightarrow{\eta} + |
| 1929 |
|
\chi \cdot \mathsf{1}) {\bf v}, \\ |
| 1624 |
– |
\dot{\mathsf{A}} & = & \mathsf{A} \cdot |
| 1625 |
– |
\mbox{ skew}\left(\overleftrightarrow{I}^{-1} \cdot {\bf j}\right) ,\\ |
| 1626 |
– |
\dot{{\bf j}} & = & {\bf j} \times \left( \overleftrightarrow{I}^{-1} |
| 1627 |
– |
\cdot {\bf j} \right) - \mbox{ rot}\left(\mathsf{A}^{T} \cdot \frac{\partial |
| 1628 |
– |
V}{\partial \mathsf{A}} \right) - \chi {\bf j} ,\\ |
| 1629 |
– |
\dot{\chi} & = & \frac{1}{\tau_{T}^2} \left( |
| 1630 |
– |
\frac{T}{T_{\mathrm{target}}} - 1 \right) ,\\ |
| 1930 |
|
\dot{\overleftrightarrow{\eta}} & = & \frac{1}{\tau_{B}^2 f k_B |
| 1931 |
|
T_{\mathrm{target}}} V \left( \overleftrightarrow{\mathsf{P}} - P_{\mathrm{target}}\mathsf{1} \right) ,\\ |
| 1932 |
|
\dot{\mathsf{H}} & = & \overleftrightarrow{\eta} \cdot \mathsf{H} . |
| 1942 |
|
|
| 1943 |
|
{\tt moveA:} |
| 1944 |
|
\begin{align*} |
| 1646 |
– |
T(t) &\leftarrow \left\{{\bf v}(t)\right\}, \left\{{\bf j}(t)\right\} ,\\ |
| 1647 |
– |
% |
| 1945 |
|
\overleftrightarrow{\mathsf{P}}(t) &\leftarrow \left\{{\bf r}(t)\right\}, |
| 1946 |
|
\left\{{\bf v}(t)\right\} ,\\ |
| 1947 |
|
% |
| 1950 |
|
\left(\chi(t)\mathsf{1} + \overleftrightarrow{\eta}(t) \right) \cdot |
| 1951 |
|
{\bf v}(t) \right), \\ |
| 1952 |
|
% |
| 1656 |
– |
{\bf j}\left(t + h / 2 \right) &\leftarrow {\bf j}(t) |
| 1657 |
– |
+ \frac{h}{2} \left( {\bf \tau}^b(t) - {\bf j}(t) |
| 1658 |
– |
\chi(t) \right), \\ |
| 1659 |
– |
% |
| 1660 |
– |
\mathsf{A}(t + h) &\leftarrow \mathrm{rotate}\left(h * |
| 1661 |
– |
{\bf j}(t + h / 2) \overleftrightarrow{\mathsf{I}}^{-1} |
| 1662 |
– |
\right), \\ |
| 1663 |
– |
% |
| 1664 |
– |
\chi\left(t + h / 2 \right) &\leftarrow \chi(t) + |
| 1665 |
– |
\frac{h}{2 \tau_T^2} \left( \frac{T(t)}{T_{\mathrm{target}}} |
| 1666 |
– |
- 1 \right), \\ |
| 1667 |
– |
% |
| 1953 |
|
\overleftrightarrow{\eta}(t + h / 2) &\leftarrow |
| 1954 |
|
\overleftrightarrow{\eta}(t) + \frac{h \mathcal{V}(t)}{2 N k_B |
| 1955 |
|
T(t) \tau_B^2} \left( \overleftrightarrow{\mathsf{P}}(t) |
| 1971 |
|
|
| 1972 |
|
{\tt moveB:} |
| 1973 |
|
\begin{align*} |
| 1689 |
– |
T(t + h) &\leftarrow \left\{{\bf v}(t + h)\right\}, |
| 1690 |
– |
\left\{{\bf j}(t + h)\right\}, \\ |
| 1691 |
– |
% |
| 1974 |
|
\overleftrightarrow{\mathsf{P}}(t + h) &\leftarrow \left\{{\bf r} |
| 1975 |
|
(t + h)\right\}, \left\{{\bf v}(t |
| 1976 |
|
+ h)\right\}, \left\{{\bf f}(t + h)\right\} ,\\ |
| 1977 |
|
% |
| 1696 |
– |
\chi\left(t + h \right) &\leftarrow \chi\left(t + h / |
| 1697 |
– |
2 \right) + \frac{h}{2 \tau_T^2} \left( \frac{T(t+ |
| 1698 |
– |
h)}{T_{\mathrm{target}}} - 1 \right), \\ |
| 1699 |
– |
% |
| 1978 |
|
\overleftrightarrow{\eta}(t + h) &\leftarrow |
| 1979 |
|
\overleftrightarrow{\eta}(t + h / 2) + |
| 1980 |
|
\frac{h \mathcal{V}(t + h)}{2 N k_B T(t + h) |
| 1986 |
|
\frac{{\bf f}(t + h)}{m} - |
| 1987 |
|
(\chi(t + h)\mathsf{1} + \overleftrightarrow{\eta}(t |
| 1988 |
|
+ h)) \right) \cdot {\bf v}(t + h), \\ |
| 1711 |
– |
% |
| 1712 |
– |
{\bf j}\left(t + h \right) &\leftarrow {\bf j}\left(t |
| 1713 |
– |
+ h / 2 \right) + \frac{h}{2} \left( {\bf \tau}^b(t |
| 1714 |
– |
+ h) - {\bf j}(t + h) \chi(t + h) \right) . |
| 1989 |
|
\end{align*} |
| 1990 |
|
|
| 1991 |
|
The iterative schemes for both {\tt moveA} and {\tt moveB} are |
| 2003 |
|
This integrator must be used with care, particularly in liquid |
| 2004 |
|
simulations. Liquids have very small restoring forces in the |
| 2005 |
|
off-diagonal directions, and the simulation box can very quickly form |
| 2006 |
< |
elongated and sheared geometries which become smaller than the |
| 2007 |
< |
electrostatic or Lennard-Jones cutoff radii. The NPTf integrator |
| 2008 |
< |
finds most use in simulating crystals or liquid crystals which assume |
| 1735 |
< |
non-orthorhombic geometries. |
| 2006 |
> |
elongated and sheared geometries which become smaller than the cutoff |
| 2007 |
> |
radius. The NPTf integrator finds most use in simulating crystals or |
| 2008 |
> |
liquid crystals which assume non-orthorhombic geometries. |
| 2009 |
|
|
| 2010 |
|
\subsection{\label{nptxyz}Constant pressure in 3 axes (NPTxyz)} |
| 2011 |
|
|
| 2035 |
|
|
| 2036 |
|
In order to satisfy the constraints of fixed bond lengths within {\sc |
| 2037 |
|
oopse}, we have implemented the {\sc rattle} algorithm of |
| 2038 |
< |
Andersen.\cite{andersen83} The algorithm is a velocity verlet |
| 2039 |
< |
formulation of the {\sc shake} method\cite{ryckaert77} of iteratively |
| 2040 |
< |
solving the Lagrange multipliers of constraint. |
| 2038 |
> |
Andersen.\cite{andersen83} {\sc rattle} is a velocity-Verlet |
| 2039 |
> |
formulation of the {\sc shake} method\cite{ryckaert77} for iteratively |
| 2040 |
> |
solving the Lagrange multipliers which maintain the holonomic |
| 2041 |
> |
constraints. Both methods are covered in depth in the |
| 2042 |
> |
literature,\cite{leach01:mm,allen87:csl} and a detailed description of |
| 2043 |
> |
this method would be redundant. |
| 2044 |
|
|
| 2045 |
< |
\subsubsection{\label{oopseSec:zcons}Z-Constraint Method} |
| 2045 |
> |
\subsubsection{\label{oopseSec:zcons}The Z-Constraint Method} |
| 2046 |
|
|
| 2047 |
< |
Based on the fluctuation-dissipation theorem, a force auto-correlation |
| 2048 |
< |
method was developed by Roux and Karplus to investigate the dynamics |
| 2047 |
> |
A force auto-correlation method based on the fluctuation-dissipation |
| 2048 |
> |
theorem was developed by Roux and Karplus to investigate the dynamics |
| 2049 |
|
of ions inside ion channels.\cite{Roux91} The time-dependent friction |
| 2050 |
|
coefficient can be calculated from the deviation of the instantaneous |
| 2051 |
< |
force from its mean force. |
| 2051 |
> |
force from its mean value: |
| 2052 |
|
\begin{equation} |
| 2053 |
|
\xi(z,t)=\langle\delta F(z,t)\delta F(z,0)\rangle/k_{B}T, |
| 2054 |
|
\end{equation} |
| 2057 |
|
\delta F(z,t)=F(z,t)-\langle F(z,t)\rangle. |
| 2058 |
|
\end{equation} |
| 2059 |
|
|
| 1784 |
– |
|
| 2060 |
|
If the time-dependent friction decays rapidly, the static friction |
| 2061 |
|
coefficient can be approximated by |
| 2062 |
|
\begin{equation} |
| 2063 |
|
\xi_{\text{static}}(z)=\int_{0}^{\infty}\langle\delta F(z,t)\delta F(z,0)\rangle dt. |
| 2064 |
|
\end{equation} |
| 2065 |
< |
Allowing diffusion constant to then be calculated through the |
| 2065 |
> |
|
| 2066 |
> |
This allows the diffusion constant to then be calculated through the |
| 2067 |
|
Einstein relation:\cite{Marrink94} |
| 2068 |
|
\begin{equation} |
| 2069 |
|
D(z)=\frac{k_{B}T}{\xi_{\text{static}}(z)}=\frac{(k_{B}T)^{2}}{\int_{0}^{\infty |
| 2070 |
|
}\langle\delta F(z,t)\delta F(z,0)\rangle dt}.% |
| 2071 |
|
\end{equation} |
| 2072 |
|
|
| 2073 |
< |
The Z-Constraint method, which fixes the z coordinates of the |
| 2074 |
< |
molecules with respect to the center of the mass of the system, has |
| 2075 |
< |
been a method suggested to obtain the forces required for the force |
| 2076 |
< |
auto-correlation calculation.\cite{Marrink94} However, simply resetting the |
| 2077 |
< |
coordinate will move the center of the mass of the whole system. To |
| 2078 |
< |
avoid this problem, a new method was used in {\sc oopse}. Instead of |
| 2079 |
< |
resetting the coordinate, we reset the forces of z-constrained |
| 2080 |
< |
molecules as well as subtract the total constraint forces from the |
| 2081 |
< |
rest of the system after the force calculation at each time step. |
| 2073 |
> |
The Z-Constraint method, which fixes the $z$ coordinates of a few |
| 2074 |
> |
``tagged'' molecules with respect to the center of the mass of the |
| 2075 |
> |
system is a technique that was proposed to obtain the forces required |
| 2076 |
> |
for the force auto-correlation calculation.\cite{Marrink94} However, |
| 2077 |
> |
simply resetting the coordinate will move the center of the mass of |
| 2078 |
> |
the whole system. To avoid this problem, we have developed a new |
| 2079 |
> |
method that is utilized in {\sc oopse}. Instead of resetting the |
| 2080 |
> |
coordinates, we reset the forces of $z$-constrained molecules and |
| 2081 |
> |
subtract the total constraint forces from the rest of the system after |
| 2082 |
> |
the force calculation at each time step. |
| 2083 |
|
|
| 2084 |
< |
After the force calculation, define $G_\alpha$ as |
| 2084 |
> |
After the force calculation, the total force on molecule $\alpha$ is: |
| 2085 |
|
\begin{equation} |
| 2086 |
|
G_{\alpha} = \sum_i F_{\alpha i}, |
| 2087 |
|
\label{oopseEq:zc1} |
| 2088 |
|
\end{equation} |
| 2089 |
< |
where $F_{\alpha i}$ is the force in the z direction of atom $i$ in |
| 2090 |
< |
z-constrained molecule $\alpha$. The forces of the z constrained |
| 2091 |
< |
molecule are then set to: |
| 2089 |
> |
where $F_{\alpha i}$ is the force in the $z$ direction on atom $i$ in |
| 2090 |
> |
$z$-constrained molecule $\alpha$. The forces on the atoms in the |
| 2091 |
> |
$z$-constrained molecule are then adjusted to remove the total force |
| 2092 |
> |
on molecule $\alpha$: |
| 2093 |
|
\begin{equation} |
| 2094 |
|
F_{\alpha i} = F_{\alpha i} - |
| 2095 |
|
\frac{m_{\alpha i} G_{\alpha}}{\sum_i m_{\alpha i}}. |
| 2096 |
|
\end{equation} |
| 2097 |
< |
Here, $m_{\alpha i}$ is the mass of atom $i$ in the z-constrained |
| 2098 |
< |
molecule. Having rescaled the forces, the velocities must also be |
| 2099 |
< |
rescaled to subtract out any center of mass velocity in the z |
| 2100 |
< |
direction. |
| 2097 |
> |
Here, $m_{\alpha i}$ is the mass of atom $i$ in the $z$-constrained |
| 2098 |
> |
molecule. After the forces have been adjusted, the velocities must |
| 2099 |
> |
also be modified to subtract out molecule $\alpha$'s center-of-mass |
| 2100 |
> |
velocity in the $z$ direction. |
| 2101 |
|
\begin{equation} |
| 2102 |
|
v_{\alpha i} = v_{\alpha i} - |
| 2103 |
|
\frac{\sum_i m_{\alpha i} v_{\alpha i}}{\sum_i m_{\alpha i}}, |
| 2104 |
|
\end{equation} |
| 2105 |
< |
where $v_{\alpha i}$ is the velocity of atom $i$ in the z direction. |
| 2106 |
< |
Lastly, all of the accumulated z constrained forces must be subtracted |
| 2107 |
< |
from the system to keep the system center of mass from drifting. |
| 2105 |
> |
where $v_{\alpha i}$ is the velocity of atom $i$ in the $z$ direction. |
| 2106 |
> |
Lastly, all of the accumulated constraint forces must be subtracted |
| 2107 |
> |
from the rest of the unconstrained system to keep the system center of |
| 2108 |
> |
mass of the entire system from drifting. |
| 2109 |
|
\begin{equation} |
| 2110 |
|
F_{\beta i} = F_{\beta i} - \frac{m_{\beta i} \sum_{\alpha} G_{\alpha}} |
| 2111 |
|
{\sum_{\beta}\sum_i m_{\beta i}}, |
| 2112 |
|
\end{equation} |
| 2113 |
< |
where $\beta$ are all of the unconstrained molecules in the |
| 2113 |
> |
where $\beta$ denotes all {\it unconstrained} molecules in the |
| 2114 |
|
system. Similarly, the velocities of the unconstrained molecules must |
| 2115 |
< |
also be scaled. |
| 2115 |
> |
also be scaled: |
| 2116 |
|
\begin{equation} |
| 2117 |
< |
v_{\beta i} = v_{\beta i} + \sum_{\alpha} |
| 2118 |
< |
\frac{\sum_i m_{\alpha i} v_{\alpha i}}{\sum_i m_{\alpha i}}. |
| 2117 |
> |
v_{\beta i} = v_{\beta i} + \sum_{\alpha} \frac{\sum_i m_{\alpha i} |
| 2118 |
> |
v_{\alpha i}}{\sum_i m_{\alpha i}}. |
| 2119 |
|
\end{equation} |
| 2120 |
|
|
| 2121 |
< |
At the very beginning of the simulation, the molecules may not be at their |
| 2122 |
< |
constrained positions. To move a z-constrained molecule to its specified |
| 2123 |
< |
position, a simple harmonic potential is used |
| 2121 |
> |
This method will pin down the centers-of-mass of all of the |
| 2122 |
> |
$z$-constrained molecules, and will also keep the entire system fixed |
| 2123 |
> |
at the original system center-of-mass location. |
| 2124 |
> |
|
| 2125 |
> |
At the very beginning of the simulation, the molecules may not be at |
| 2126 |
> |
their desired positions. To steer a $z$-constrained molecule to its |
| 2127 |
> |
specified position, a simple harmonic potential is used: |
| 2128 |
|
\begin{equation} |
| 2129 |
|
U(t)=\frac{1}{2}k_{\text{Harmonic}}(z(t)-z_{\text{cons}})^{2},% |
| 2130 |
|
\end{equation} |
| 2131 |
< |
where $k_{\text{Harmonic}}$ is the harmonic force constant, $z(t)$ is the |
| 2132 |
< |
current $z$ coordinate of the center of mass of the constrained molecule, and |
| 2133 |
< |
$z_{\text{cons}}$ is the constrained position. The harmonic force operating |
| 2134 |
< |
on the z-constrained molecule at time $t$ can be calculated by |
| 2131 |
> |
where $k_{\text{Harmonic}}$ is an harmonic force constant, $z(t)$ is |
| 2132 |
> |
the current $z$ coordinate of the center of mass of the constrained |
| 2133 |
> |
molecule, and $z_{\text{cons}}$ is the desired constraint |
| 2134 |
> |
position. The harmonic force operating on the $z$-constrained molecule |
| 2135 |
> |
at time $t$ can be calculated by |
| 2136 |
|
\begin{equation} |
| 2137 |
|
F_{z_{\text{Harmonic}}}(t)=-\frac{\partial U(t)}{\partial z(t)}= |
| 2138 |
|
-k_{\text{Harmonic}}(z(t)-z_{\text{cons}}). |
| 2139 |
|
\end{equation} |
| 2140 |
|
|
| 2141 |
< |
\section{\label{oopseSec:design}Program Design} |
| 2141 |
> |
The user may also specify the use of a constant velocity method |
| 2142 |
> |
(steered molecular dynamics) to move the molecules to their desired |
| 2143 |
> |
initial positions. Based on concepts from atomic force microscopy, |
| 2144 |
> |
{\sc smd} has been used to study many processes which occur via rare |
| 2145 |
> |
events on the time scale of a few hundreds of picoseconds. For |
| 2146 |
> |
example,{\sc smd} has been used to observe the dissociation of |
| 2147 |
> |
Streptavidin-biotin Complex.\cite{smd} |
| 2148 |
|
|
| 2149 |
< |
\subsection{\label{sec:architecture} {\sc oopse} Architecture} |
| 2149 |
> |
To use of the $z$-constraint method in an {\sc oopse} simulation, the |
| 2150 |
> |
molecules must be specified using the {\tt nZconstraints} keyword in |
| 2151 |
> |
the meta-data file. The other parameters for modifying the behavior |
| 2152 |
> |
of the $z$-constraint method are listed in table~\ref{table:zconParams}. |
| 2153 |
|
|
| 2154 |
< |
The core of OOPSE is divided into two main object libraries: |
| 2155 |
< |
\texttt{libBASS} and \texttt{libmdtools}. \texttt{libBASS} is the |
| 2156 |
< |
library developed around the parsing engine and \texttt{libmdtools} |
| 2157 |
< |
is the software library developed around the simulation engine. These |
| 2158 |
< |
two libraries are designed to encompass all the basic functions and |
| 2159 |
< |
tools that {\sc oopse} provides. Utility programs, such as the |
| 2160 |
< |
property analyzers, need only link against the software libraries to |
| 2161 |
< |
gain access to parsing, force evaluation, and input / output |
| 2162 |
< |
routines. |
| 2154 |
> |
\begin{table} |
| 2155 |
> |
\caption{Meta-data Keywords: Z-Constraint Parameters} |
| 2156 |
> |
\label{table:zconParams} |
| 2157 |
> |
\begin{center} |
| 2158 |
> |
% Note when adding or removing columns, the \hsize numbers must add up to the total number |
| 2159 |
> |
% of columns. |
| 2160 |
> |
\begin{tabularx}{\linewidth}% |
| 2161 |
> |
{>{\setlength{\hsize}{1.00\hsize}}X% |
| 2162 |
> |
>{\setlength{\hsize}{0.4\hsize}}X% |
| 2163 |
> |
>{\setlength{\hsize}{1.2\hsize}}X% |
| 2164 |
> |
>{\setlength{\hsize}{1.4\hsize}}X} |
| 2165 |
|
|
| 2166 |
< |
Contained in \texttt{libBASS} are all the routines associated with |
| 1872 |
< |
reading and parsing the \texttt{.bass} input files. Given a |
| 1873 |
< |
\texttt{.bass} file, \texttt{libBASS} will open it and any associated |
| 1874 |
< |
\texttt{.mdl} files; then create structures in memory that are |
| 1875 |
< |
templates of all the molecules specified in the input files. In |
| 1876 |
< |
addition, any simulation parameters set in the \texttt{.bass} file |
| 1877 |
< |
will be placed in a structure for later query by the controlling |
| 1878 |
< |
program. |
| 2166 |
> |
{\bf keyword} & {\bf units} & {\bf use} & {\bf remarks} \\ \hline |
| 2167 |
|
|
| 2168 |
< |
Located in \texttt{libmdtools} are all other routines necessary to a |
| 2169 |
< |
Molecular Dynamics simulation. The library uses the main data |
| 2170 |
< |
structures returned by \texttt{libBASS} to initialize the various |
| 2171 |
< |
parts of the simulation: the atom structures and positions, the force |
| 2172 |
< |
field, the integrator, \emph{et cetera}. After initialization, the |
| 2173 |
< |
library can be used to perform a variety of tasks: integrate a |
| 2174 |
< |
Molecular Dynamics trajectory, query phase space information from a |
| 2175 |
< |
specific frame of a completed trajectory, or even recalculate force or |
| 2176 |
< |
energetic information about specific frames from a completed |
| 2177 |
< |
trajectory. |
| 2168 |
> |
{\tt nZconstraints} & integer & The number of $z$-constrained |
| 2169 |
> |
molecules & If using the $z$-constraint method, {\tt nZconstraints} |
| 2170 |
> |
must be set \\ |
| 2171 |
> |
{\tt zconsTime} & fs & Sets the frequency at which the {\tt .fz} file |
| 2172 |
> |
is written & \\ |
| 2173 |
> |
{\tt zconsForcePolicy} & string & The strategy for subtracting |
| 2174 |
> |
the $z$-constraint force from the {\it unconstrained} molecules & Possible |
| 2175 |
> |
strategies are {\tt BYMASS} and {\tt BYNUMBER}. The default |
| 2176 |
> |
strategy is {\tt BYMASS}\\ |
| 2177 |
> |
{\tt zconsGap} & $\mbox{\AA}$ & Sets the distance between two adjacent |
| 2178 |
> |
constraint positions&Used mainly to move molecules through a |
| 2179 |
> |
simulation to estimate potentials of mean force. \\ |
| 2180 |
> |
{\tt zconsFixtime} & fs & Sets the length of time the $z$-constraint |
| 2181 |
> |
molecule is held fixed & {\tt zconsFixtime} must be set if {\tt |
| 2182 |
> |
zconsGap} is set\\ |
| 2183 |
> |
{\tt zconsUsingSMD} & logical & Flag for using Steered Molecular |
| 2184 |
> |
Dynamics to move the molecules to the correct constrained positions & |
| 2185 |
> |
Harmonic Forces are used by default\\ |
| 2186 |
|
|
| 2187 |
< |
With these core libraries in place, several programs have been |
| 2188 |
< |
developed to utilize the routines provided by \texttt{libBASS} and |
| 2189 |
< |
\texttt{libmdtools}. The main program of the package is \texttt{oopse} |
| 1894 |
< |
and the corresponding parallel version \texttt{oopse\_MPI}. These two |
| 1895 |
< |
programs will take the \texttt{.bass} file, and create (and integrate) |
| 1896 |
< |
the simulation specified in the script. The two analysis programs |
| 1897 |
< |
\texttt{staticProps} and \texttt{dynamicProps} utilize the core |
| 1898 |
< |
libraries to initialize and read in trajectories from previously |
| 1899 |
< |
completed simulations, in addition to the ability to use functionality |
| 1900 |
< |
from \texttt{libmdtools} to recalculate forces and energies at key |
| 1901 |
< |
frames in the trajectories. Lastly, the family of system building |
| 1902 |
< |
programs (Sec.~\ref{oopseSec:initCoords}) also use the libraries to |
| 1903 |
< |
store and output the system configurations they create. |
| 2187 |
> |
\end{tabularx} |
| 2188 |
> |
\end{center} |
| 2189 |
> |
\end{table} |
| 2190 |
|
|
| 1905 |
– |
\subsection{\label{oopseSec:parallelization} Parallelization of {\sc oopse}} |
| 2191 |
|
|
| 2192 |
< |
Although processor power is continually growing roughly following |
| 1908 |
< |
Moore's Law, it is still unreasonable to simulate systems of more then |
| 1909 |
< |
a 1000 atoms on a single processor. To facilitate study of larger |
| 1910 |
< |
system sizes or smaller systems on long time scales in a reasonable |
| 1911 |
< |
period of time, parallel methods were developed allowing multiple |
| 1912 |
< |
CPU's to share the simulation workload. Three general categories of |
| 1913 |
< |
parallel decomposition methods have been developed including atomic, |
| 1914 |
< |
spatial and force decomposition methods. |
| 2192 |
> |
\section{\label{oopseSec:minimizer}Energy Minimization} |
| 2193 |
|
|
| 2194 |
< |
Algorithmically simplest of the three methods is atomic decomposition |
| 2195 |
< |
where N particles in a simulation are split among P processors for the |
| 2196 |
< |
duration of the simulation. Computational cost scales as an optimal |
| 2197 |
< |
$\mathcal{O}(N/P)$ for atomic decomposition. Unfortunately all |
| 2198 |
< |
processors must communicate positions and forces with all other |
| 2199 |
< |
processors at every force evaluation, leading communication costs to |
| 2200 |
< |
scale as an unfavorable $\mathcal{O}(N)$, \emph{independent of the |
| 2194 |
> |
As one of the basic procedures of molecular modeling, energy |
| 2195 |
> |
minimization is used to identify local configurations that are stable |
| 2196 |
> |
points on the potential energy surface. There is a vast literature on |
| 2197 |
> |
energy minimization algorithms have been developed to search for the |
| 2198 |
> |
global energy minimum as well as to find local structures which are |
| 2199 |
> |
stable fixed points on the surface. We have included two simple |
| 2200 |
> |
minimization algorithms: steepest descent, ({\sc sd}) and conjugate |
| 2201 |
> |
gradient ({\sc cg}) to help users find reasonable local minima from |
| 2202 |
> |
their initial configurations. Since {\sc oopse} handles atoms and |
| 2203 |
> |
rigid bodies which have orientational coordinates as well as |
| 2204 |
> |
translational coordinates, there is some subtlety to the choice of |
| 2205 |
> |
parameters for minimization algorithms. |
| 2206 |
> |
|
| 2207 |
> |
Given a coordinate set $x_{k}$ and a search direction $d_{k}$, a line |
| 2208 |
> |
search algorithm is performed along $d_{k}$ to produce |
| 2209 |
> |
$x_{k+1}=x_{k}+$ $\lambda _{k}d_{k}$. In the steepest descent ({\sc |
| 2210 |
> |
sd}) algorithm,% |
| 2211 |
> |
\begin{equation} |
| 2212 |
> |
d_{k}=-\nabla V(x_{k}). |
| 2213 |
> |
\end{equation} |
| 2214 |
> |
The gradient and the direction of next step are always orthogonal. |
| 2215 |
> |
This may cause oscillatory behavior in narrow valleys. To overcome |
| 2216 |
> |
this problem, the Fletcher-Reeves variant~\cite{FletcherReeves} of the |
| 2217 |
> |
conjugate gradient ({\sc cg}) algorithm is used to generate $d_{k+1}$ |
| 2218 |
> |
via simple recursion: |
| 2219 |
> |
\begin{equation} |
| 2220 |
> |
d_{k+1} =-\nabla V(x_{k+1})+\gamma_{k}d_{k} |
| 2221 |
> |
\end{equation} |
| 2222 |
> |
where |
| 2223 |
> |
\begin{equation} |
| 2224 |
> |
\gamma_{k} =\frac{\nabla V(x_{k+1})^{T}\nabla V(x_{k+1})}{\nabla |
| 2225 |
> |
V(x_{k})^{T}\nabla V(x_{k})}. |
| 2226 |
> |
\end{equation} |
| 2227 |
> |
|
| 2228 |
> |
The Polak-Ribiere variant~\cite{PolakRibiere} of the conjugate |
| 2229 |
> |
gradient ($\gamma_{k}$) is defined as% |
| 2230 |
> |
\begin{equation} |
| 2231 |
> |
\gamma_{k}=\frac{[\nabla V(x_{k+1})-\nabla V(x)]^{T}\nabla V(x_{k+1})}{\nabla |
| 2232 |
> |
V(x_{k})^{T}\nabla V(x_{k})}% |
| 2233 |
> |
\end{equation} |
| 2234 |
> |
It is widely agreed that the Polak-Ribiere variant gives better |
| 2235 |
> |
convergence than the Fletcher-Reeves variant, so the conjugate |
| 2236 |
> |
gradient approach implemented in {\sc oopse} is the Polak-Ribiere |
| 2237 |
> |
variant. |
| 2238 |
> |
|
| 2239 |
> |
The conjugate gradient method assumes that the conformation is close |
| 2240 |
> |
enough to a local minimum that the potential energy surface is very |
| 2241 |
> |
nearly quadratic. When the initial structure is far from the minimum, |
| 2242 |
> |
the steepest descent method can be superior to the conjugate gradient |
| 2243 |
> |
method. Hence, the steepest descent method is often used for the first |
| 2244 |
> |
10-100 steps of minimization. Another useful feature of minimization |
| 2245 |
> |
methods in {\sc oopse} is that a modified {\sc shake} algorithm can be |
| 2246 |
> |
applied during the minimization to constraint the bond lengths if this |
| 2247 |
> |
is required by the force field. Meta-data parameters concerning the |
| 2248 |
> |
minimizer are given in Table~\ref{table:minimizeParams} |
| 2249 |
> |
|
| 2250 |
> |
\begin{table} |
| 2251 |
> |
\caption{Meta-data Keywords: Energy Minimizer Parameters} |
| 2252 |
> |
\label{table:minimizeParams} |
| 2253 |
> |
\begin{center} |
| 2254 |
> |
% Note when adding or removing columns, the \hsize numbers must add up to the total number |
| 2255 |
> |
% of columns. |
| 2256 |
> |
\begin{tabularx}{\linewidth}% |
| 2257 |
> |
{>{\setlength{\hsize}{1.2\hsize}}X% |
| 2258 |
> |
>{\setlength{\hsize}{0.6\hsize}}X% |
| 2259 |
> |
>{\setlength{\hsize}{1.1\hsize}}X% |
| 2260 |
> |
>{\setlength{\hsize}{1.1\hsize}}X} |
| 2261 |
> |
|
| 2262 |
> |
{\bf keyword} & {\bf units} & {\bf use} & {\bf remarks} \\ \hline |
| 2263 |
> |
|
| 2264 |
> |
{\tt minimizer} & string & selects the minimization method to be used |
| 2265 |
> |
& either {\tt CG} (conjugate gradient) or {\tt SD} (steepest |
| 2266 |
> |
descent) \\ |
| 2267 |
> |
{\tt minimizerMaxIter} & steps & Sets the maximum number of iterations |
| 2268 |
> |
for the energy minimization & The default value is 200\\ |
| 2269 |
> |
{\tt minimizerWriteFreq} & steps & Sets the frequency with which the {\tt .dump} and {\tt .stat} files are writtern during energy minimization & \\ |
| 2270 |
> |
{\tt minimizerStepSize} & $\mbox{\AA}$ & Sets the step size for the |
| 2271 |
> |
line search & The default value is 0.01\\ |
| 2272 |
> |
{\tt minimizerFTol} & $\mbox{kcal mol}^{-1}$ & Sets the energy tolerance |
| 2273 |
> |
for stopping the minimziation. & The default value is $10^{-8}$\\ |
| 2274 |
> |
{\tt minimizerGTol} & $\mbox{kcal mol}^{-1}\mbox{\AA}^{-1}$ & Sets the |
| 2275 |
> |
gradient tolerance for stopping the minimization. & The default value |
| 2276 |
> |
is $10^{-8}$\\ |
| 2277 |
> |
{\tt minimizerLSTol} & $\mbox{kcal mol}^{-1}$ & Sets line search |
| 2278 |
> |
tolerance for terminating each step of the minimization. & The default |
| 2279 |
> |
value is $10^{-8}$\\ |
| 2280 |
> |
{\tt minimizerLSMaxIter} & steps & Sets the maximum number of |
| 2281 |
> |
iterations for each line search & The default value is 50\\ |
| 2282 |
> |
|
| 2283 |
> |
\end{tabularx} |
| 2284 |
> |
\end{center} |
| 2285 |
> |
\end{table} |
| 2286 |
> |
|
| 2287 |
> |
\section{\label{oopseSec:parallelization} Parallel Simulation Implementation} |
| 2288 |
> |
|
| 2289 |
> |
Although processor power is continually improving, it is still |
| 2290 |
> |
unreasonable to simulate systems of more than 10,000 atoms on a single |
| 2291 |
> |
processor. To facilitate study of larger system sizes or smaller |
| 2292 |
> |
systems for longer time scales, parallel methods were developed to |
| 2293 |
> |
allow multiple CPU's to share the simulation workload. Three general |
| 2294 |
> |
categories of parallel decomposition methods have been developed: |
| 2295 |
> |
these are the atomic,\cite{Fox88} spatial~\cite{plimpton95} and |
| 2296 |
> |
force~\cite{Paradyn} decomposition methods. |
| 2297 |
> |
|
| 2298 |
> |
Algorithmically simplest of the three methods is atomic decomposition, |
| 2299 |
> |
where $N$ particles in a simulation are split among $P$ processors for |
| 2300 |
> |
the duration of the simulation. Computational cost scales as an |
| 2301 |
> |
optimal $\mathcal{O}(N/P)$ for atomic decomposition. Unfortunately, all |
| 2302 |
> |
processors must communicate positions and forces with all other |
| 2303 |
> |
processors at every force evaluation, leading the communication costs |
| 2304 |
> |
to scale as an unfavorable $\mathcal{O}(N)$, \emph{independent of the |
| 2305 |
|
number of processors}. This communication bottleneck led to the |
| 2306 |
< |
development of spatial and force decomposition methods in which |
| 2306 |
> |
development of spatial and force decomposition methods, in which |
| 2307 |
|
communication among processors scales much more favorably. Spatial or |
| 2308 |
|
domain decomposition divides the physical spatial domain into 3D boxes |
| 2309 |
|
in which each processor is responsible for calculation of forces and |
| 2310 |
|
positions of particles located in its box. Particles are reassigned to |
| 2311 |
|
different processors as they move through simulation space. To |
| 2312 |
< |
calculate forces on a given particle, a processor must know the |
| 2312 |
> |
calculate forces on a given particle, a processor must simply know the |
| 2313 |
|
positions of particles within some cutoff radius located on nearby |
| 2314 |
< |
processors instead of the positions of particles on all |
| 2314 |
> |
processors rather than the positions of particles on all |
| 2315 |
|
processors. Both communication between processors and computation |
| 2316 |
|
scale as $\mathcal{O}(N/P)$ in the spatial method. However, spatial |
| 2317 |
|
decomposition adds algorithmic complexity to the simulation code and |
| 2318 |
< |
is not very efficient for small N since the overall communication |
| 2318 |
> |
is not very efficient for small $N$, since the overall communication |
| 2319 |
|
scales as the surface to volume ratio $\mathcal{O}(N/P)^{2/3}$ in |
| 2320 |
|
three dimensions. |
| 2321 |
|
|
| 2322 |
|
The parallelization method used in {\sc oopse} is the force |
| 2323 |
< |
decomposition method. Force decomposition assigns particles to |
| 2324 |
< |
processors based on a block decomposition of the force |
| 2323 |
> |
decomposition method.\cite{hendrickson:95} Force decomposition assigns |
| 2324 |
> |
particles to processors based on a block decomposition of the force |
| 2325 |
|
matrix. Processors are split into an optimally square grid forming row |
| 2326 |
|
and column processor groups. Forces are calculated on particles in a |
| 2327 |
< |
given row by particles located in that processors column |
| 2328 |
< |
assignment. Force decomposition is less complex to implement than the |
| 2329 |
< |
spatial method but still scales computationally as $\mathcal{O}(N/P)$ |
| 2330 |
< |
and scales as $\mathcal{O}(N/\sqrt{P})$ in communication |
| 2331 |
< |
cost. Plimpton has also found that force decompositions scale more |
| 2332 |
< |
favorably than spatial decompositions for systems up to 10,000 atoms |
| 2333 |
< |
and favorably compete with spatial methods up to 100,000 |
| 2334 |
< |
atoms.\cite{plimpton95} |
| 2335 |
< |
|
| 2327 |
> |
given row by particles located in that processor's column |
| 2328 |
> |
assignment. One deviation from the algorithm described by Hendrickson |
| 2329 |
> |
{\it et al.} is the use of column ordering based on the row indexes |
| 2330 |
> |
preventing the need for a transpose operation necessitating a second |
| 2331 |
> |
communication step when gathering the final force components. Force |
| 2332 |
> |
decomposition is less complex to implement than the spatial method but |
| 2333 |
> |
still scales computationally as $\mathcal{O}(N/P)$ and scales as |
| 2334 |
> |
$\mathcal{O}(N/\sqrt{P})$ in communication cost. Plimpton has also |
| 2335 |
> |
found that force decompositions scale more favorably than spatial |
| 2336 |
> |
decompositions for systems up to 10,000 atoms and favorably compete |
| 2337 |
> |
with spatial methods up to 100,000 atoms.\cite{plimpton95} |
| 2338 |
> |
|
| 2339 |
|
\section{\label{oopseSec:conclusion}Conclusion} |
| 2340 |
|
|
| 2341 |
< |
We have presented the design and implementation of our open source |
| 2342 |
< |
simulation package {\sc oopse}. The package offers novel capabilities |
| 2343 |
< |
to the field of Molecular Dynamics simulation packages in the form of |
| 2344 |
< |
dipolar force fields, and symplectic integration of rigid body |
| 2345 |
< |
dynamics. It is capable of scaling across multiple processors through |
| 2346 |
< |
the use of force based decomposition using MPI. It also implements |
| 2347 |
< |
several advanced integrators allowing the end user control over |
| 2348 |
< |
temperature and pressure. In addition, it is capable of integrating |
| 2349 |
< |
constrained dynamics through both the {\sc rattle} algorithm and the |
| 2350 |
< |
z-constraint method. |
| 2341 |
> |
We have presented a new parallel simulation program called {\sc |
| 2342 |
> |
oopse}. This program offers some novel capabilities, but mostly makes |
| 2343 |
> |
available a library of modern object-oriented code for the scientific |
| 2344 |
> |
community to use freely. Notably, {\sc oopse} can handle symplectic |
| 2345 |
> |
integration of objects (atoms and rigid bodies) which have |
| 2346 |
> |
orientational degrees of freedom. It can also work with transition |
| 2347 |
> |
metal force fields and point-dipoles. It is capable of scaling across |
| 2348 |
> |
multiple processors through the use of force based decomposition. It |
| 2349 |
> |
also implements several advanced integrators allowing the end user |
| 2350 |
> |
control over temperature and pressure. In addition, it is capable of |
| 2351 |
> |
integrating constrained dynamics through both the {\sc rattle} |
| 2352 |
> |
algorithm and the $z$-constraint method. |
| 2353 |
|
|
| 2354 |
< |
These features are all brought together in a single open-source |
| 2355 |
< |
program. This allows researchers to not only benefit from |
| 2356 |
< |
{\sc oopse}, but also contribute to {\sc oopse}'s development as |
| 2357 |
< |
well. |
| 2354 |
> |
We encourage other researchers to download and apply this program to |
| 2355 |
> |
their own research problems. By making the code available, we hope to |
| 2356 |
> |
encourage other researchers to contribute their own code and make it a |
| 2357 |
> |
more powerful package for everyone in the molecular dynamics community |
| 2358 |
> |
to use. All source code for {\sc oopse} is available for download at |
| 2359 |
> |
{\tt http://oopse.org}. |
| 2360 |
|
|
| 1972 |
– |
|
| 2361 |
|
\newpage |
| 2362 |
|
\section{Acknowledgments} |
| 1975 |
– |
The authors would like to thank the Notre Dame BoB computer cluster where much of this project was tested. Additionally, the authors would like to acknowledge their funding from {\LARGE FIX ME}. |
| 2363 |
|
|
| 2364 |
< |
\bibliographystyle{achemso} |
| 2364 |
> |
Development of {\sc oopse} was funded by a New Faculty Award from the |
| 2365 |
> |
Camille and Henry Dreyfus Foundation and by the National Science |
| 2366 |
> |
Foundation under grant CHE-0134881. Computation time was provided by |
| 2367 |
> |
the Notre Dame Bunch-of-Boxes (B.o.B) computer cluster under NSF grant |
| 2368 |
> |
DMR-0079647. |
| 2369 |
> |
|
| 2370 |
> |
\bibliographystyle{jcc} |
| 2371 |
|
\bibliography{oopsePaper} |
| 2372 |
|
|
| 2373 |
|
\end{document} |
