ESPResSo++ Documentation

ESPResSo++ Documentation
Release latest
Developer team
March 20, 2018
CONTENTS
1
Installation
2
Tutorial
2.1 Basic System Setup . . . . . . .
2.2 Simple Lennard Jones System . .
2.3 Advanced Lennard Jones System
2.4 Polymer Melt . . . . . . . . . . .
2.5 AddNewPotential . . . . . . . . .
2.6 Appendices . . . . . . . . . . . .
2.7 Adaptive Resolution Simulations
2.8 Thermodynamic integration . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5
5
7
9
11
13
16
17
23
User Interface
3.1 analysis . . . . . . .
3.2 bc . . . . . . . . . .
3.3 check . . . . . . . .
3.4 esutil . . . . . . . .
3.5 external . . . . . . .
3.6 integrator . . . . . .
3.7 interaction . . . . .
3.8 io . . . . . . . . . .
3.9 espressopp . . . . .
3.10 standard_system . .
3.11 storage . . . . . . .
3.12 tools . . . . . . . .
3.13 Logging mechanism
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
27
27
42
44
44
44
44
65
131
134
154
156
159
170
3
4
3
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Credits
173
4.1 ESPResSo++ Developers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
4.2 FAQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
4.3 Getting Help . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Bibliography
175
Python Module Index
177
Index
181
i
ii
ESPResSo++ Documentation, Release latest
Welcome to the homepage of the ESPResSo++ project
ESPResSo++ is an extensible, flexible, fast and parallel simulation software for soft matter research. It is a highly
versatile software package for the scientific simulation and analysis of coarse-grained atomistic or bead-spring
models as they are used in soft matter research.
ESPResSo and ESPResSo++ have common roots and share parts of the developer/user community. However their
development is independent and they are different software packages.
ESPResSo++ is free, open-source software published under the GNU General Public License (GPL).
Please cite this, if you used ESPResSo++ in your research J. D. Halverson, T. Brandes, O. Lenz, A. Arnold, S.
Bevc, V. Starchenko, K. Kremer, T. Stuehn, D. Reith, “ESPResSo++: A Modern Multiscale Simulation
Package for Soft Matter Systems”, Computer Physics Communications, 184 (2013), pp. 1129-1149 DOI:
10.1016/j.cpc.2012.12.004 Online access: http://dx.doi.org/10.1016/j.cpc.2012.12.004
Recent publications where ESPResSo++ was used
CONTENTS
1
ESPResSo++ Documentation, Release latest
2
CONTENTS
CHAPTER
ONE
INSTALLATION
The first step in the installation of ESPResSo++ is to download the latest release from the following location:
https://github.com/espressopp/espressopp/releases
On the command line type:
tar -xzf espressopp-latest.tgz
This will create a subdirectory espressopp-latest
Enter this subdirectory
cd espressopp-latest
Create the Makefiles using the cmake command. If you don’t have it yet, you have to install it first. It is available
for all major Linux distributions and also for Mac OS X. (ubuntu,debian: “apt-get install cmake” or get it from
http://www.cmake.org )
cmake .
(the space and dot after cmake are necessary)
If cmake doesn’t finish successfully (e.g. it didn’t find all the libraries) you can tell cmake manually, where to find
them by typing:
ccmake .
This will open an interactive page where all configuration information can be specified. Alternatively, if cmake .
complains on missing BOOST or MPI4PY libraries and you had not installed them, you can try
cmake . -DEXTERNAL_BOOST=OFF -DEXTERNAL_MPI4PY=OFF
In this case, ESPResSo++ will try to use internal Boost and mpi4py libraries.
After successfully building all the Makefiles you should build ESPResSo++ with:
make
(This will take several minutes)
Before beeing able to use the espressopp module in Python you need to source the ESPRC file:
source ESPRC
(This sets all corresponding environment variables to point to the module, e.g. PYTHONPATH) You have to
source this file every time you want to work with espressopp. It would advisable to e.g. source the file in your
.bashrc file ( “source <path_to_espressopp>/ESPRC” )
In order to use matplotlib.pyplot for graphical output get the open source code from:
http://sourceforge.net/projects/matplotlib
and follow the installation instructions of your distribution.
3
ESPResSo++ Documentation, Release latest
4
Chapter 1. Installation
CHAPTER
TWO
TUTORIAL
Basic System Setup
ESPResSo++ is implemented as a python module that has to be imported at the beginning of every script:
>>> import espressopp
ESPResSo++ uses an object called System to store some global variables and is also used to keep the connection
between some other important modules. We create it with:
>>> system
= espressopp.System()
Starting a new simulation with ESPResSo++ we should have an idea about what we want to simulate. E.g. how big
should the simulation box be or what is the density of the system or what are the interactions and the interaction
ranges between our particles.
Let us start with the size of the simulation box:
>>> box
= (10, 10, 10)
In many cases you will need a random number generator (e.G. to couple to a temperature bath or to randomly
position particles in the simulation box). ESPResSo++ provides its own random number generator (for the experts:
see boost/random.hpp) so let’s use it:
>>> rng
= espressopp.esutil.RNG()
Our simulation box needs some boundary conditions. We want to use periodic boundary conditions:
>>> bc
= espressopp.bc.OrthorhombicBC(rng, box)
We tell our system object about this:
>>> system.bc
>>> system.rng
= bc
= rng
Now we need to decide which parallelization scheme for the particle storage we want to use. In the current
version of ESPResSo++ there is only one storage scheme implemented which is domain decomposition. Further
parallelized storages (e.g. atom decomposition or force decomposition) will be implemented in future versions.
The domain decomposition storage needs to know how many CPUs (or cores, if there are multicore CPUs) are
available for the simulation and how to assign the CPUs to the different domains of our simulation box. Moreover
the storage needs to know the maximum interaction range of the particles. In a simple Lennard-Jones fluid this
1
could for example be  = 2 6 . This value together with the skin value determines the minimal size for the so
called linked cells which are used to speed up Verlet list rebuilds (see Frenkel&Smit or Allen&Tildesley for the
details).
>>> maxcutoff
>>> skin
= pow(2.0, 1.0/6.0)
= 0.4
Tell the system about it:
5
ESPResSo++ Documentation, Release latest
>>> system.skin
= skin
In the most simple case, if you want to use only one CPU, the nodeGrid and the cellGrid could look like this:
>>> nodeGrid
>>> cellGrid
= (1,1,1)
= (2,2,2)
In general you don’t need to take care of that yourself. Just use the corresponding ESPResSo++ routines to
calculate a reasonable nodeGrid and cellGrid:
>>> nodeGrid
>>> cellGrid
= espressopp.tools.decomp.nodeGrid(espressopp.MPI.COMM_WORLD.size,box,maxcutoff
= espressopp.tools.decomp.cellGrid(box, nodeGrid, maxcutoff, skin)
Now we have all the ingredients we need for the domain decomposition storage of our system:
>>> ddstorage
= espressopp.storage.DomainDecomposition(system, nodeGrid, cellGrid)
We initialized the DomainDecomposition object with a pointer to our system. We also have to inform the system
about the DomainDecomposition storage:
>>> system.storage = ddstorage
The next module we need is the integrator. This object will do the actual work of integrating Newtons equations
of motion. ESPResSo++ implements the well known velocity Verlet algorithm (see for example Frenkel&Smit):
integrator
>>>
= espressopp.integrator.VelocityVerlet(system)
We have to tell the integrator about the basic time step:
dt
integrator.dt
>>>
>>>
= 0.005
= dt
Let’s do some math in between:
Note: For 3D vectors like positions, velocities or forces ESPResSo++ provides a so called Real3D type, which
simplifies handling and arithmetic operations with vectors. 3D coordinates would typically be defined like this:
>>> a = espressopp.Real3D(2.0, 5.0, 6.0)
>>> b = espressopp.Real3D(0.1, 0.0, 0.5)
Now you could do things like:
>>>
>>>
>>>
>>>
>>>
c
d
e
f
g
=
=
=
=
=
a + b
a * 1.5
a - b
e.sqr()
e.abs()
#
#
#
#
#
c
d
e
f
g
is
is
is
is
is
a
a
a
a
a
Real3D object
Real3D object
Real3D object
scalar
scalar
In order to make defining vectors even more simple include the line
>>> from espressopp import Real3D
just at the beginning of your script. This allows to define vectors as:
>>> vec = Real3D(2.0, 1.5, 5.0)
Back to our simulation:
The most simple simulation we can do is integrating Newtons equation of motion for one particle without any
external forces. So let’s simply add one particle to the storage of our system. Every particle in ESPResSo++ has
a unique particle id and a position (this is obligatory).
6
Chapter 2. Tutorial
ESPResSo++ Documentation, Release latest
>>> pid = 1
>>> pos = Real3D(2.0, 4.0, 6.0)
# remember to add "from espressopp import Real3D"
>>>
# at the beginning of your script
>>> system.storage.addParticle(pid, pos)
Of course nothing will happen when we integrate this. The particle will stay where it is. Add some initial velocity
to the particle by adding the follow line to the script:
>>> system.storage.modifyParticle(pid, 'v', Real3D(1.0, 0, 0))
After particles have been modified make sure that this information is distributed to all CPUs:
>>> system.storage.decompose()
Now we can propagate the particle by calling the integrator:
>>> integrator.run(100)
Check the result with:
>>> print "The new particle position is: ", system.storage.getParticle(pid).pos
Let’s add some more particles at random positions with random velocities and random mass and random type 0 or
1. The boundary condition object knows about how to create random positions within the simulation box. We can
add all the particles at once by creating a particle list first:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
particle_list = []
num_particles = 9
for k in range(num_particles):
pid = 2 + k
pos = system.bc.getRandomPos()
v
= Real3D(system.rng(), system.rng(), system.rng())
mass = system.rng()
type = system.rng(2)
part = [pid, pos, type, v, mass]
particle_list.append(part)
system.storage.addParticles(particle_list, 'id', 'pos', 'type', 'v', 'mass')
# don't forget the decomposition
system.storage.decompose()
To have a look at the overall system there are several possibilities. The easiest way to get a nice picture is by
writing out a PDB file and looking at the configuration with some visualization programm (e.g. VMD):
>>> filename = "myconf.pdb"
>>> espressopp.tools.pdb.pdbwrite(filename, system)
or (if vmd is in your search PATH) you could directly connect to VMD by:
>>> espressopp.tools.vmd.connect(system)
or you could print all particle information to the screen:
>>> for k in range(10):
>>>
p = system.storage.getParticle(k+1)
>>>
print p.id, p.type, p.mass, p.pos, p.v, p.f, p.q
Simple Lennard Jones System
Lets just copy and paste the beginning from the “System Setup” tutorial:
>>> import espressopp
>>> from espressopp import Real3D
2.2. Simple Lennard Jones System
7
ESPResSo++ Documentation, Release latest
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
system
box
rng
bc
system.bc
system.rng
maxcutoff
skin
system.skin
nodeGrid
cellGrid
nodeGrid
cellGrid
ddstorage
system.storage
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
espressopp.System()
(10, 10, 10)
espressopp.esutil.RNG()
espressopp.bc.OrthorhombicBC(rng, box)
bc
rng
pow(2.0, 1.0/6.0)
0.4
skin
(1,1,1)
(1,1,1)
espressopp.tools.decomp.nodeGrid(espressopp.MPI.COMM_WORLD.size,box,maxcutoff
espressopp.tools.decomp.cellGrid(box, nodeGrid, maxcutoff, skin)
espressopp.storage.DomainDecomposition(system, nodeGrid, cellGrid)
ddstorage
integrator
dt
integrator.dt
= espressopp.integrator.VelocityVerlet(system)
= 0.005
= dt
And lets add some random particles:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
num_particles = 20
particle_list = []
for k in range(num_particles):
pid = k + 1
pos = system.bc.getRandomPos()
v
= Real3D(0,0,0)
mass = system.rng()
type = 0
part = [pid, pos, type, v, mass]
particle_list.append(part)
system.storage.addParticles(particle_list, 'id', 'pos', 'type', 'v', 'mass')
system.storage.decompose()
All particles should interact via a Lennard Jones potential:
>>> LJPot = espressopp.interaction.LennardJones(epsilon=1.0, sigma=1.0, cutoff=maxcutoff, shift='a
shift=True means that the potential will be shifted at the cutoff so that potLJ(cutoff)=0 Next we create a VerletList
which will than be used in the interaction: (the Verlet List object needs to know from which system to get its
particles and which cutoff to use)
>>> verletlist = espressopp.VerletList(system, cutoff=maxcutoff)
Now create a non bonded interaction object and add the Lennard Jones potential to that:
>>> NonBondedInteraction = espressopp.interaction.VerletListLennardJones(verletlist)
>>> NonBondedInteraction.setPotential(type1=0, type2=0, potential=LJPot)
Tell the system about the newly created NonBondedInteraction object:
>>> system.addInteraction(NonBondedInteraction)
We should set the langevin thermostat in the integrator to cool down the random particle system:
>>>
>>>
>>>
>>>
langevin
= espressopp.integrator.LangevinThermostat(system)
langevin.gamma
= 1.0
langevin.temperature = 1.0
integrator.addExtension(langevin)
and finally let the system run and see how it relaxes or explodes:
8
Chapter 2. Tutorial
ESPResSo++ Documentation, Release latest
>>> espressopp.tools.analyse.info(system, integrator)
>>> for k in range(100):
>>>
integrator.run(10)
>>>
espressopp.tools.analyse.info(system, integrator)
Due to the random particle positions it may happen, that two or more particles are very close to each other and
the resulting repulsive force between them are so high that they ‘shoot off’ in different directions with very high
speed. Usually the numbers are then larger than the computer can deal with. A typical error message you get
could look like this:
Note: ERROR: particle 5 has moved to outer space (one or more coordinates are nan)
In order to prevent this, systems that are setup in a random way and thus have strong overlaps between particels
have to be “warmed up” before they can be equilibrated.
In ESPResSo++ there are several possible ways of warming up a system. As a first approach one could simply
constrain the forces in the integrator. For this purpose ESPResSo++ provides an integrator Extension named
CapForces. The two parameters of this Extension are the system and the maximum force that a particle can get.
The following python code shows how CapForces can be used. Add it to your Lennard-Jones example just after
adding the Langevin Extension:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
print "starting warmup with force capping ..."
force_capping
= espressopp.integrator.CapForce(system, 1000000.0)
integrator.addExtension(force_capping)
# reduce the time step of the integrator to make the integration numerically more stable
integrator.dt = 0.0001
espressopp.tools.analyse.info(system, integrator)
for k in range(10):
integrator.run(1000)
espressopp.tools.analyse.info(system, integrator)
After the warmup the time step of the integrator can be set to a larger value. The CapForce extension can be
disconnected after the warmup to get the original full Lennard-Jones potential back.
>>>
>>>
>>>
>>>
integrator.dt
= 0.005
integrator.step = 0
force_capping.disconnect()
print "warmup finished - force capping switched off."
Task 1:
write a python script that creates a random configuration of 1000 Lennard Jones particles with a number density of
0.85 in a cubic simulation box. Warm up and equilibrate this configuration. Examine the output of the command
>>> espressopp.tools.analyse.info(system, integrator)
after each integration step. How fast is the energy of the system going down ? How long do you have to warmup
? What are good parameters for dt, force_capping and number of integration steps ?
Advanced Lennard Jones System
This tutorial needs the matplotlib.pyplot and numpy libraries and also VMD to be installed.
>>> import espressopp
After importing espressopp we import several other Python packages that we want to use for graphical output of
some system parameters (e.g. temperature and energy)
2.3. Advanced Lennard Jones System
9
ESPResSo++ Documentation, Release latest
>>>
>>>
>>>
>>>
>>>
>>>
import math
import time
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
plt.ion()
We setup a standard Lennard-Jones system with 1000 particles and a density of 0.85 in a cubic siomulation box.
ESPResSo++ provides a “shortcut” to setup such a system:
>>>
>>>
>>>
>>>
N
= 1000
rho = 0.85
L
= pow(N/rho, 1.0/3)
system, integrator = espressopp.standard_system.LennardJones(N,(L, L, L), dt=0.0001)
We also add a Langevin thermostat:
>>>
>>>
>>>
>>>
langevin = espressopp.integrator.LangevinThermostat(system)
langevin.gamma
= 1.0
langevin.temperature = 1.0
integrator.addExtension(langevin)
We do a very short warmup in the beginning to get rid of “extremely” high forces
>>>
>>>
>>>
>>>
>>>
>>>
force_capping
= espressopp.integrator.CapForce(system, 1000000.0)
integrator.addExtension(force_capping)
espressopp.tools.analyse.info(system, integrator)
for k in range(10):
integrator.run(100)
espressopp.tools.analyse.info(system, integrator)
Now let’s initialize a graph. So that we can have a realtime-view on what is happening in the simulation:
>>> plt.figure()
We want to observe temperature and energy of the system:
>>> T
>>> E
= espressopp.analysis.Temperature(system)
= espressopp.analysis.EnergyPot(system, per_atom=True)
x will be the x-axixs of the graph containg the time. yT and yE will be temperature and energy as y-axes in 2
plots:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
x
= []
yT = []
yE = []
yTmin = 0.0
yEmin = 0.0
x.append(integrator.dt * integrator.step)
yT.append(T.compute())
yE.append(E.compute())
yTmax = max(yT)
yEmax = max(yE)
Initialize the two graphs (‘ro’ means red circles, ‘go’ means green cirlces, see also pyplot documentation)
>>>
>>>
>>>
>>>
plt.subplot(211)
gT, = plt.plot(x, yT, 'ro')
plt.subplot(212)
gE, = plt.plot(x, yE, 'go')
We also want to observe the configuration with VMD. So we have to connect to vmd. This command will automatically start vmd (vmd has to be found in your PATH environment for this to work)
10
Chapter 2. Tutorial
ESPResSo++ Documentation, Release latest
>>> sock = espressopp.tools.vmd.connect(system)
>>> for k in range(200):
>>>
integrator.run(1000)
>>>
espressopp.tools.vmd.imd_positions(system, sock)
Update the x-, and y-axes:
>>>
>>>
>>>
>>>
>>>
x.append(integrator.dt * integrator.step)
yT.append(T.compute())
yE.append(E.compute())
yTmax = max(yT)
yEmax = max(yE)
Plot the temperature graph
>>>
>>>
>>>
>>>
>>>
plt.subplot(211)
plt.axis([x[0], x[-1], yTmin, yTmax*1.2 ])
gT.set_ydata(yT)
gT.set_xdata(x)
plt.draw()
Plot the energy graph
>>>
>>>
>>>
>>>
>>>
plt.subplot(212)
plt.axis([x[0], x[-1], yEmin, yEmax*1.2 ])
gE.set_ydata(yE)
gE.set_xdata(x)
plt.draw()
In the end save the equilibrated configurations as .eps and .pdf files
>>> plt.savefig('mypyplot.eps')
>>> plt.savefig('mypyplot.pdf')
Polymer Melt
We first import espressopp and then define all the parameters of the simulation:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
import espressopp
num_chains
monomers_per_chain
L
box
bondlen
rc
skin
dt
epsilon
sigma
=
=
=
=
=
=
=
=
=
=
10
10
10
(L, L, L)
0.97
pow(2, 1.0/6.0)
0.3
0.005
1.0
1.0
Like in the simple Lennard Jones tutorial we setup the system and the integrator. First the system with the excluded
volume interaction (WCA, Lennard Jones type)
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
system
system.rng
system.bc
system.skin
nodeGrid
cellGrid
system.storage
interaction
potLJ
2.4. Polymer Melt
=
=
=
=
=
=
=
=
=
espressopp.System()
espressopp.esutil.RNG()
espressopp.bc.OrthorhombicBC(system.rng, box)
skin
espressopp.tools.decomp.nodeGrid(espressopp.MPI.COMM_WORLD.size,box,rc,skin)
espressopp.tools.decomp.cellGrid(box, nodeGrid, rc, skin)
espressopp.storage.DomainDecomposition(system, nodeGrid, cellGrid)
espressopp.interaction.VerletListLennardJones(espressopp.VerletList(system, c
espressopp.interaction.LennardJones(epsilon, sigma, rc)
11
ESPResSo++ Documentation, Release latest
>>> interaction.setPotential(type1=0, type2=0, potential=potLJ)
>>> system.addInteraction(interaction)
Then the integrator with the Langevin extension
>>>
>>>
>>>
>>>
>>>
>>>
integrator
= espressopp.integrator.VelocityVerlet(system)
integrator.dt = dt
thermostat
= espressopp.integrator.LangevinThermostat(system)
thermostat.gamma = 1.0
thermostat.temperature = temperature
integrator.addExtension(thermostat)
Know we add the particles. Keep in mind that we want to create a polymer melt. This means that particles are
“bonded” in chains. We setup each polymer chain as a random walk.
>>> props
= ['id', 'type', 'mass', 'pos', 'v']
>>> vel_zero = espressopp.Real3D(0.0, 0.0, 0.0)
In providing bonding information for the particles we “setup” the bonded chains. For this we use the FixedPairList
object that needs to know where and in which storage the particles can be found:
>>>
>>>
>>>
>>>
>>>
bondlist
pid
type
mass
chain
=
=
=
=
=
espressopp.FixedPairList(system.storage)
1
0
1.0
[]
ESPResSo++ provides a function that will return position and bond information of a random walk. You have to
provide a start ID (particle id) and a starting position which we will get from the random position generator of the
boundary condition object:
>>> for i in range(num_chains):
>>>
startpos = system.bc.getRandomPos()
>>>
positions, bonds = espressopp.tools.topology.polymerRW(pid, startpos, monomers_per_chain, bo
>>>
for k in range(monomers_per_chain):
>>>
part = [pid + k, type, mass, positions[k], vel_zero]
>>>
chain.append(part)
>>>
pid += monomers_per_chain
>>>
type += 1
>>>
system.storage.addParticles(chain, *props)
>>>
system.storage.decompose()
>>>
chain = []
>>>
bondlist.addBonds(bonds)
Note: try out the command
>>> espressopp.tools.topology.polymerRW(pid, startpos, monomers_per_chain, bondlen)
to see what it returns
Don’t forget to distribute the particles and the bondlist to the CPUs in the end:
>>> system.storage.decompose()
Finally add the information about the bonding potential. In this example we are using a FENE-potential between
the bonded particles.
>>> potFENE
= espressopp.interaction.FENE(K=30.0, r0=0.0, rMax=1.5)
>>> interFENE = espressopp.interaction.FixedPairListFENE(system, bondlist, potFENE)
>>> system.addInteraction(interFENE)
Start the integrator and observe how the system explodes. Like in the random Lennard Jones system, we have the
same problem here: particles can strongly overlap and thus will get very high forces accelerating them to infinite
12
Chapter 2. Tutorial
ESPResSo++ Documentation, Release latest
(for the computer) speed.
>>> espressopp.tools.analyse.info(system, integrator)
>>> for k in range(nsteps):
>>>
integrator.run(isteps)
>>>
espressopp.tools.analyse.info(system, integrator)
>>>
espressopp.tools.analyse.info(system, integrator)
Task 2:
Try to warmup and equilibrate a dense polymer melt (density=0.85) by using the warmup methods that you have
learned in the Lennard Jones tutorial.
Hint:
During warmup you can slowly switch on the excluded volume interaction by starting with a small epsilon and
increasing it during integration: You can do this by continuously overwriting the interaction potential after some
time interval.
>>> potLJ
= espressopp.interaction.LennardJones(new_epsilon, sigma, rc)
>>> interaction.setPotential(type1=0, type2=0, potential=potLJ)
AddNewPotential
The aim of the tutorial is to implement a new interaction potential in ESPResSo++. We start with the Gromos
fourth-power bond-stretching potential, because its functional form is simple and its implementation is somewhat
similar to other potentials already implemented in ESPResSo++. Everything you learn in this tutorial will then be
relevent for implementing any other more complicated potential.
Make sure you have a working, compiled version of ESPResSo++ before starting the tutorial.
For those who are not so familiar with C++ or interfacing python and C++, you will find some helpful notes in the
appendix.
Steps for adding a new interaction potential
1. Choose the potential and derive the force.
2. Choose the appropriate interaction template from those in $ESPRESSOHOME/src/interaction, e.g.
VerletListInteractionTemplate.hpp, FixedTripleListInteractionTemplate.hpp
3. Create
the
.cpp,
.hpp
and
.py
files
for
your
potential,
place
them
in
$ESPRESSOHOME/src/interaction and modify $ESPRESSOHOME/src/interaction/bindings.cpp
and $ESPRESSOHOME/src/interaction/__init__.py
4. Compile.
These steps are described in more detail below for our tutorial example potential.
Today’s tutorial exercise
Step 1
The potential we are implementing today is a two-body bonded potential with the form
 ( ) =
2.5. AddNewPotential
1
2
2
 (
− 0,
)2
4
13
ESPResSo++ Documentation, Release latest
noindent where  is the distance between particles i and j. The potential has two input parameters 0 and .
Derive the force.
Step 2
This is a 2-body interaction between a predefined (fixed) list of atom pairs. What is the appropriate interaction
template to use? Choose one in $ESPRESSOHOME/src/interaction
Open the interaction template file. (When you close the file later, close it without saving, or else later on your
compile time will be very long, because of the number of dependencies on the interaction template!) Identify the
functions addForces() and computeEnergy(). Many interaction templates also contain functions such as
computeVirial(), computeVirialX() (for calculating the virial in slabs along the x-direction) etc.
Find the function calls:
potential->_computeForce(force, dist)
in addForces() and
potential->_computeEnergy(r21)
in computeEnergy().
An interaction template can be combined with many different potentials (e.g. harmonic potential, Lennard Jones
potential, etc.) Each potential will have its own C++ class containing functions to compute the energy and forces
for that particular potential (see e.g. Harmonic.cpp/hpp, LennardJones.cpp/hpp) In turn, each potential can be
combined with many different interaction templates.
You don’t need to modify the interaction template file today. (Close it without saving!)
Step 3
In this step we create the .cpp, .hpp and .py files for our potential. Let’s call the potential FourthPower. The
FourthPower.py file will contain the end-user python interface, and in the FourthPower.cpp and FourthPower.hpp
files we will create a C++ class for our potential. We will also write a wrapper which will allow the user to call
the C++ code from the python interface.
3(a) Interfacing potential class and interaction template
In many cases, it’s not necessary to understand the contents of this section in order to implement a new potential.
If you like, you can skip directly to Section 3(b) Creating the new potential class.
Now we need to understand how the interaction template will interface with our new class. This is done via a class
template, e.g. in Potential.hpp, AnglePotential.hpp, DihedralPotential.hpp etc.
Still in $ESPRESSOHOME/src/interaction, open the file Potential.hpp. (When you close the file
later, close it without saving, or else later on your compile time will be very long, because of the number of
dependencies on the file!)
Find
the
functions
_computeForce(Real3D& force, const Real3D& dist)
and
_computeEnergy(real dist) which you identified in the interaction template.
Note
that
_computeForce(Real3D& force, const Real3D& dist)
calls
the
function
_computeForceRaw(force, dist, distSqr) and _computeEnergy(real dist) calls
_computeEnergySqr(dist*dist) which calls _computeEnergySqrRaw(distSqr). The functions
_computeForceRaw() and _computeEnergySqrRaw() are the new functions we need to write for our
new potential. They will be member methods of our new C++ class FourthPower.
You don’t need to modify anything in Potential.hpp today. (Close it without saving!)
14
Chapter 2. Tutorial
ESPResSo++ Documentation, Release latest
3(b) Creating the new potential class
An easy way to implement the new C++ class is to identify a previously implemented potential which somewhat
resembles your new potential, e.g. here we could take the Harmonic potential, which is also a 2-body potential,
and which has also been interfaced with the FixedPairListInteractionTemplate.
Still in $ESPRESSOHOME/src/interaction, copy the files Harmonic.py, Harmonic.cpp and
Harmonic.hpp to new files FourthPower.py, FourthPower.cpp and FourthPower.hpp. In the
new files, find and replace all occurences of ‘Harmonic’ with ‘FourthPower’, and ‘HARMONIC’ with ‘FOURTHPOWER’.
First modify FourthPower.hpp.
Note
the
#include
statement
for
FixedPairListInteractionTemplate.hpp
and
Potential.hpp, the files you examined in Step 2 and Step 3(a) Interfacing potential class and interaction template.
The Harmonic potential had parameters called K and r0. You can reuse these for the FourthPower potential, along
with the setters and getters setK, getK, setR0 and getR0. For better efficiency, you could also create a new
variable which contains the square of r0.
Now we need functions _computeForceRaw() and _computeEnergySqrRaw(), as explained in
Step 3(a) Interfacing potential class and interaction template. Modify these functions to use the functional form of the fourth power potential as derived in Step 1.
Note that Real3D dist, which
contains the vector between the two particles, has been defined as 1 − 2 (see addForces() in
FixedPairListInteractionTemplate.hpp).
Next open Harmonic.py and FourthPower.py.
Here is an example of an end-user’s python script to add an interaction using the harmonic potential:
harmonicbondslist = espresso.FixedPairList(system.storage)
harmonicbondslist.addBonds(bond_list) #bond_list is a list of tuples [(particleindex_i,particleind
harmonic_potential = espresso.interaction.Harmonic(K=10.0, r0=1.0, cutoff = 5.0, shift = 0.0)
harmonic_interaction = espresso.interaction.FixedPairListHarmonic(system, harmonicbondslist, poten
system.addInteraction(harmonic_interaction)
Compare this to the contents of Harmonic.py to understand the python source code.
Our new potential FourthPower can be called by the end-user in a similar way. Since the Harmonic and FourthPower potentials have similar input parameters (K, r0) and both use the FixedPairListInteractionTemplate, you
don’t need to make any further modifications to the file FourthPower.py, besides replacing ‘Harmonic’ with
‘FourthPower’.
Next open FourthPower.cpp.
Here you will find the C++/python interface, in the function registerPython(). If you want to understand
this function, you will find details in Exposing a C++ class or struct to python using boost. You don’t need to
make any further modifications to this file, besides replacing ‘Harmonic’ with ‘FourthPower’.
3(c) Including the new class in espressopp
Finally,
update
the
files
$ESPRESSOHOME/src/interaction/bindings.cpp
and
$ESPRESSOHOME/src/interaction/__init__.py (for example by copying and modifying all
the lines referring to the Harmonic potential so that they now refer to the FourthPower potential). You need to
make three modifications: to include the new .hpp file, to call the new registerPython() wrapper, and to import
everything in the new python module.
Step 4
Move to the directory $ESPRESSOHOME. Update the makefiles and compile using the commands:
2.5. AddNewPotential
15
ESPResSo++ Documentation, Release latest
cmake .
make
Advanced exercise
For an interaction potential of your choosing, follow the steps above to implement it, e.g. a non-bonded two-body
interaction, probably using VerletListInteractionTemplate and based on the LennardJones potential, or a bonded three-body interaction, probably using FixedTripleListInteractionTemplate.hpp
and based on the AngularHarmonic potential.
You will probably have to write setters and getters for the parameters in your potential in your .hpp file, and
make the corresponding modifications to the function registerPython() in the .cpp file and the python user
interface in the .py file.
Appendices
Exposing a C++ class or struct to python using boost
(See http://www.boost.org/doc/libs/1_56_0/libs/python/doc/tutorial/doc/html/python/exposing.html)
Say we have a C++ struct called World:
struct World
{
World(std::string msg): msg(msg) {}
void set(std::string msg) { this->msg = msg; }
std::string greet() { return msg; }
std::string msg;
};
//
//
//
//
constructor
function set
function greet
member variable
Now we write the C++ class wrapper for struct World to expose the constructor and the functions greet and set to
python:
{
class_<World>("World", init<std::string>())
.def("greet", &World::greet)
.def("set", &World::set)
;
}
If there are additional constructors we can also expose them using def(), e.g. for an additional constructor which
takes two doubles:
class_<World>("World", init<std::string>())
.def(init<double, double>())
.def("greet", &World::greet)
.def("set", &World::set)
;
We can also expose the data members of the C++ class or struct and the associated access (getter and setter)
functions using add_property(), e.g. for the variable myValue with access functions getMyValue and
setMyValue:
.add_property("myValue",&World::getMyValue,&World::setMyValue)
C++ classes and structs may be derived from other classes. Say we have the C++ struct myDerivedStruct which is
derived from the struct myBaseStruct:
struct myBaseStruct { virtual ~myBaseStruct(); };
struct myDerivedStruct : myBaseStruct {};
16
Chapter 2. Tutorial
ESPResSo++ Documentation, Release latest
We can wrap the base class myBaseStruct as explained above:
<Base>("Base")
/*...*/
;
Now when we want to wrap the class myDerivedStruct, we tell boost that it is derived from the base class myBaseStruct:
class_<myDerivedStruct, bases<myBaseStruct> >("myDerivedStruct")
/*...*/
;
C++ templates
See http://www.cplusplus.com/doc/oldtutorial/templates/
typedef
typedef declaration allows you to create an alias that can be used anywhere in place of a (possibly complex) type
name
typedef DataType AliasName;
Python notes
Syntax for classes in python
(See also https://docs.python.org/2/tutorial/classes.html)
Here is a python class called DerivedClassName which is derived from two other base classes (BaseClassName1
and BaseClassName1), is initialised with two variables x and y which have default values 1 and 2, and contains a
function myFunction.
class DerivedClassName(BaseClassName1, BaseClassName2):
"""docstring"""
#a way of providing some documentation for the class
def __init__(self,x=1,y=2): #takes two variable which have default values 1 and 2
self.x = x
self.y = y
def myFunction(self):
return self.x * self.y
PMI
PMI = parallel method invocation. For more details see the file $ESPRESSOHOME/src/pmi.py
Adaptive Resolution Simulations
Theory and Background
ESPResSo++ provides functionality to run adaptive resolution simulations using the Adaptive Resolution Simulation Scheme (AdResS). In AdResS molecules in different regions in a simulation box are described by different
non-bonded force fields, typically atomistic (AT) and coarse-grained (CG). These different subregions are interfaced and coupled via a hybrid region, where the interaction smoothly changes. Molecules can diffuse between
the different regions and change their interaction on the fly.
2.7. Adaptive Resolution Simulations
17
ESPResSo++ Documentation, Release latest
There are two different AdResS approaches: The force-based scheme, in which forces are interpolated, as well
as the energy-based scheme (Hamiltonian AdResS or H-AdResS) which interpolates on the level of potential
energies. In force-based AdResS (see, for example, Praprotnik et al., J. Chem. Phys. 123, 224106 (2005) as well
as Annu. Rev. Phys. Chem. 59, 545 (2008)), we have for the net force between the molecules  and 
CG
F| = (R )(R )FAT
| + (1 − (R )(R )) F| ,
where FAT
| is an AT force field based on the individual atoms belonging to the molecules  and  and  is a
position dependent resolution function smoothly changing from 1 in the AT region to 0 in the CG region via the
hybrid buffer region. It is evaluated based on the molecules’ center of mass positions R . Note that there can of
course also be bonded interactions, but these are typically not interpolated, as they are computationally usually
much cheaper to evaluate than the non-bonded forces. For the sake of clarity, we omit them here.
In H-AdResS (see Potestio et al., Phys. Rev. Lett. 110, 108301 (2013)), interpolation is performed directly on
potential energies in the Hamiltonian as
=
∑︁ {︀
∑︁ ∑︁ p2
}︀

+
(R )AT + (1 − (R )) CG ,
2

 ∈
where the first term corresponds to the kinetic energy and we again omitted intramolecular interactions. The forces
obtained from this Hamiltonian are
)︂
}︂
(︂
∑︁ ∑︁ {︂  + 
 + 
CG
+
FAT
1
−
F
F =
|
|
2
2
̸= ∈
− [AT − CG ] ∇  .
The last term, the so-called drift force, comes from applying the position gradient on the position-dependent
resolution function . It acts only in the hybrid region and unphysically pushes molecules from one region to the
other. Therefore, it needs to be corrected. On the other hand, force-based AdResS, contrary to H-AdResS, does
not allow a Hamiltonian formulation at all.
Usually, the force fields used in the different regions of the adaptive simulation setup have significantly different
pressures given the same temperature and particle density. This pressure gradient leads, in addition to the drift
force in H-AdResS, to particles being pushed across the hybrid region. Eventually, the system would evolve to
an equilibrium state with a inhomogeneous density profile across the simulation box. Therefore, correction forces
needs to be applied in the hybrid region to counter these effects. In H-AdResS one can use a so-called free energy
correction (FEC), which on average cancels the drift force in the hybrid region (see Potestio et al., Phys. Rev.
Lett. 110, 108301 (2013)). The FEC corresponds to the free energy difference between the subsystems and can,
for instance, be derived from Kirkwood thermodynamic integration. An alternative approach which is typically
used to cancel the pressure gradient in force-based AdResS is the so-called thermodynamic force (see Fritsch et
al., Phys. Rev. Lett. 108, 170602 (2012)). It is derived by constructing the correction directly from the distorted
density profile which is obtained without any correction and then refined iteratively.
ESPResSo++ code
Several measures had to be taken to implement adaptive resolution simulations in ESPResSo++. On top of the
normal particles, which serve as the CG particles in AdResS, another layer of extra AT particles is introduced
such that one has access to both atomistic and CG particles throughout the whole system. A mapping between
the two defines which atoms belong to which CG bead. The resolution function  is implemented as a particle
property of the CG particles that is updated after each integration step based on the new positions. This happens in
an extension to the Velocity Verlet integrator. The actual adaptive resolution scheme is then implemented via new
interaction templates that define how forces and energies are computed in force-based and energy-based AdResS.
These templates use for particle pairs in the atomistic region the actual atoms, this is the AT particles, for the force
and energy computation while in the CG region they use the CG particles. In the hybrid region, both are used, as
defined in the equations above. The drift term of H-AdResS is implemented similarly. Furthermore, the AdResS
integrator extension makes sure that the atomistic particles in the CG region travel along with the CG particles
and that similarly the CG particles in the AT region are properly updated according to the new atomistic positions
after each integration step. The FEC as well as a module to apply the Thermodynamic Force are implemented as
integrator extensions.
18
Chapter 2. Tutorial
ESPResSo++ Documentation, Release latest
In the following, we explain the new features step by step (more details about parameters etc. can be found in the
documention of the different classes).
Adress Domain Decomposition
When setting up the storage we have to use an appropriate domain decomposition that accomodates storage and
proper interprocessor communication of both AT and CG particles.
# (H-)AdResS domain decomposition
system.storage = espressopp.storage.DomainDecompositionAdress(system, nodeGrid, cellGrid)
Atomistic and Coarse-Grained particles
When adding particles to the storage, we have to define them as atomistic or coarse-grained. This has been
implemented as the particle property “adrat”. If it is 0, the particle is coarse-grained. If it is 1, it is an atomistic
particle.
# add particles to system
system.storage.addParticles(allParticles, "id", "pos", "v", "f", "type", "mass", "adrat")
When adding the particles as above, it is important that a set of atomistic particles belonging to one CG particle
appears in the list of particles allParticles always after the corresponding CG particle.
Next, the FixedTupleListAdress defines which atomistic particles belong to which coarse-grained particles.
# create FixedTupleList object and add the tuples
ftpl = espressopp.FixedTupleListAdress(system.storage)
ftpl.addTuples(tuples)
system.storage.setFixedTuplesAdress(ftpl)
In this example, tuples is a list of tuples, where each tuple itself is another short list in which the first element
is the CG particle and the other elements are the AT particles belonging to it. Note that in ESPResSo++ the CG
particle is positioned always in the center of mass of its atoms.
Having set up the FixedTupleList, we can also set up an AdResS fixed pair list that defines bonds between AT
particles within individual molecules. This is done in the following way:
# add bonds between AT particles
fpl = espressopp.FixedPairListAdress(system.storage, ftpl)
fpl.addBonds(bonds)
where bonds is a list of bonds between AT particles within CG molecules. Similarly, triple lists for angles,
quadruple lists for dihedrals etc. are set up. Compared to conventional bonds, angles, etc. between different
normal CG particles one just adds the suffix Adress to the appropriate list object and provides it also with the
FixedTupleList (ftpl in the example). Note that you can define several different such fixed pair lists and you
can, for example, also in AdResS simulations still use the normal FixedPairList to define bonds between
regular CG particles.
AdResS Verlet List
Next, we construct the AdResS Verlet list object for non-bonded interacting particle pairs:
# AdResS Verlet list
vl = espressopp.VerletListAdress(system, cutoff=0.8, adrcut=1.4,
dEx=1.5, dHy=1.0,
adrCenter=[Lx/2, Ly/2, Lz/2], sphereAdr=False)
We have to provide the cutoffs of the list as well as the sizes of the atomistic and hybrid regions. The parameter
cutoff corresponds to the cutoff used for CG particle pairs with both particles being in the CG region, while
adrcut is the cutoff for all other particle pairs (at least one particle of the pair is in the AT or hybrid region).
2.7. Adaptive Resolution Simulations
19
ESPResSo++ Documentation, Release latest
We want to stress that this pair list is build based on the CG particles’ positions. Hence, for the AT and hybrid
region one needs in some situations to provide a Verlet list cutoff (adrcut) slightly larger than the actual maximum
interaction range of the potential, in order to not lose interactions between some atom pairs. Let us clarify this with
an example: Thinking of a pair of water molecules, both coarse-grained into single beads, these CG beads could
be farther apart than the interaction cutoff. Two hydrogen atoms pointing towards each other, however, could in
fact still be in interaction range. Therefore, an appropriate buffer needs to be provided.
The sphereAdr flag decides how to geometrically set up the change in resolution. If it’s true, the AT region is
a spherical region positioned at adrCenter with radius dEx. If sphereAdr is false, the resolution changes
along the x-axis of the system and dEx corresponds to half the width of the AT region. dHy always is the full
width of the hybrid region. Instead of providing a 3D position for adrCenter as above, one can also provide a
particle ID of a CG particle. In this case, the atomistic region will follow the movement of the particle. This should
be only done, however, for force-based AdResS, since it would break the Hamiltonian character of H-AdResS, and
also only when using a spherical adaptive geometry. Then, however, it is even possible to provide a list of particle
IDs, in which case the AT region corresponds to the overlap of the spherical regions defined by the individual
particles provided in the list. It will deform accordingly while these particle move.
Interactions
When adding interactions to the system we have to use the corresponding interaction templates. Here is how to
set up a non-bonded interaction in a H-AdResS system:
# H-AdResS non-bonded interaction: WCA potential between AT particles
# and tabulated potential between CG particles
interNB = espressopp.interaction.VerletListHadressLennardJones(vl, ftpl)
potWCA = espressopp.interaction.LennardJones(epsilon=1.0, sigma=1.0, shift='auto',
cutoff=rca)
potCG = espressopp.interaction.Tabulated(itype=3, filename=tabCG, cutoff=rc) # CG
interNB.setPotentialAT(type1=1, type2=1, potential=potWCA) # AT
interNB.setPotentialCG(type1=0, type2=0, potential=potCG) # CG
system.addInteraction(interNB)
First, we define the appropriate interaction type, in H-AdResS this is VerletListHadressLennardJones.
Next we define the actual potentials. Then we associate them with the H-AdResS interaction and add
the interaction to the system. For force-based AdResS the only change required would be to use the
VerletListAdressLennardJones interaction.
Note that the here used interaction, VerletListHadressLennardJones, couples only Lennard-Jones-type
potentials with tabulated ones. However, there exist more such interaction templates for other potentials and
potential combinations.
AdResS Integrator Extension
Finally, we have to set up the AdResS integrator extension:
# AdResS integrator extension
adress = espressopp.integrator.Adress(system, verletlist, ftpl, regionupdates = 1)
integrator.addExtension(adress)
It takes as arguments the Verlet list and the fixed tuple list. Additionally, for the case of a moving and/or deforming
AdResS region based on one or more particles, the parameter regionupdates specifies how regularly we
want to update the shape of the AdResS region in number of steps. This is to avoid as much as possible of
the additional communication required to inform different processors of the change of the AdResS region. The
parameter defaults to 1 and is not used at all for static AdResS regions.
Having set up the AdResS extension, we can distribute all particles in the box and place the CG molecules in the
centers of mass of the atoms which they belong to. This can be done conveniently via
# distribute atoms and CG molecules according to AdResS domain decomposition,
# place CG molecules in the center of mass
espressopp.tools.AdressDecomp(system, integrator)
20
Chapter 2. Tutorial
ESPResSo++ Documentation, Release latest
Free Energy Compensation
When using H-AdResS, we probably want to also employ a FEC. This can be done as follows:
# set up FEC
fec = espressopp.integrator.FreeEnergyCompensation(system, center=[Lx/2, Ly/2, Lz/2])
fec.addForce(itype=3, filename="table_fec.tab", type=1)
integrator.addExtension(fec)
The FEC takes as arguments the system object as well as the center of the AT region. Then we add the actual force,
which needs to be provided in a table (first column: resolution , second: energy, third: force). itype defines
which type of interpolation should be used for values between the ones provided in the table. 1 corresponds to
linear interpolation, 2 to akima splines, 3 to cubic splines. We suggest to use cubic splines. The FEC is applied
on CG particles and distributed among the atoms belonging to the CG particle. type specifies the CG particle
type for which this correction should be applied. One can, for example, use different FECs for different molecules
types.
Thermodynamic Force
When using force-based AdResS, or, alternatively, in addition to the FEC in H-AdResS, we can use the thermodynamic force. It can be set up in the following way, very similar to the FEC before:
# set up Thermodynamic Force
thdforce = espressopp.integrator.TDforce(system, verletlist)
thdforce.addForce(itype=3,filename="table_tf.tab",type=1)
integrator.addExtension(thdforce)
It works largely as for the FEC with the following differences: The table should not provide resolution values in
the first column but actual distance values, this is, the distance from the (closest) AT region center. This allows
to extend the application of the thermodynamic force slightly beyond the borders of the hybrid region where the
resolution is constant. Furthermore, the Thermodynamic Force needs the verletlist as argument.
It is also possible to define a thermodynamic force, which is suited for an adaptive resolution setup with an AT
region that is constructed via the overlap of several spherical regions. In this case, the extension needs more
information:
# set up Thermodynamic Force
thdforce = espressopp.integrator.TDforce(system, verletlist, startdist = 0.9,
enddist = 2.1, edgeweightmultiplier = 20)
thdforce.addForce(itype=3,filename="table_tf.tab",type=1)
integrator.addExtension(thdforce)
It gets three more parameters, startdist, enddist and edgeweightmultiplier. startdist explicitely says at which distance from the center of the closest AT region defining particle the thermodynamic force
starts to act and enddist says where it ends. Hence, these value should correspond to what is actually written
in the table. edgeweightmultiplier is a parameter that speficies how precisely the thermodynamic force
should be applied in the overlap regions of different spheres. For most applications, however, 20 should provide
reasonable results (for details, see Kreis et al., J. Chem. Theory Comput. 12, 4067 (2016)). The 3 additional
parameters are of course also present with some default values in the basic case, but they are ignored unless we
have an AT region that is constructed via the overlap of several spherical regions.
Examples
We have provided several example scripts and setups that are available in the ESPResSo++ source code at
examples/adress. Most of them are based on published papers.
The reader is strongly encouraged to play around with them and test what happens when the setups are modified. Possible questions to ask are provided at the end of the following subsections, which explain the individual
examples in more detail.
2.7. Adaptive Resolution Simulations
21
ESPResSo++ Documentation, Release latest
Force-AdResS: Tetrahedral Liquid
Subfolder: fadress_tetraliquid. This example consists of the system that was used in the initial work
introducing the force-based adaptive resolution method (see Praprotnik et al., J. Chem. Phys. 123, 224106 (2005)
and Phys. Rev. E 73, 066701 (2006)). A liquid composed of artificial tetrahedral molecules, i.e. each molecule
consists of 4 bonded atoms arranged in a tetrahedral geometry, is coupled to a CG model which describes the
molecules as individual beads.
Questions: The geometry is set in such a way that the resolution changes along the x-axis of the box. Try changing
the setup such that the AT region is of spherical shape. You can also try removing the thermostat. Does the system
conserve energy? Also vary the size of the atomistic region and see what happens. Can you also make the system
all-atomistic or all-CG? You can also try to compare computational times.
Force-AdResS: A Protein in Water
Subfolder: fadress_protein. This system is an aqueous solution of the regulatory protein ubiquitin. The
atomistic protein and the atomistic water around it is coupled to a coarse-grained water model, which maps water
molecules farther away from the protein to single beads. The CG water interaction was parametrized with iterative
Boltzmann inversion (IBI). This system is similar to the setup which was used by Fogarty et al. (J. Chem. Phys.
142, 195101 (2015)) to study the structure and dynamics of a protein hydration shell.
Questions: The setup is significantly more complicated than the previous system. Try to understand the script.
You can also have a look into the the actual source code and try to understand, for example, how the gromacs
parser works. The example is set up as a fully atomistic simulation by setting the size of the atomistic region to a
value larger than the simulation box. Try to change the script such that it is an actual adaptive setup. Do not forget
the thermodynamic force! Furthermore, how is the high-resolution region positioned now?
Force-AdResS: Self-Adjusting Adaptive Resolution Simulations
Subfolder: fadress_selfadjusting. This setup demonstrates how force-based adaptive resolution simulations with self-adjusting high-resolution regions can be set up (Kreis et al., J. Chem. Theory Comput. 12, 4067
(2016)). The system is a polyalanine-9 molecule in aqueous solution. A spherical AT region is associated with
each atom of the peptide such that the overall AT region formed by the overlap of all these spheres elegantly
envelops the peptide. The peptide starts in an extended configuration and as it folds, the AT region surrounding
it adjusts itself accordingly. At the outside, we use again a coarse-grained IBI single-bead model for the water
molecules.
Questions: Can you change the system such that fewer atoms are associated with AT region, for example, only the
heavy atoms? Can you change the update frequency of the shape of the AT region?
H-AdResS: Tetrahedral Liquid
Subfolder: hadress_tetraliquid. This is the system used by Potestio et al. in the paper that proposed the
H-AdResS method (Phys. Rev. Lett. 110, 108301 (2013)). It is again a simple system composed of tetrahedral
molecules that change their resolution and become individual beads in the CG region. The interpolation occurs
along the x-axis. This example has three subfolders.
The first folder hadress_tetraliquid_plain runs a simple H-AdResS simulation without any free energy
correction. Hence, the drift force strongly pushes molecules from one region to the other. The script contains
analysis routines which measure both a density and a pressure profile along the direction of resolution change
while the simulation is running. Gathering enough statistics takes a while, but we have also provided reference
profiles which are obtained after a sufficiently long simulation. Have a look at them and try to interpret them.
The second folder hadress_tetraliquid_FEC contains the same setup but with a free energy correction.
For this, two tables are provided, table_FEC_Helmholtz.dat and table_FEC_Gibbs.dat. They were
derived via Kirkwood thermodynamic integration. The first one is based on the Helmholtz free energy difference
per particle between the two subsystem, and the second one corresponds to the Gibbs free energy difference
per particle. Two density and pressure profiles obtained while applying these correction are also shown. Try to
interpret them.
22
Chapter 2. Tutorial
ESPResSo++ Documentation, Release latest
The third folder hadress_tetraliquid_KTI contains a simple implementation of Kirkwood thermodynamic integration (KTI) which could in principle, when run for long enough, be used to derive the FEC. This
is not an adaptive resolution simulation. Instead, we tell the AdResS integrator extension that we want to run
KTI. Then, the extension does not modify the resolution values associated with the different molecules and we
can change them by hand during the simulation. In this way, we can set up a simulation in which we change the
resolution of all molecules in the system every few steps and slowly proceed from a complete CG system to an
all-atom one. Have a look and try to understand what is going on.
There are many more interesting things you can try out: Are the H-AdResS simulations energy conserving? Add
the commented Langevin thermostat and compare. Also vary the timestep. Additionally, you can change the size
of the hybrid region. What happens if it becomes smaller or larger? Furthermore, what happens if you change the
system from H-AdResS to force-based AdResS?
H-AdResS: Water
Subfolder: hadress_water. This is a slightly more advanced H-AdResS system in which an atomistic model
is coupled to a coarse-grained one, mapping the three water atoms onto single beads.
Questions: Feel free to play around with the system. You could also try to figure out, how the gromacs parsers
sets up the interactions and chooses the right H-AdResS interactions.
Thermodynamic integration
Theoretical explanation
Thermodynamic integration (TI) is a method used to calculate the free energy difference between two states A and
B. For the theoretical background, see e.g. http://www.alchemistry.org. In this tutorial, we show how to perform
TI calculations with ESPResSo++. We calculate the free energy of solvation of methanol in water. The complete
python script is available in the ESPResSo+ source code under examples/thd_integration_solvation
To do TI, we define states A and B, with potentials   and   . We then construct a pathway of intermediate
states between A and B by defining a parameter  that takes values between 0 and 1 and writing the system
potential  as a function of ,   and   . The free energy difference between the states A and B is then given
by
⟩
∫︁ 1 ⟨
 ()
d
∆ =

0

In practise, we discretise  and perform a series of MD simulations with different  values between 0 and 1,
sampling () in each simulation.
To calculate the solvation free energy of methanol in water, we use a box of water containing one methanol
molecule. We simulate desolvation via two separate TI calculations. (Note that the procedure described here
is decoupling, and solute-solute interactions will be treated differently if you’re doing annihilation instead of
decoupling, see Note 1.)
Step 1: free energy change for switching off the Coulombic interactions
State A: methanol has full non-bonded (Coulomb and Lennard Jones) interactions with the solvent
State B: methanol has only Lennard Jones interactions with the solvent
Step 2: free energy change for switching off the Lennard Jones interactions
State A: methanol has only Lennard Jones interactions with the solvent
State B: methanol has no interaction with the solvent
2.8. Thermodynamic integration
23
ESPResSo++ Documentation, Release latest
Step 1 can be done using a linear function of :
 ( ) = (1 −  ) +   
where  is the solute-solvent Coulombic interaction in state A. In ESPResSo++ the charges used for state A
are the particle charges contained in the particle property charge. The charges in state B are zero, so  ()
does not appear in the expression. (The case where A and B both have non-zero charges is not implemented
in ESPResSo++). The term    is all other parts of the potential that don’t change with  including
all bonded interactions, any solute-solute Coulombic interactions, solvent-solvent Coulombic interactions and all
Lennard-Jones interactions. The parameter  goes from 0 to 1 in Step 1.
Step 2 must be done using a softcore potential because of the singularity in the Lennard-Jones potential at  = 0.
∑︁
 ( ) =
 ( ,  ) +   
,


 ( ,  ) = (1 −  )
( ) +  
( )
6 
6 1/6
 = (
 + 
)
6
6 1/6
 = (
(1 − ) + 
)


The terms 
( ) and 
( ) are the normal Lennard-Jones 12-6 hardcore potentials:


( ) = 4.0 (
 12  6
−
)


∑︀
The sum ,  ( ,  ) is over all solute-solvent interactions. The term    is all other parts of the
potential that don’t change with  including any solute-solute Lennard-Jones interactions and solvent-solvent
Lennard-Jones interactions, which are treated using standard hardcore Lennard-Jones. (In this particular example
of methanol, there are no solute-solute Lennard-Jones interactions). Finally  and  are adjustable parameters of
the softcore potential.
The ESPResSo++ C++ code allows for different values of  ,  ,  and  for every pair of atomtypes interacting via this potential. In this example, we will set  to 0 (we are switching off the Lennard-Jones interaction).
The parameter  goes from 0 to 1 in Step 2.
ESPResSo++ code
We must perform many separate simulations, each with a different  value. It is convenient to define a list of 
values in the python script and use an index to access a different element of the list in each separate simulation.
The script for the first simulation contains these lines:
# Parameters for Thermodynamic Integration
stateBIndices = [1,2,3,4,5,6] #indices of the methanol atoms
lambdaVectorCoul = [0.00, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30,
0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85,
1.000, 1.000, 1.000, 1.000, 1.000, 1.000,
1.000, 1.000, 1.000, 1.000, 1.000, 1.000,
1.000, 1.000, 1.000, 1.000, 1.000, 1.000,
1.000, 1.000, 1.000, 1.000, 1.000, 1.000,
1.000, 1.000, 1.000]
lambdaVectorVdwl = [0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00,
0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00,
0.050, 0.075, 0.100, 0.125, 0.150, 0.175,
0.275, 0.300, 0.325, 0.350, 0.375, 0.400,
0.500, 0.525, 0.550, 0.575, 0.600, 0.625,
0.725, 0.750, 0.775, 0.800, 0.825, 0.850,
0.950, 0.975, 1.000]
lambdaIndex = 0
lambdaTICoul = lambdaVectorCoul[lambdaIndex]
lambdaTIVdwl = lambdaVectorVdwl[lambdaIndex]
24
0.35, 0.40, 0.45, 0.50,
0.90, 0.95, 1.00, 1.000,
1.000, 1.000, 1.000,
1.000, 1.000, 1.000,
1.000, 1.000, 1.000,
1.000, 1.000, 1.000,
0.00, 0.00, 0.00, 0.00,
0.00, 0.00, 0.00, 0.025,
0.200, 0.225, 0.250,
0.425, 0.450, 0.475,
0.650, 0.675, 0.700,
0.875, 0.900, 0.925,
Chapter 2. Tutorial
ESPResSo++ Documentation, Release latest
The list lambdaVectorCoul contains the values of  and the list lambdaVectorVdwl contains the values of  . The total number of simulations to do Step 1 and Step 2 will be len(lambdaVectorCoul) or
len(lambdaVectorVdwl). We must make a copy of the python script for each simulation, changing each
time the value of lambdaIndex.
Next we set up the Coulombic interactions, assuming we already have created a system and a verletlist.
The electrostatics method used is generalised reaction field.
#atTypes - list of all atomtypes (integers) used in the pairs interacting via this potential
#epsilon1,epsilon2,kappa - reaction field parameters
#annihilate=False means decoupling is used (see Note 1)
#ftpl - a FixedTupleListAdResS object (see AdResS tutorial)
#for non-AdResS simulations, simply set adress=False, and the parameter ftpl is not needed
qq_adres_interaction = gromacs.setCoulombInteractionsTI(system, verletlist, nbCutoff,
atTypes, epsilon1=1, epsilon2=80,
kappa=0, lambdaTI=lambdaTICoul,
pidlist=stateBIndices,
annihilate=False, adress=True, ftpl=ftpl)
Now we set up the softcore Lennard Jones interaction.
#atomtypeparameters - dictionary of format {atomtype: {'eps': epsilon, 'sig': sigma}}
#
where atomtype is integer and epsilon and sigma are real
#defaults - dictionary containing a key 'combinationrule' with value 1 if the contents
#
of atomtypeparameters need to be converted from c6,c12 format to
#
epsilon,sigma format; can also be an empty dictionary if no conversion needed
#sigmaSC, alphaSC, powerSC - parameters of the softcore potential
alphaSC = 0.5
powerSC = 1.0
epsilonB = 0.0
sigmaSC = 0.3
lj_adres_interaction = gromacs.setLennardJonesInteractionsTI(system, defaults,
atomtypeparameters, verletlist, nbCutoff,
epsilonB=epsilonB, sigmaSC=sigmaSC, alphaSC=alphaSC,
powerSC=powerSC, lambdaTI=lambdaTIVdwl,
pidlist=stateBIndices, annihilate=False,
adress=True, ftpl=ftpl)
We open an output file. In the first line we write the values of  and  for this simulation.
dhdlF = open("dhdl.xvg","a")
dhdlF.write("#(coul-lambda, vdw-lambda) = ("+str(lambdaTICoul)+", "+str(lambdaTIVdwl)+")\n")
During the MD run, every x number of MD steps, we return to the python level and calculate the derivatives of the
energies with respect to .
dhdlCoul = qq_adres_interaction.computeEnergyDeriv()
dhdlVdwl = lj_adres_interaction.computeEnergyDeriv()
dhdlF.write(str(time)+" "+str(dhdlCoul)+" "+str(dhdlVdwl)+"\n")
After all simulations, we can now average () for each value of  or  , integrate over  and  , add the
values ∆ and ∆ , and take the negative (because the procedure described here is desolvation and we want
the free energy of solvation).
Some notes
1. This example given here uses decoupling (solute-solvent interactions are a function of , solute-solute
interactions are not affected by changes in ). In ESPResSo++ it is also possible to do annihilation, where
both solute-solvent and solute-solute interactions are a function of , by setting annihilate=True when
creating the non-bonded interactions.
2. The procedure described here is desolvation. To get the free energy of solvation, we take the negative of the
value obtained after integration.
2.8. Thermodynamic integration
25
ESPResSo++ Documentation, Release latest
3. The
example
Python
code
snippets
here
use
the
helper
functions
gromacs.setLennardJonesInteractionsTI and gromacs.setCoulombInteractionsTI
contained
in
$ESPRESSOHOME/src/tools/convert/gromacs.py,
but
this
is
not necessary.
You can do TI with ESPResSo++ without the Gromacs parser
by
directly
calling
espresso.interaction.LennardJonesSoftcoreTI
and
espresso.interaction.ReactionFieldGeneralizedTI. See the documentation of these two
classes.
26
Chapter 2. Tutorial
CHAPTER
THREE
USER INTERFACE
analysis
espressopp.analysis.AllParticlePos
espressopp.analysis.AllParticlePos.gatherAllPositions()
Return type
espressopp.analysis.AnalysisBase
Overview
List of classes based on AnalysisBase:
espressopp.analysis.LBOutput
Overview
espressopp.analysis.LBOutputScreen
espressopp.analysis.LBOutputVzInTime
espressopp.analysis.LBOutputVzOfX
Details
Abstract output class for LB simulations. The implemented realisations are:
• espressopp.analysis.LBOutputScreen to output simulation progress and control flux conservation when using MD to LB coupling.
• espressopp.analysis.LBOutputVzInTime to output velocity component  on the lattice site
with an index (0.25 *  , 0, 0) in time.
• espressopp.analysis.LBOutputVzOfX to output local density  and  component of the velocity
as a function of the coordinate .
Note: all derived output classes have to be called from class espressopp.integrator.ExtAnalyze
with specified periodicity of invokation and after this added to the integrator. See examples.
27
ESPResSo++ Documentation, Release latest
espressopp.analysis.LBOutputScreen
Computes and outputs to the screen the simulation progress (finished step) and controls mass flux conservation
when using MD-to-LB coupling. Ideally, the sum of mass fluxes should be 0, i.e.  +   = 0.
class espressopp.analysis.LBOutputScreen(system, lb)
Parameters
• system (shared_ptr) – system object defined earlier in the python-script
• lb (lb_object) – lattice boltzmann object defined earlier in the python-script
Example:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
# initialise output to the screen
outputScreen = espressopp.analysis.LBOutputScreen(system,lb)
# initialise external analysis object with previously created output object
# and periodicity of invocation (steps):
extAnalysis = espressopp.integrator.ExtAnalyze(outputScreen,100)
# add the external analysis object as an extension to the integrator
integrator.addExtension( extAnalysis )
espressopp.analysis.LBOutputVzInTime
Computes and outputs the velocity component  in time on the lattice site with an index (0.25 *  , 0, 0).
class espressopp.analysis.LBOutputVzInTime(system, lb)
Parameters
• system (shared_ptr) – system object defined earlier in the python-script
• lb (lb_object) – lattice boltzmann object defined earlier in the python-script
Example:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
# initialise output of the Vz as a function of time
outputVzInTime = espressopp.analysis.LBOutputVzInTime(system,lb)
# initialise external analysis object with previously created output object
# and periodicity of invocation (steps):
extAnalysis = espressopp.integrator.ExtAnalyze(outputVzInTime,100)
# add the external analysis object as an extension to the integrator
integrator.addExtension( extAnalysis )
espressopp.analysis.LBOutputVzOfX
Computes and outputs simulation progress (finished step) and controls flux conservation when using MD to LB
coupling.
class espressopp.analysis.LBOutputVzOfX(system, lb)
Parameters
• system (shared_ptr) – system object defined earlier in the python-script
• lb (lb_object) – lattice boltzmann object defined earlier in the python-script
Example:
28
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
# initialise output of the Vz as a function of x-coordinate
outputVzOfX = espressopp.analysis.LBOutputVzOfX(system,lb)
# initialise external analysis object with previously created output object
# and periodicity of invocation (steps):
extAnalysis = espressopp.integrator.ExtAnalyze(outputVzOfX,100)
# add the external analysis object as an extension to the integrator
integrator.addExtension( extAnalysis )
espressopp.analysis.OrderParameter
espressopp.analysis.OrderParameter(system,
cutoff,
do_cluster_analysis,
ql_low, ql_high)
angular_momentum,
include_surface_particles,
Parameters
• system –
• cutoff –
• angular_momentum (int) – (default: 6)
• do_cluster_analysis – (default: False)
• include_surface_particles – (default: False)
• ql_low – (default: -1.0)
• ql_high (real) – (default: 1.0)
espressopp.analysis.ParticleRadiusDistribution
espressopp.analysis.ParticleRadiusDistribution(system)
Parameters system –
espressopp.analysis.PressureTensor
This class computes the pressure tensor of the system. It can be used as standalone class in python as well as in
combination with the integrator extension ExtAnalyze.
Example of standalone Usage:
>>> pt = espressopp.analysis.PressureTensor(system)
>>> print "pressure tensor of current configuration = ", pt.compute()
or
>>> pt = espressopp.analysis.PressureTensor(system)
>>> for k in xrange(100):
>>>
integrator.run(100)
>>>
pt.performMeasurement()
>>> print "average pressure tensor = ", pt.getAverageValue()
Example of usage in integrator with ExtAnalyze:
>>>
>>>
>>>
>>>
>>>
pt
= espressopp.analysis.PressureTensor(system)
extension_pt = espressopp.integrator.ExtAnalyze(pt , interval=100)
integrator.addExtension(extension_pt)
integrator.run(10000)
pt_ave = pt.getAverageValue()
3.1. analysis
29
ESPResSo++ Documentation, Release latest
>>> print "average Pressure Tensor = ", pt_ave[:6]
>>> print "
std deviation = ", pt_ave[6:]
>>> print "number of measurements = ", pt.getNumberOfMeasurements()
The following methods are supported:
• performMeasurement() computes the pressure tensor and updates average and standard deviation
• reset() resets average and standard deviation to 0
• compute() computes the instant pressure tensor, return value: [xx, yy, zz, xy, xz, yz]
• getAverageValue() returns the average pressure tensor and the standard deviation, return value: [xx, yy,
zz, xy, xz, yz, +-xx, +-yy, +-zz, +-xy, +-xz, +-yz]
• getNumberOfMeasurements() counts the number of measurements that have been computed (standalone
or in integrator) does _not_ include measurements that have been done using “compute()”
espressopp.analysis.PressureTensor(system)
Parameters system –
espressopp.analysis.PressureTensorLayer
This class computes the pressure tensor of the system in layer h0. It can be used as standalone class in python as
well as in combination with the integrator extension ExtAnalyze.
Example of standalone Usage:
>>> pt = espressopp.analysis.PressureTensorLayer(system, h0, dh)
>>> print "pressure tensor of current configuration = ", pt.compute()
or
>>> pt = espressopp.analysis.PressureTensorLayer(system)
>>> for k in xrange(100):
>>>
integrator.run(100)
>>>
pt.performMeasurement()
>>> print "average pressure tensor = ", pt.getAverageValue()
Example of usage in integrator with ExtAnalyze:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
pt
= espressopp.analysis.PressureTensorLayer(system)
extension_pt = espressopp.integrator.ExtAnalyze(pt , interval=100)
integrator.addExtension(extension_pt)
integrator.run(10000)
pt_ave = pt.getAverageValue()
print "average Pressure Tensor = ", pt_ave[:6]
print "
std deviation = ", pt_ave[6:]
print "number of measurements = ", pt.getNumberOfMeasurements()
The following methods are supported:
• performMeasurement() computes the pressure tensor and updates average and standard deviation
• reset() resets average and standard deviation to 0
• compute() computes the instant pressure tensor in layer h0, return value: [xx, yy, zz, xy, xz, yz]
• getAverageValue() returns the average pressure tensor and the standard deviation, return value: [xx, yy,
zz, xy, xz, yz, +-xx, +-yy, +-zz, +-xy, +-xz, +-yz]
• getNumberOfMeasurements() counts the number of measurements that have been computed (standalone
or in integrator) does _not_ include measurements that have been done using “compute()”
espressopp.analysis.PressureTensorLayer(system, h0, dh)
Parameters
30
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• system –
• h0 –
• dh –
espressopp.analysis.PressureTensorMultiLayer
This class computes the pressure tensor of the system in n layers. Layers are perpendicular to Z direction and
are equidistant(distance is Lz/n). It can be used as standalone class in python as well as in combination with the
integrator extension ExtAnalyze.
Example of standalone Usage:
>>> pt = espressopp.analysis.PressureTensorMultiLayer(system, n, dh)
>>> for i in xrange(n):
>>>
print "pressure tensor in layer %d: %s" % ( i, pt.compute())
or
>>> pt = espressopp.analysis.PressureTensorMultiLayer(system, n, dh)
>>> for k in xrange(100):
>>>
integrator.run(100)
>>>
pt.performMeasurement()
>>> for i in xrange(n):
>>>
print "average pressure tensor in layer %d: %s" % ( i, pt.compute())
Example of usage in integrator with ExtAnalyze:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
pt
= espressopp.analysis.PressureTensorMultiLayer(system, n, dh)
extension_pt = espressopp.integrator.ExtAnalyze(pt , interval=100)
integrator.addExtension(extension_pt)
integrator.run(10000)
pt_ave = pt.getAverageValue()
for i in xrange(n):
print "average Pressure Tensor = ", pt_ave[i][:6]
print "
std deviation = ", pt_ave[i][6:]
print "number of measurements = ", pt.getNumberOfMeasurements()
The following methods are supported:
• performMeasurement() computes the pressure tensor and updates average and standard deviation
• reset() resets average and standard deviation to 0
• compute() computes the instant pressure tensor in n layers, return value: [xx, yy, zz, xy, xz, yz]
• getAverageValue() returns the average pressure tensor and the standard deviation, return value: [xx, yy,
zz, xy, xz, yz, +-xx, +-yy, +-zz, +-xy, +-xz, +-yz]
• getNumberOfMeasurements() counts the number of measurements that have been computed (standalone
or in integrator) does _not_ include measurements that have been done using “compute()”
espressopp.analysis.PressureTensorMultiLayer(system, n, dh)
Parameters
• system –
• n–
• dh –
espressopp.analysis.Temperature
Calculate the temperature of the system (in   units).
3.1. analysis
31
ESPResSo++ Documentation, Release latest
espressopp.analysis.Temperature(system)
Parameters system (shared_ptr) – system object
Returns temperature
Return type real
Temperature of the system of  particles is calculated as:
 =

1 ∑︁
 2 ,
 =1
where  and  are the mass and velocity of a particle .
 = 3 is the number of the system’s degrees of freedom.
Example:
>>>
>>>
>>>
>>>
>>>
# declare an object, e.g., T:
T
= espressopp.analysis.Temperature(system)
# later in your script compute temperature and print it:
print T.compute()
espressopp.analysis.Test
Test class for any analysis tool.
espressopp.analysis.Test(system)
Parameters system –
Details
This abstract base class provides the interface and some basic functionality for classes that do analysis or observable measurements
It provides the following methods:
espressopp.analysis.AnalysisBase.compute()
Computes the instant value of the observable.
Return type a python list or a scalar
espressopp.analysis.AnalysisBase.getAverageValue()
Returns the average value for the observable and the standard deviation.
Return type a python list
espressopp.analysis.AnalysisBase.getNumberOfMeasurements()
counts the number of measurements that have been performed (standalone or in integrator) does _not_
include measurements that have been done using “compute()”
Return type
espressopp.analysis.AnalysisBase.performMeasurement()
Computes the observable and updates average and standard deviation
Return type
espressopp.analysis.AnalysisBase.reset()
Resets average and standard deviation
Return type
32
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.analysis.Autocorrelation
espressopp.analysis.Autocorrelation(system)
Parameters system –
espressopp.analysis.Autocorrelation.clear()
Return type
espressopp.analysis.Autocorrelation.compute()
Return type
espressopp.analysis.Autocorrelation.gather(value)
Parameters value –
Return type
espressopp.analysis.CMVelocity
Compute and reset (set to zero) the center-of-mass (CM) velocity of the system.
class espressopp.analysis.CMVelocity(system)
Parameters system (espressopp.System) – system object
Note: CMVelocity can be attached to the integrator. In this case the reset() method is called, so you
will reset the CM-velocity every n-th steps.
Methods
compute()
Compute the CM-velocity of the system
Return type Real3D
reset()
Reset (set to zero) the CM-velocity of the system. Done by computing the CM-velocity of the system
and subtracting it then from every particle.
Return type void
Example of resetting velocity
>>> total_velocity = espressopp.analysis.CMVelocity(system)
>>> total_velocity.reset()
Example of attaching to integrator
>>>
>>>
>>>
>>>
>>>
# This extension can be attached to integrator
# and run `reset()` every `n-th` steps.
total_velocity = espressopp.analysis.CMVelocity(system)
ext_remove_com = espressopp.integrator.ExtAnalyze(total_velocity, 10)
integrator.addExtension(ext_remove_com)
espressopp.analysis.ConfigsParticleDecomp
espressopp.analysis.ConfigsParticleDecomp(system)
Parameters system –
espressopp.analysis.ConfigsParticleDecomp.clear()
3.1. analysis
33
ESPResSo++ Documentation, Release latest
Return type
espressopp.analysis.ConfigsParticleDecomp.compute()
Return type
espressopp.analysis.ConfigsParticleDecomp.gather()
Return type
espressopp.analysis.ConfigsParticleDecomp.gatherFromFile(filename)
Parameters filename –
Return type
espressopp.analysis.Configurations
• gather() add configuration to trajectory
• clear() clear trajectory
• back() get last configuration of trajectory
• capacity maximum number of configurations in trajectory further adding (gather()) configurations results
in erasing oldest configuration before adding new one capacity=0 means: infinite capacity (until memory is
full)
• size number of stored configurations
usage:
storing trajectory
>>> configurations = espressopp.Configurations(system)
>>> configurations.gather()
>>> for k in xrange(100):
>>>
integrator.run(100)
>>>
configurations.gather()
accessing trajectory data:
iterate over all stored configurations:
>>> for conf in configurations:
iterate over all particles stored in configuration:
>>>
>>>
>>>
for pid in conf
particle_coords = conf[pid]
print pid, particle_coords
access particle with id <pid> of stored configuration <n>:
>>> print "particle coord: ",configurations[n][pid]
espressopp.analysis.Configurations(system)
Parameters system –
espressopp.analysis.Configurations.back()
Return type
espressopp.analysis.Configurations.clear()
Return type
espressopp.analysis.Configurations.gather()
Return type
34
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.analysis.ConfigurationsExt
• gather() add configuration to trajectory
• clear() clear trajectory
• back() get last configuration of trajectory
• capacity maximum number of configurations in trajectory further adding (gather()) configurations results
in erasing oldest configuration before adding new one capacity=0 means: infinite capacity (until memory is
full)
• size number of stored configurations
usage:
storing trajectory
>>> configurations = espressopp.ConfigurationsExt(system)
>>> configurations.gather()
>>> for k in xrange(100):
>>>
integrator.run(100)
>>>
configurations.gather()
accessing trajectory data:
iterate over all stored configurations:
>>> for conf in configurations:
iterate over all particles stored in configuration:
>>>
>>>
>>>
for pid in conf
particle_coords = conf[pid]
print pid, particle_coords
access particle with id <pid> of stored configuration <n>:
>>> print "particle coord: ",configurations[n][pid]
espressopp.analysis.ConfigurationsExt(system)
Parameters system –
espressopp.analysis.ConfigurationsExt.back()
Return type
espressopp.analysis.ConfigurationsExt.clear()
Return type
espressopp.analysis.ConfigurationsExt.gather()
Return type
espressopp.analysis.Energy
espressopp.analysis.EnergyPot(system, per_atom)
Parameters
• system –
• per_atom – (default: False)
espressopp.analysis.EnergyPot.compute()
Return type
3.1. analysis
35
ESPResSo++ Documentation, Release latest
espressopp.analysis.EnergyKin(system, per_atom)
Parameters
• system –
• per_atom – (default: False)
espressopp.analysis.EnergyKin.compute()
Return type
espressopp.analysis.EnergyTot(system, per_atom)
Parameters
• system –
• per_atom – (default: False)
espressopp.analysis.EnergyTot.compute()
Return type
espressopp.analysis.IntraChainDistSq
espressopp.analysis.IntraChainDistSq(system, fpl)
Parameters
• system –
• fpl –
espressopp.analysis.IntraChainDistSq.compute()
Return type
espressopp.analysis.MeanSquareDispl
espressopp.analysis.MeanSquareDispl(system, chainlength)
Parameters
• system –
• chainlength – (default: None)
espressopp.analysis.MeanSquareDispl.computeG2()
Return type
espressopp.analysis.MeanSquareDispl.computeG3()
Return type
espressopp.analysis.MeanSquareDispl.strange()
Return type
espressopp.analysis.MeanSquareInternalDist
espressopp.analysis.MeanSquareInternalDist(system, chainlength)
Parameters
• system –
• chainlength –
36
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.analysis.MeanSquareInternalDist.strange()
Return type
espressopp.analysis.Observable
Overview
List of classes based on Observable:
espressopp.analysis.AdressDensity
Class to compute radial density profiles in adaptive resolution simulations based on distance to closest AdResS
center. Works also for multiple overlapping AdResS regions.
Examples:
>>> densityprofile = espressopp.analysis.AdressDensity(system, verletlist)
>>> # creates the class
>>> densityprofile.addExclusions([1,2,3])
>>> # defines particle to be excluded from the calculation based on list of particle ids
>>> densityprofile.compute(100)
>>> # computes the densityprofile using 100 bins
espressopp.analysis.AdressDensity(system, verletlist)
Parameters
• system (shared_ptr<System>) – system object
• verletlist (shared_ptr<VerletListAdress>) – verletlist object
espressopp.analysis.AdressDensity.compute(bins)
Parameters bins (int) – number of bins
Return type list of reals
espressopp.analysis.AdressDensity.addExclusions(pidlist)
Parameters pidlist (list of ints) – list of ids of particles to be excluded from the
calculation
espressopp.analysis.CenterOfMass
espressopp.analysis.CenterOfMass(system)
Parameters system –
espressopp.analysis.MaxPID
espressopp.analysis.MaxPID(system)
Parameters system –
3.1. analysis
37
ESPResSo++ Documentation, Release latest
espressopp.analysis.NeighborFluctuation
espressopp.analysis.NeighborFluctuation(system, radius)
Parameters
• system –
• radius –
espressopp.analysis.NPart
espressopp.analysis.NPart(system)
Parameters system –
espressopp.analysis.PotentialEnergy
The object that computes potential energy of different interactions.
espressopp.analysis.PotentialEnergy(system, potential, compute_method=None)
Parameters
• system (espressopp.System) – The system object
• interaction (espressopp.interaction.Interaction) – The interaction
object.
• compute_method (str) – If set to ALL (default) then compute total potential energies, if set to CG then compute only coarse-grained part (if feasible), if set to AT then
compute only atomitic part of potential energy.
espressopp.analysis.Pressure
espressopp.analysis.Pressure(system)
Parameters system –
espressopp.analysis.RadialDistrF
espressopp.analysis.RadialDistrF(system)
Parameters system –
espressopp.analysis.RadialDistrF.compute(rdfN)
Parameters rdfN –
Return type
espressopp.analysis.RDFatomistic
Class to compute radial distribution functions in adaptive resolution simulations in subregions of the box.
Option 1 (spanbased = True): the RDF can be calculated in a cuboid region in the center of the box (periodic in
y,z, limited in x). In this case, particle pairs are considered for which at least one of them is in the defined cuboid
region. This can be useful when the high resolution region has a slab geometry. No further normalization should
be required.
Option 2 (spanbased = False): the routine can also calculate unnormalized RDFs using particle pairs with both
particles being in the high resolution region (based on the resolution value lambda, the span parameter is not used
then). This can be useful when atomistic region has complicated or spherical geometries.
38
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
In any case, only pairs of atomistic particles belonging to two different coarse-grained particles are considered.
Furthermore, note that the routine uses L_y / half (L_y is the box length in y-direction) as the maximum distance
for the RDF calculation, which is then binned according to rdfN during the computation. Hence, L_y should be
the shortest box side (or, equally short as L_x and/or L_z).
Examples:
>>> rdf_0_1 = espressopp.analysis.RDFatomistic(system = system, type1 = 0, type2 = 1, spanbased =
>>> # creates the class for calculating the RDF between atomistic particles of type 1 and 0 betwee
>>> # At least one of these particles has to be within plus/minus 1.5 from the center of the box i
>>> rdf_0_1.compute(100)
>>> # computes the rdf using 100 bins over a distance corresponding to L_y / 2.0
espressopp.analysis.RDFatomistic(system, type1, type2, spanbased, span)
Parameters
• system (shared_ptr<System>) – system object
• type1 (int) – type of atom 1
• type2 (int) – type of atom 2
• spanbased (bool) – (default: True) If True, calculates RDFs in a cuboid region of
radius span from the center (limited in x, periodic in y,z). If False, calculates RDFs with
both particles being in the high resolution region (using lambda resolution values and
ignoring span parameter).
• span (real) – (default: 1.0) +/- distance from centre of box in x-direction of the
cuboid region used for RDF calculation if spanbased == True. If spanbased == False,
this parameter is not used.
espressopp.analysis.RDFatomistic.compute(rdfN)
Parameters rdfN (int) – number of bins
Return type list of reals
espressopp.analysis.StaticStructF
espressopp.analysis.StaticStructF(system)
Parameters system –
espressopp.analysis.StaticStructF.compute(nqx, nqy, nqz, bin_factor, ofile)
Parameters
• nqx –
• nqy –
• nqz –
• bin_factor –
• ofile – (default: None)
Return type
espressopp.analysis.StaticStructF.computeSingleChain(nqx, nqy, nqz, bin_factor,
chainlength, ofile)
Parameters
• nqx –
• nqy –
• nqz –
3.1. analysis
39
ESPResSo++ Documentation, Release latest
• bin_factor –
• chainlength –
• ofile – (default: None)
Return type
espressopp.analysis.XDensity
espressopp.analysis.XDensity(system)
Parameters system –
espressopp.analysis.XDensity.compute(rdfN)
Parameters rdfN –
Return type
espressopp.analysis.XPressure
espressopp.analysis.XPressure(system)
Parameters system –
espressopp.analysis.XPressure.compute(N)
Parameters N –
Return type
espressopp.analysis.XTemperature
espressopp.analysis.XTemperature(system)
Parameters system –
espressopp.analysis.XTemperature.compute(N)
Parameters N –
Return type
Details
espressopp.analysis.Observable.compute()
Return type
espressopp.analysis.SystemMonitor
SystemMonitor prints and logs to file values obtained from Observables like temperature, pressure or potential
energy.
espressopp.analysis.SystemMonitor(system, integrator, output)
Parameters
• system (espressopp.System) – The system object.
• integrator (espressopp.integrator.MDIntegrator) – The MD integrator.
40
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• output (espressopp.analysis.SystemMonitorOutputCSV) – The output object.
espressopp.analysis.SystemMonitor.add_observable(name, observable, is_visible)
The function adds new observable to SystemMonitor.
Parameters
• name (str) – The name of observable
• observable – The observable, eg. espressopp.analysis.PotentialEnergy
• is_visible (bool) – If set to True then values will be print on console.
espressopp.analysis.SystemMonitor.info()
The method print out on console the values of observables.
CSV Output
The output of SystemMonitor to CSV files.
espressopp.analysis.SystemMonitorOutputCSV(file_name, delimiter)
Parameters
• file_name (str) – The name of CSV file.
• delimiter (str) – The field delimiter, by default it is tabulator.
Example
>>> interaction = espressopp.interaction.VerletListLennardJones(verletlist)
>>> interaction.setPotential(type1=0, type2=0,
potential=espressopp.interaction.LennardJones(epsilon=1.0, sigma=1.0,
cutoff=2.0))
>>> system_monitor_csv = espressopp.analysis.SystemMonitorOutputCSV('out.csv')
>>> system_monitor = espressopp.analysis.SystemMonitor(
system, integrator, espressopp.analysis.SystemMonitorOutputCSV('out.csv'))
>>> system_monitor.add_observable('pot', espressopp.analysis.PotentialEnergy(system, interaction))
>>> ext_analysis = espressopp.integrator.ExtAnalyze(system_monitor, 10)
>>> integrator.addExtension(ext_analysis)
espressopp.analysis.Velocities
espressopp.analysis.Velocities(system)
Parameters system –
espressopp.analysis.Velocities.clear()
Return type
espressopp.analysis.Velocities.gather()
Return type
espressopp.analysis.VelocityAutocorrelation
espressopp.analysis.VelocityAutocorrelation(system)
Parameters system –
3.1. analysis
41
ESPResSo++ Documentation, Release latest
espressopp.analysis.Viscosity
espressopp.analysis.Viscosity(system)
Parameters system –
espressopp.analysis.Viscosity.compute(t0, dt, T)
Parameters
• t0 –
• dt –
• T–
Return type
espressopp.analysis.Viscosity.gather()
Return type
bc
espressopp.bc.BC
Overview
espressopp.bc.OrthorhombicBC
espressopp.bc.SlabBC
Details
This is the abstract base class for all boundary condition objects. It cannot be used directly. All derived classes
implement at least the following methods:
class espressopp.bc.BC
getFoldedPosition(pos, imageBox)
Parameters
• pos –
• imageBox – (default: None)
Return type
getMinimumImageVector(pos1, pos2)
Parameters
• pos1 –
• pos2 –
Return type
getRandomPos()
Return type
getUnfoldedPosition(pos, imageBox)
Parameters
42
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• pos –
• imageBox –
Return type
pos, pos1 and pos2 are particle coordinates ( type: (float, float, float) ). imageBox ( type: (int, int, int) )
specifies the
espressopp.bc.OrthorombicBC
Like all boundary condition objects, this class implements all the methods of the base class BC , which are
described in detail in the documentation of the abstract class BC.
The OrthorhombicBC class is responsible for the orthorhombic boundary condition. Currently only periodic
boundary conditions are supported.
Example:
>>> boxsize = (Lx, Ly, Lz)
>>> bc = espressopp.bc.OrthorhombicBC(rng, boxsize)
espressopp.bc.OrthorhombicBC(rng, boxL)
Parameters
• rng –
• boxL (real) – (default: 1.0)
espressopp.bc.OrthorhombicBC.setBoxL(boxL)
Parameters boxL –
espressopp.bc.SlabBC
Like all boundary condition objects, this class implements all the methods of the base class BC , which are
described in detail in the documentation of the abstract class BC.
The SlabBC class is responsible for a cuboid boundary condition that is periodic in all but the “dir” dimension.
Currently, dir is set arbirtrarily to “0” (the x-direction).
Example:
>>> boxsize = (Lx, Ly, Lz)
>>> bc = espressopp.bc.SlabBC(rng, boxsize)
espressopp.bc.SlabBC(rng, boxL)
Parameters
• rng –
• boxL (real) – (default: 1.0)
espressopp.bc.SlabBC.setBoxL(boxL)
Parameters boxL –
3.2. bc
43
ESPResSo++ Documentation, Release latest
check
espressopp.check.System
esutil
espressopp.esutil.Collectives
locate the node with here=True (e.g. indicating that data of a distributed storage is on the local node). This is a
collective SPMD function.
here is a boolean value, which should be True on at most one node. Returns on the controller the number of the
node with here=True, or an KeyError exception if no node had the item, i.e. had here=True.
espressopp.esutil.locateItem(here)
Parameters here –
espressopp.esutil.GammaVariate
espressopp.esutil.GammaVariate(alpha, beta)
Parameters
• alpha –
• beta –
espressopp.esutil.Grid
espressopp.esutil.NormalVariate
espressopp.esutil.NormalVariate(mean, sigma)
Parameters
• mean (real) – (default: 0.0)
• sigma (real) – (default: 1.0)
espressopp.esutil.RNG
espressopp.esutil.UniformOnSphere
external
integrator
espressopp.integrator.Adress
The AdResS object is an extension to the integrator. It makes sure that the integrator also processes the atomistic
particles and not only the CG particles. Hence, this object is of course only used when performing AdResS or
H-AdResS simulations.
In detail the AdResS extension makes sure:
44
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• that also the forces on the atomistic particles are initialized and set to by Adress::initForces
• that also the atomistic particles are integrated and propagated by Adress::integrate1 and Adress::integrate2
Example - how to turn on the AdResS integrator extension:
>>> adress = espressopp.integrator.Adress(system, verletlist, fixedtuplelist)
>>> integrator.addExtension(adress)
If KTI is set to True, then the resolution parameters are not updated. This can be used for example for Kirkwood
thermodynamic integration, during which one manually sets the whole system on different resolution parameters.
KTI = True then prevents overwriting these manually set values. Furthermore, when having moving AdResS
regions based on particles, regionupdates specifies the update frequency of the AdResS region in number of steps
(or, to be more precise, calls of communicateAdrPositions()). Note that there is a tradeoff: The more frequently
the AdResS region is updated, the more gradually and accurately the AdResS region changes and adapts it shape.
This could allow for a smaller overall AdResS region and possibly a smoother simulation. However, when having
many AdResS region defining particles, these frequent updates can become computationally significant and cost
additional simulation time. The optimum is highly system and application dependent.
class espressopp.integrator.Adress(_system, _verletlist, _fixedtuplelist, KTI = False, regionupdates = 1)
Parameters
• _system (shared_ptr<System>) – system object
• _verletlist (shared_ptr<VerletListAdress>) – verletlist object
• _fixedtuplelist (shared_ptr<FixedTupleListAdress>) – fixedtuplelist object
• KTI (bool) – update resolution parameter? (Yes: set False, No: set True)
• regionupdates (int) – after how many steps does the AdResS region needs to be
updated?
espressopp.integrator.AssociationReaction
espressopp.integrator.BerendsenBarostat
This is the Berendsen barostat implementation according to the original paper [Berendsen84]. If Berendsen barostat is defined (as a property of integrator) then at the each run the system size and the particle coordinates will be
scaled by scaling parameter  according to the formula:
 = [1 − ∆/ (0 −  )]1/3
where ∆ - integration timestep,  - time parameter (coupling parameter), 0 - external pressure and  - instantaneous pressure.
Example:
>>>
>>>
>>>
>>>
berendsenP = espressopp.integrator.BerendsenBarostat(system)
berendsenP.tau = 0.1
berendsenP.pressure = 1.0
integrator.addExtension(berendsenP)
!IMPORTANT In order to run npt simulation one should separately define thermostat as well (e.g. BerendsenThermostat).
Definition:
In order to define the Berendsen barostat
>>> berendsenP = espressopp.integrator.BerendsenBarostat(system)
one should have the System defined.
3.6. integrator
45
ESPResSo++ Documentation, Release latest
Properties:
• berendsenP.tau
The property ‘tau’ defines the time parameter  .
• berendsenP.pressure
The property ‘pressure’ defines the external pressure 0 .
Setting the integration property:
>>> integrator.addExtension(berendsenP)
It will define Berendsen barostat as a property of integrator.
One more example:
>>>
>>>
>>>
>>>
berendsen_barostat = espressopp.integrator.BerendsenBarostat(system)
berendsen_barostat.tau = 10.0
berendsen_barostat.pressure = 3.5
integrator.addExtension(berendsen_barostat)
Canceling the barostat:
If one do not need the pressure regulation in system anymore or need to switch the ensamble or whatever :)
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
# define barostat with parameters
berendsen = espressopp.integrator.BerendsenBarostat(system)
berendsen.tau = 0.8
berendsen.pressure = 15.0
integrator.addExtension(berendsen)
...
# some runs
...
# disconnect Berendsen barostat
berendsen.disconnect()
# the next runs will not include the system size and particle coordinates scaling
Connecting the barostat back after the disconnection
>>> berendsen.connect()
References:
espressopp.integrator.BerendsenBarostat(system)
Parameters system –
espressopp.integrator.BerendsenBarostatAnisotropic
#TODO fix these comments This is the Berendsen barostat implementation according to the original paper
[Berendsen84]. If Berendsen barostat is defined (as a property of integrator) then at the each run the system
size and the particle coordinates will be scaled by scaling parameter  according to the formula:
 = [1 − ∆/ (0 −  )]1/3
where ∆ - integration timestep,  - time parameter (coupling parameter), 0 - external pressure and  - instantaneous pressure.
Example:
>>>
>>>
>>>
>>>
46
berendsenP = espressopp.integrator.BerendsenBarostatAnisotropic(system)
berendsenP.tau = 0.1
berendsenP.pressure = 1.0
integrator.addExtension(berendsenP)
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
!IMPORTANT In order to run npt simulation one should separately define thermostat as well (e.g. BerendsenThermostat).
Definition:
In order to define the Berendsen barostat
>>> berendsenP = espressopp.integrator.BerendsenBarostatAnisotropic(system)
one should have the System defined.
Properties:
• berendsenP.tau
The property ‘tau’ defines the time parameter  .
• berendsenP.pressure
The property ‘pressure’ defines the external pressure 0 .
Setting the integration property:
>>> integrator.addExtension(berendsenP)
It will define Berendsen barostat as a property of integrator.
One more example:
>>>
>>>
>>>
>>>
berendsen_barostat = espressopp.integrator.BerendsenBarostatAnisotropic(system)
berendsen_barostat.tau = 10.0
berendsen_barostat.pressure = 3.5
integrator.addExtension(berendsen_barostat)
Canceling the barostat:
If one do not need the pressure regulation in system anymore or need to switch the ensamble or whatever :)
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
# define barostat with parameters
berendsen = espressopp.integrator.BerendsenBarostatAnisotropic(system)
berendsen.tau = 0.8
berendsen.pressure = 15.0
integrator.addExtension(berendsen)
...
# some runs
...
# disconnect Berendsen barostat
berendsen.disconnect()
# the next runs will not include the system size and particle coordinates scaling
Connecting the barostat back after the disconnection
>>> berendsen.connect()
espressopp.integrator.BerendsenBarostatAnisotropic(system)
Parameters system –
espressopp.integrator.BerendsenThermostat
This is the Berendsen thermostat implementation according to the original paper [Berendsen84]. If Berendsen
thermostat is defined (as a property of integrator) then at the each run the system size and the particle coordinates
will be scaled by scaling parameter  according to the formula:
 = [1 + ∆/ (0 / − 1)]1/2
3.6. integrator
47
ESPResSo++ Documentation, Release latest
where ∆ - integration timestep,  - time parameter (coupling parameter), 0 - external temperature and  instantaneous temperature.
Example:
>>>
>>>
>>>
>>>
berendsenT = espressopp.integrator.BerendsenThermostat(system)
berendsenT.tau = 1.0
berendsenT.temperature = 1.0
integrator.addExtension(berendsenT)
Definition:
In order to define the Berendsen thermostat
>>> berendsenT = espressopp.integrator.BerendsenThermostat(system)
one should have the System defined.
Properties:
• berendsenT.tau
The property ‘tau’ defines the time parameter  .
• berendsenT.temperature
The property ‘temperature’ defines the external temperature 0 .
Setting the integration property:
>>> integrator.addExtension(berendsenT)
It will define Berendsen thermostat as a property of integrator.
One more example:
>>>
>>>
>>>
>>>
berendsen_thermostat = espressopp.integrator.BerendsenThermostat(system)
berendsen_thermostat.tau = 0.1
berendsen_thermostat.temperature = 3.2
integrator.addExtension(berendsen_thermostat)
Canceling the thermostat:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
# define thermostat with parameters
berendsen = espressopp.integrator.BerendsenThermostat(system)
berendsen.tau = 2.0
berendsen.temperature = 5.0
integrator.addExtension(berendsen)
...
# some runs
...
# disconnect Berendsen thermostat
berendsen.disconnect()
Connecting the thermostat back after the disconnection
>>> berendsen.connect()
espressopp.integrator.BerendsenThermostat(system)
Parameters system –
espressopp.integrator.CapForce
This class can be used to forcecap all particles or a group of particles. Force capping means that the force vector
of a particle is rescaled so that the length of the force vector is <= capforce
Example Usage:
48
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
>>> capforce
= espressopp.integrator.CapForce(system, 1000.0)
>>> integrator.addExtension(capForce)
CapForce can also be used to forcecap only a group of particles:
>>> particle_group = [45, 67, 89, 103]
>>> capforce
= espressopp.integrator.CapForce(system, 1000.0, particle_group)
>>> integrator.addExtension(capForce)
espressopp.integrator.CapForce(system, capForce, particleGroup)
Parameters
• system –
• capForce –
• particleGroup – (default: None)
espressopp.integrator.DPDThermostat
espressopp.integrator.DPDThermostat(system, vl)
Parameters
• system –
• vl –
espressopp.integrator.EmptyExtension
espressopp.integrator.EmptyExtension(system)
Parameters system –
espressopp.integrator.ExtAnalyze
This class can be used to execute nearly all analysis objects within the main integration loop which allows to
automatically accumulate time averages (with standard deviation error bars).
Example Usage:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
pt
= espressopp.analysis.PressureTensor(system)
extension_pt = espressopp.integrator.ExtAnalyze(pt , interval=100)
integrator.addExtension(extension_pt)
integrator.run(10000)
pt_ave = pt.getAverageValue()
print "average Pressure Tensor = ", pt_ave[:6]
print "
std deviation = ", pt_ave[6:]
print "number of measurements = ", pt.getNumberOfMeasurements()
espressopp.integrator.ExtAnalyze(action_obj, interval)
Parameters
• action_obj –
• interval (int) – (default: 1)
3.6. integrator
49
ESPResSo++ Documentation, Release latest
espressopp.integrator.Extension
espressopp.integrator.Extension.connect()
Return type
espressopp.integrator.Extension.disconnect()
Return type
espressopp.integrator.ExtForce
espressopp.integrator.ExtForce(system, extForce, particleGroup)
Parameters
• system –
• extForce –
• particleGroup – (default: None)
espressopp.integrator.FixPositions
espressopp.integrator.FixPositions(system, particleGroup, fixMask)
Parameters
• system –
• particleGroup –
• fixMask –
espressopp.integrator.FreeEnergyCompensation
Free Energy Compensation used in Hamiltonian Adaptive Resolution Simulations (H-AdResS). This works for
spherical or slab adaptive resolution geometries. However, it only works for fixed, non-moving atomistic region
(otherwise, H-AdResS is not properly defined).
Example:
>>>
>>>
>>>
>>>
>>>
>>>
fec = espressopp.integrator.FreeEnergyCompensation(system, center=[Lx/2, Ly/2, Lz/2])
# set up the fec module with the center in the center of the box
fec.addForce(itype=3,filename="tablefec.xvg",type=typeCG)
# set up the actual force
integrator.addExtension(fec)
# add to previously defined integrator
espressopp.integrator.FreeEnergyCompensation(system, center, sphereAdr)
Parameters
• system (shared_ptr<System>) – system object
• center (list of reals) – (default: [], corresponds to (0.0, 0.0, 0.0) position)
center of high resolution region
• sphereAdr (bool) – (default: False) Spherical AdResS region (True) vs. slab geometry with resolution change in x-direction (False)
espressopp.integrator.FreeEnergyCompensation.addForce(itype, filename, type)
Parameters
• itype (int) – interpolation type 1: linear, 2: Akima, 3: Cubic
50
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• filename (string) – filename for TD force file
• type (int) – particle type on which the TD force needs to be applied
espressopp.integrator.FreeEnergyCompensation.computeCompEnergy()
Return type real
espressopp.integrator.GeneralizedLangevinThermostat
espressopp.integrator.GeneralizedLangevinThermostat(system)
Parameters system –
espressopp.integrator.GeneralizedLangevinThermostat.addCoeffs(itype,
filename, type)
Parameters
• itype –
• filename –
• type –
Return type
espressopp.integrator.Isokinetic
espressopp.integrator.Isokinetic(system)
Parameters system –
espressopp.integrator.LangevinBarostat
This is the barostat implementation to perform Langevin dynamics in a Hoover style extended system according
to the paper [Quigley04]. It includes corrections of Hoover approach which were introduced by Martyna et
al [Martyna94]. If LangevinBarostat is defined (as a property of integrator) the integration equations will be
modified. The volume of system  is introduced as a dynamical variable:


˙  =  +



˙  = − ▽ Φ − (1 +
 
)  −  + 
  
˙ =   /
˙ =  ( −  ) +

 ∑︁ 2
−   + 
 =1 
where volume has a fictitious mass  and associated momentum  ,  - friction coefficient,  - external
pressure and  - instantaneous pressure without white noise contribution from thermostat,  - dimension,  degrees of freedom (if there are no constrains and  is the number of particles in system  =  ).  - values
which are drawn from Gaussian distribution of zero mean and unit variance scaled by
√︂
2   
∆
!IMPORTANT Terms − +  correspond to the termostat. They are not included here and will not be
calculated if the Langevin Thermostat is not defined.
Example:
3.6. integrator
51
ESPResSo++ Documentation, Release latest
>>>
>>>
>>>
>>>
>>>
>>>
rng = espressopp.esutil.RNG()
langevinP = espressopp.integrator.LangevinBarostat(system, rng, desiredTemperature)
langevinP.gammaP = 0.05
langevinP.pressure = 1.0
langevinP.mass = pow(10.0, 4)
integrator.addExtension(langevinP)
!IMPORTANT This barostat is supposed to be run in a couple with thermostat in order to simulate the npt
ensamble, because the term  needs the temperature as a parameter.
Definition:
In order to define the Langevin-Hoover barostat
>>> langevinP = espressopp.integrator.LangevinBarostat(system, rng, desiredTemperature)
one should have the System and RNG defined and know the desired temperature.
Properties:
• langevinP.gammaP
The property ‘gammaP’ defines the friction coefficient  .
• langevinP.pressure
The property ‘pressure’ defines the external pressure  .
• langevinP.mass
The property ‘mass’ defines the fictitious mass  .
Methods:
• setMassByFrequency( frequency )
Set the proper langevinP.mass using expression  =    /2 , where frequency,  , is the frequency of
required volume fluctuations. The value of  should be less then the lowest frequency which appears in
the NVT temperature spectrum [Quigley04] in order to match the canonical distribution.  - dimensions, 
- number of particles,  - Boltzmann constant,  - desired temperature.
NOTE The langevinP.mass can be set both directly and using the (setMassByFrequency( frequency ))
Adding to the integration:
>>> integrator.addExtension(langevinP)
It will define Langevin-Hoover barostat as a property of integrator.
One more example:
>>>
>>>
>>>
>>>
>>>
>>>
rngBaro = espressopp.esutil.RNG()
lP = espressopp.integrator.LangevinBarostat(system, rngBaro, desiredTemperature)
lP.gammaP = .5
lP.pressure = 1.0
lP.mass = pow(10.0, 5)
integrator.addExtension(lP)
Canceling the barostat:
If one do not need the pressure regulation in system anymore or need to switch the ensamble or whatever :)
>>>
>>>
>>>
>>>
>>>
>>>
52
# define barostat with parameters
rngBaro = espressopp.esutil.RNG()
lP = espressopp.integrator.LangevinBarostat(system, rngBaro, desiredTemperature)
lP.gammaP = .5
lP.pressure = 1.0
lP.mass = pow(10.0, 5)
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
>>>
>>>
>>>
>>>
>>>
>>>
>>>
integrator.langevinBarostat = lP
...
# some runs
...
# disconnect barostat
langevinBarostat.disconnect()
# the next runs will not include the modification of integration equations
Connecting the barostat back after the disconnection
>>> langevinBarostat.connect()
References:
espressopp.integrator.LangevinBarostat(system, rng, temperature)
Parameters
• system –
• rng –
• temperature –
espressopp.integrator.LangevinThermostat
Langevin Thermostat
Example:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
langevin = espressopp.integrator.LangevinThermostat(system)
# set up the thermostat
langevin.gamma = gamma
# set friction coefficient gamma
langevin.temperature = temp
# set temperature
langevin.adress = True
# set adress (default is False)
integrator.addExtension(langevin)
# add extensions to a previously defined integrator
espressopp.integrator.LangevinThermostat(system)
Parameters system (shared_ptr<System>) – system object
espressopp.integrator.LangevinThermostat.addExclusions(pidlist)
Parameters pidlist (list of ints) – list of particle ids to be excluded from thermostating. In adaptive (AdResS) simulations, add ids of atomistic particles to be excluded
(thermostats acts in this case on atomistic level). For normal simulations, add normal or
coarse-grained particle ids.
espressopp.integrator.LangevinThermostat1D
espressopp.integrator.LangevinThermostat1D(system)
Parameters system –
espressopp.integrator.LangevinThermostatHybrid
As LangevinThermostat, but for use in AdResS systems, to allow the application of different thermostat friction
constants () to different AdResS regions. Uses three values of , one for the atomistic region, one for the hybrid
region, and one for the coarse-grained region.
3.6. integrator
53
ESPResSo++ Documentation, Release latest
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
# create FixedTupleList object
ftpl = espressopp.FixedTupleListAdress(system.storage)
ftpl.addTuples(tuples)
system.storage.setFixedTuplesAdress(ftpl)
system.storage.decompose()
# create Langevin thermostat
thermostat
= espressopp.integrator.LangevinThermostatHybrid(system,ftpl)
# set Langevin friction constants
thermostat.gamma
= 0.0 # units = 1/timeunit
print "# gamma for atomistic region for langevin thermostat = ",thermostat.gamma
thermostat.gammahy
= 10.0 # units = 1/timeunit
print "# gamma for hybrid region for langevin thermostat = ",thermostat.gammahy
thermostat.gammacg
= 10.0 # units = 1/timeunit
print "# gamma for coarse-grained region for langevin thermostat = ",thermostat.gammacg
# set temperature of thermostat
thermostat.temperature = kBT
# kBT is a float with the value of temperature in reduced units, i.e. temperature * Boltzmann'
No need to include the line
>>> thermostat.adress = True
as is necessary in the case of the basic LangevinThermostat, because LangevinThermostatHybrid is always only
used in AdResS systems
espressopp.integrator.LangevinThermostatOnGroup
Thermalize particles in the ParticleGroup only.
espressopp.integrator.LangevinThermostatOnGroup(system, particle_group)
Parameters
• system (espressopp.System) – The system object.
• particle_group (espressopp.ParticleGroup) – The particle group.
Example
>>>
>>>
>>>
>>>
>>>
>>>
>>>
pg = espressopp.ParticleGroup(system.storage)
for pid in range(10):
pg.add(pid)
thermostat = espressopp.integrator.LangevinThermostatOnGroup(system, pg)
thermostat.temperature = 1.0
thermostat.gamma = 1.0
integrator.addExtension(thermostat)
espressopp.integrator.LangevinThermostatOnRadius
Langevin Thermostat for Radii of Particles
Example:
>>>
>>>
>>>
>>>
54
radius_mass = mass
# set virtual mass for dynamics of radius
langevin = espressopp.integrator.LangevinThermostatOnRadius(system, radius_mass)
# set up the thermostat
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
>>>
>>>
>>>
>>>
>>>
>>>
langevin.gamma = gamma
# set friction coefficient gamma
langevin.temperature = temp
# set temperature
integrator.addExtension(langevin)
# add extensions to a previously defined integrator
espressopp.integrator.LangevinThermostatOnRadius(system, dampingmass)
Parameters
• system –
• _dampingmass –
espressopp.integrator.LangevinThermostatOnRadius.addExclusions(pidlist)
Parameters pidlist (list of ints) – list of particle ids to be excluded from thermostating.
espressopp.integrator.LatticeBoltzmann
Overview
espressopp.integrator.LatticeBoltzmann
Details
The LatticeBoltzmann (LB) class controls fluid hydrodynamics and allows for hybrid LB/MD simulations. It is
implemented as espressopp.integrator.Extension in ESPResSo++.
class espressopp.integrator.LatticeBoltzmann(system, nodeGrid, a = 1., tau = 1.,
numDims = 3, numVels = 19)
Parameters
• system (shared_ptr) – system object
• nodeGrid (Int3D) – arrangement of CPUs in space
• a (real) – lattice spacing (in lattice units).
• tau (real) – time discretization (in lattice units)
• numDims (int) – dimensionality of the LB model
• numVels (int) – number of velocity vectors in the LB model
Returns lb object
The LB-fluid in ESPResSo++ is aiming at simulations of complex soft matter systems. They consist of MD
particles (colloids, composite nanoparticles or polymer chains) that are solved in the LB-fluid preserving
hydrodynamic interactions.
The default lattice model is D3Q19 (numDims = 3, numVels = 19) and both lattice spacing a and
timestep tau are set to 1. If some other lattice model is needed feel free to modify the code: adding 3D
ones is straightforward, for 2D cases one has to make more thouroughs changes.
The parameters of the LB-fluid are expected in Lennard-Jones (LJ) units. This strategy helps users with
MD-background think of LB-fluid in term of LJ liquid. One only has to specify its properties such as liquid
density, , temperature,  , and viscosity, .
Note: Standard LJ fluid can be characterized by  ∼ 1[ −3 ],  ∼ 1[], and  ∼ 5[ / 3 ]
3.6. integrator
55
ESPResSo++ Documentation, Release latest
Example
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
L = 20
# create cubic box
box = (L, L, L)
# The rc+skin= lattice_size
rc = 0.9
skin= 0.1
# initialize empty default system with the created cubic box.
system, integrator = espressopp.standard_system.Default(box)
# nodeGrid is determined based on the number of CPUs used for simulation among others
nodeGrid=espressopp.tools.decomp.nodeGrid(espressopp.MPI.COMM_WORLD.size,box,rc,skin)
# initialize lb object. The dimensions of the lattice are obtained from the
# system's box dimensions employing lattice spacing 1.
lb = espressopp.integrator.LatticeBoltzmann(system, nodeGrid)
Methods
getLBMom(node, moment)
Get hydrodynamic moment from a specific node
Parameters
• node (Int3D) – node index
• moment (int) – hydrodynamic moment to get
Use 0 to get density  and 1-3 for mass flux components  ,  and  , correspondingly.
setLBMom(node, moment, value)
Set hydrodynamic moment for a specific node
Parameters
• node (Int3D) – node index
• moment (int) – hydrodynamic moment to set
• value (real) – value to set
saveLBConf()
Dumps LB configuration with separate files for coupling forces, LB-fluid moments and populations
(the last one is a bit overkill). The dump files are written for every CPU separately and are put in the
dump folder
keepLBDump()
Sets a flag to keep previously dumped LB configuration. Normally the previous dump is deleted after
a new one is made.
Example
>>> # set bulk viscosity
>>> for k in range (10):
>>>
integrator.run(50000)
>>>
>>>
# output LB configuration
>>>
lb.keepLBDump()
# flag to keep previously saved LB state
>>>
lb.saveLBConf()
# saves current state of the LB fluid
Properties
Int3D nodeGrid
Array of CPUs in space
Example
56
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
>>> # it is advised to set nodeGrid by internal ESPResSo++ function
>>> # based on the number of CPUs
>>> nodeGrid=espressopp.tools.decomp.nodeGrid(espressopp.MPI.COMM_WORLD.size,box,rc,skin)
real a = 1.
Lattice spacing (lattice units)
real tau = 1.
Lattice time step (lattice units)
int numDims = 3
Number of dimensions of the LB model (D3Q19)
int numVels = 19
Number of velocity vectors of the LB model (D3Q19)
real visc_b
Bulk viscosity (LJ units), affects gamma_b.
Example
>>> # set bulk viscosity
>>> lb.visc_b = 5.
real visc_s
Shear viscosity (LJ units), affects gamma_s.
Example
>>> # set shear viscosity
>>> lb.visc_s = 5.
real gamma_b = 0.
Bulk gamma (for experienced LB users)
real gamma_s = 0.
Shear gamma (for experienced LB users)
real gamma_odd = 0.
Odd gamma (for experienced LB users)
real gamma_even = 0.
Even gamma (for experienced LB users)
real lbTemp = 0.
Temperature of the LB fluid (LJ units)
Example
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
L = 20
T = 1.
N = 200
# create cubic box
box = (L, L, L)
rc=0.9
skin=0.1
# initialize Lennard Jones system with the created cubic box and given temperature.
system, integrator = espressopp.standard_system.LennardJones(N, box, temperature=T)
# nodeGrid is determined based on the number of CPUs used for simulation
nodeGrid=espressopp.tools.decomp.nodeGrid(espressopp.MPI.COMM_WORLD.size,box,rc,skin)
# initialize lb object. The dimensions of the lattice are obtained from the
# system's box dimensions employing lattice spacing 1.
lb = espressopp.integrator.LatticeBoltzmann(system, nodeGrid)
3.6. integrator
57
ESPResSo++ Documentation, Release latest
>>>
>>> # set LB temperature to T
>>> lb.lbTemp = T
real fricCoeff=5.
Friction coefficient of the coupling (LJ units)
Example
>>> # set friction coefficient of the coupling
>>> lb.fricCoeff = 20.
int nSteps = 1
Timescale contrast (ratio) between LB and MD
Example
>>> # set time step contrast between LB and MD
>>> lb.nSteps = 10
int profStep = 10000
Frequency of time profiling
Example
>>> # set profiling frequency
>>> lb.profStep = 5000
Int3D getMyNi
Number of real and halo nodes for the CPU
espressopp.integrator.LBInit
Overview
espressopp.integrator.LBInitPopUniform
espressopp.integrator.LBInitPopWave
espressopp.integrator.LBInitConstForce
espressopp.integrator.LBInitPeriodicForce
Details
This abstract class provides the interface to (re-)initialize populations and handle external forces.
class espressopp.integrator.LBInit
createDenVel(rho0, u0)
to set initial density and velocity of the LB-fluid.
Parameters
• rho0 (real) – density
• u0 (Real3D) – velocity
The following options for LB-fluid initialization are supported:
•espressopp.integrator.LBInitPopUniform A typical choice. It initializes uniformly distributed density and velocity: On every lattice site the density is rho0 and velocity is u0
•espressopp.integrator.LBInitPopWave for uniform density at every lattice site, but harmonic velocity  () with the period of lattice sites in x-direction
58
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
setForce(value)
to set an external force onto LB-fluid.
Parameters value (Real3D) – value of the force
addForce(force)
to add a new external force to the existing one.
Parameters force (Real3D) – value of the force
Two main external force types are implemented:
•espressopp.integrator.LBInitConstForce to manage constant (gravity-like) forces acting on every lattice site and
•espressopp.integrator.LBInitPeriodicForce to manage periodic (sin-like) forces
espressopp.integrator.LBInitPopUniform
This class creates LB-fluid with uniform density rho0 and velocity u0 (lattice units).
Example:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
# set initial density and velocity
initDen = 1.
initVel = Real3D( 0. )
# create initPop object and initialize populations
initPop = espressopp.integrator.LBInitPopUniform(system,lb)
initPop.createDenVel( initDen, initVel )
espressopp.integrator.LBInitPopWave
This class creates LB-fluid with uniform density and harmonic velocity (lattice units):
 = 0,  = 0,  () =  · (2 ·  / ), where  is the amplitude of the velocity wave,  is the number of
lattice nodes in -direction and  is the index of the node the velocity is calculated for.
This may be used to test the system: total moment is zero and the liquid tends to equilibrium, i.e. relaxes to a
uniform zero velocity.
Example:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
# set initial density
initDen = 1.
# set initial velocity
Vx = Vy = 0.
ampVz = 0.0005
initVel = Real3D( Vx, Vy, ampVz )
# create initPop object and initialize populations
initPop = espressopp.integrator.LBInitPopWave(system,lb)
initPop.createDenVel( initDen, initVel )
espressopp.integrator.LBInitConstForce
This class allows to set or add constant (gravity-like) external forces (lattice units) to the LB-fluid. At first, one
has to create a force object and then set or add this force to the system.
Example to set extenal force:
3.6. integrator
59
ESPResSo++ Documentation, Release latest
>>> extForceToSet = Real3D(0., 0., 0.0005)
>>> lbforce = espressopp.integrator.LBInitConstForce(system,lb)
>>> lbforce.setForce( extForceToSet )
Example to add extenal force to the existing forces:
>>> extForceToAdd = Real3D(0.0001, 0., 0.)
>>> lbforce = espressopp.integrator.LBInitConstForce(system,lb)
>>> lbforce.addForce( extForceToAdd )
espressopp.integrator.LBInitPeriodicForce
This class allows to set or add external periodic forces (lattice units) to the LB-fluid. At first, one has to create a
force object and then set or add this force to the system.
Note: Please note, that a periodic (sin-like) force acts in z-direction as a function of x. The z-component of
the force provides therefore the amplitude of the sin-modulation. The x- and y-components of the specified force
interpreted as body forces in corresponding directions.
Example to set external sin-like force.
>>>
>>>
>>>
>>>
>>>
ampFz = 0.0001
Fx = Fy = 0.
extForceToSet = Real3D( Fx, Fy, ampFz )
lbforceSin = espressopp.integrator.LBInitConstForce(system,lb)
lbforceSin.setForce( extForceToSet )
Example to add external sin-like force.
>>>
>>>
>>>
>>>
>>>
ampFz = 0.0005
Fx = Fy = 0.
extForceToAdd = Real3D( Fx, Fy, ampFz )
lbforceSin = espressopp.integrator.LBInitConstForce(system,lb)
lbforceSin.addForce( extForceToAdd )
espressopp.integrator.MDIntegrator
espressopp.integrator.MDIntegrator.addExtension(extension)
Parameters extension –
Return type
espressopp.integrator.MDIntegrator.getExtension(k)
Parameters k –
Return type
espressopp.integrator.MDIntegrator.getNumberOfExtensions()
Return type
espressopp.integrator.MDIntegrator.run(niter)
Parameters niter –
Return type
60
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.integrator.MinimizeEnergy
This is a very simple approach to perform energy minimization of the system. The module uses a steepest descent
method. The position of particles is updated following the equation:
+1 =  + ( ,  )
where + is a new position,  is a position at current step with corresponding force  . The parameters  and
 are set by user and control the relaxation of the energy and the maximum update of the coordinates per step.
Additionaly, a variable  step is also implemented. In this case, the position of particles is updated following the
equation:
+1 =  +  / 
where  is a maximum force in a single step of steepest descent method.  =  / is automatically
adjusted to a force magnitude.
In both cases, the routine runs until the maximum force is bigger than  or for at most n steps.
Please note This module does not support any integrator extensions.
Example
>>> em = espressopp.integrator.MinimizeEnergy(system, gamma=0.001, ftol=0.01, max_displacement=0.0
>>> em.run(10000)
Example
>>> em = espressopp.integrator.MinimizeEnergy(system, gamma=0.01, ftol=0.01, max_displacement=0.01
>>> em.run(10000)
API
espressopp.integrator.MinimizeEnergy(system, gamma, ftol, max_displacement, variable_step_flag)
Parameters
• system (espressopp.System) – The espressopp system object.
• gamma (float) – The gamma value.
• ftol (float) – The force tolerance
• max_displacement (float) – The maximum displacement.
• variable_step_flag (bool) – The flag of adjusting gamma to the force strength.
espressopp.integrator.MinimizeEnergy.run(max_steps, verbose)
Parameters
• max_steps (int) – The maximum number of steps to run.
• verbose (bool) – If set to True then display information about maximum force during the iterations.
Returns The true if the maximum force in the system is lower than ftol otherwise false.
Return type bool
espressopp.integrator.MinimizeEnergy.f_max
The maximum force in the system.
espressopp.integrator.MinimizeEnergy.displacement
The maximum displacement used during the run of MinimizeEnergy
espressopp.integrator.MinimizeEnergy.step
The current iteration step.
3.6. integrator
61
ESPResSo++ Documentation, Release latest
espressopp.integrator.OnTheFlyFEC
espressopp.integrator.OnTheFlyFEC(system, center)
Parameters
• system –
• center – (default: [])
espressopp.integrator.OnTheFlyFEC.getBins()
Return type
espressopp.integrator.OnTheFlyFEC.getGap()
Return type
espressopp.integrator.OnTheFlyFEC.getSteps()
Return type
espressopp.integrator.OnTheFlyFEC.makeArrays()
Return type
espressopp.integrator.OnTheFlyFEC.resetCounter()
Return type
espressopp.integrator.OnTheFlyFEC.writeFEC()
Return type
espressopp.integrator.Rattle
RATTLE algorithm for satisfying bond constraints and making the corresponding velocity corrections.
Refs:
Andersen, H. C. Rattle: A velocity version of the Shake algorithm for molecular dynamics calculations, J. Comp.
Physics, 52, 24-34 (1983)
Allen & Tildesley, Computer Simulation of Liquids, OUP, 1987
RATTLE is implemented as an integrator extension, and takes as input a list of lists detailing, for each bond to be
constrained: the indices of the two particles involved, the constraint distance, and the particle masses.
This implementation is intended for use with hydrogen-heavy atom bonds, which form isolated groups of constrained bonds, e.g NH2 or CH3 groups. The particle which participates in only one constrained bond (i.e. the
hydrogen) should be listed first. The particle listed second (the heavy atom) may participate in more than one
constrained bond. This implementation will not work if both particles participate in more than one constrained
bond.
Note: At the moment, the RATTLE implementation only works if all atoms in an isolated group of rigid bonds
are on the same CPU. This can be achieved by grouping all the particles using DomainDecompositionAdress and
FixedTupleListAdress. The groups of rigid bonds can be identified using the dictionary constrainedBondsDict
(see example below).
Note: The constraints are not taken into account in other parts of the code, such as temperature or pressure
calculation.
Python example script for one methanol molecule where atoms are indexed in the order C H1 H2 H3 OH HO:
>>>
>>>
>>>
>>>
>>>
62
# list for each constrained bond which lists: heavy atom index, light atom index, bond length,
constrainedBondsList = [[1, 2, 0.109, 12.011, 1.008], [1, 3, 0.109, 12.011, 1.008], [1, 4, 0.1
rattle = espressopp.integrator.Rattle(system, maxit = 1000, tol = 1e-6, rptol = 1e-6)
rattle.addConstrainedBonds(constrainedBondsList)
integrator.addExtension(rattle)
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
This list of lists of constrained bonds can be conveniently built using the espressopppp tool findConstrainedBonds.
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
# Automatically identify hydrogen-containing bonds among the particles whose indices are in th
# pidlist - list of indices of particles in which to search for hydrogens (list of int)
# masses - list of masses of all particles (list of real)
# massCutoff - atoms with mass < massCutoff are identified as hydrogens (real)
# bondtypes - dictionary (e.g. obtained using espressopppp.gromacs.read()), key: bondtype (int
# bondtypeparams - dictionary (e.g. obtained using espressopppp.gromacs.read()), key: bondtype
hydrogenIDs, constrainedBondsDict, constrainedBondsList = espressopp.tools.findConstrainedBond
# hydrogenIDs - list of indices of hydrogen atoms
# constrainedBondsDict - dictionary mapping from a heavy atom to all the light atoms it is bon
# constrainedBondsList - list of lists, constrained bonds for use with Rattle.addConstrainedBo
print "# found", len(hydrogenIDs)," hydrogens in the solute"
print "# found", len(constrainedBondsDict)," heavy atoms involved in bonds to hydrogen"
print "# will constrain", len(constrainedBondsList)," bonds using RATTLE"
espressopppp.integrator.Rattle(system, maxit = 1000, tol = 1e-6, rptol = 1e-6)
Parameters
• system (espressopp.System) – espressopp system
• maxit (int) – maximum number of iterations
• tol (real) – tolerance for deciding if constraint distance and current distance are
similar enough
• rptol (real) – tolerance for deciding if the angle between the bond vector at end of
previous timestep and current vector has become too large
espressopppp.integrator.Rattle.addConstrainedBonds(bondDetailsLists)
Parameters bondDetailsLists (list of [int, int, real, real, real]) –
list of lists, each list contains pid of heavy atom, pid of light atom, constraint distance, mass
of heavy atom, mass of light atom
espressopp.integrator.Settle
espressopp.integrator.Settle(system, fixedtuplelist, mO, mH, distHH, distOH)
Parameters
• system –
• fixedtuplelist –
• mO (real) – (default: 16.0)
• mH (real) – (default: 1.0)
• distHH (real) – (default: 1.58)
• distOH (real) – (default: 1.0)
espressopp.integrator.Settle.addMolecules(moleculelist)
Parameters moleculelist –
Return type
espressopp.integrator.StochasticVelocityRescaling
espressopp.integrator.StochasticVelocityRescaling(system)
Parameters system –
3.6. integrator
63
ESPResSo++ Documentation, Release latest
espressopp.integrator.TDforce
Thermodynamic force.
Example - how to turn on thermodynamic force (except for multiple moving spherical regions)
>>>
>>>
>>>
>>>
fthd="tabletf.xvg"
thdforce = espressopp.integrator.TDforce(system,verletlist) #info about centre and shape of ad
thdforce.addForce(itype=3,filename="tabletf.xvg",type=typeCG)
integrator.addExtension(thdforce)
Example - how to turn on thermodynamic force for multiple moving spherical regions
>>>
>>>
>>>
>>>
fthd="tabletf.xvg"
thdforce = espressopp.integrator.TDforce(system, verletlist, startdist = 0.9, enddist = 2.1, e
thdforce.addForce(itype=3,filename="tabletf.xvg",type=typeCG)
integrator.addExtension(thdforce)
espressopp.integrator.TDforce(system, verletlist, startdist, enddist, edgeweightmultiplier)
Parameters
• system (shared_ptr<System>) – system object
• verletlist (shared_ptr<VerletListAdress>) – verletlist object
• startdist (real) – (default: 0.0) starting distance from center at which the TD
force is actually applied. Needs to be altered when using several moving spherical
regions (not used for static or single moving region)
• enddist (real) – (default: 0.0) end distance from center up to which the TD force is
actually applied. Needs to be altered when using several moving spherical regions (not
used for static or single moving region)
• edgeweightmultiplier (int) – (default:
20) interpolation parameter for multiple overlapping spherical regions (see Kreis et al., JCTC doi:
10.1021/acs.jctc.6b00440), the default should be fine for most applications (not
used for static or single moving region)
espressopp.integrator.TDforce.addForce(itype, filename, type)
Parameters
• itype (int) – interpolation type 1: linear, 2: Akima, 3: Cubic
• filename (string) – filename for TD force file
• type (int) – particle type on which the TD force needs to be applied
espressopp.integrator.VelocityVerlet
espressopp.integrator.VelocityVerlet(system)
Parameters system –
espressopp.integrator.VelocityVerletOnGroup
espressopp.integrator.VelocityVerletOnGroup(system, group)
Parameters
• system –
• group –
64
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.integrator.VelocityVerletOnRadius
espressopp.integrator.VelocityVerletOnRadius(system, dampingmass)
Parameters
• system –
• dampingmass –
interaction
espressopp.interaction.AngularCosineSquared
Calculates the Angular Cosine Squared interaction
 = (() − (0 ))2
espressopp.interaction.AngularCosineSquared(K, theta0)
Parameters
• K (real) – (default: 1.0)
• theta0 (real) – (default: 0.0)
espressopp.interaction.FixedTripleListAngularCosineSquared(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedTripleListAngularCosineSquared.getFixedTripleList()
Return type A Python list of lists.
espressopp.interaction.FixedTripleListAngularCosineSquared.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
class espressopp.interaction.AngularCosineSquared.AngularCosineSquared
The AngularCosineSquared potential.
espressopp.interaction.AngularHarmonic
Calculates the Angular Harmonic interaction
 = ( − 0 )2
3.7. interaction
65
ESPResSo++ Documentation, Release latest
espressopp.interaction.AngularHarmonic(K, theta0)
Parameters
• K (real) – (default: 1.0)
• theta0 (real) – (default: 0.0)
espressopp.interaction.FixedTripleListAngularHarmonic(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedTripleListAngularHarmonic.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
class espressopp.interaction.AngularHarmonic.AngularHarmonic
The AngularHarmonic potential.
espressopp.interaction.AngularPotential
This is an abstract class, only needed to be inherited from.
espressopp.interaction.AngularPotential.computeEnergy(*args)
Parameters *args –
Return type
espressopp.interaction.AngularPotential.computeForce(*args)
Parameters *args –
Return type
espressopp.interaction.AngularUniqueCosineSquared
Calculates the angular unique cosine squared interaction.
 = (() − (0 ))2
espressopp.interaction.AngularUniqueCosineSquared(K)
Parameters K (real) – (default: 1.0)
espressopp.interaction.FixedTripleAngleListAngularUniqueCosineSquared(system,
ftcl,
potential)
Parameters
66
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• system –
• ftcl –
• potential –
espressopp.interaction.FixedTripleAngleListAngularUniqueCosineSquared.getFixedTripleList
Return type A Python list of lists.
espressopp.interaction.FixedTripleAngleListAngularUniqueCosineSquared.setPotential(potenti
Parameters potential –
class espressopp.interaction.AngularUniqueCosineSquared.AngularUniqueCosineSquared
The AngularUniqueCosineSquared potential.
espressopp.interaction.AngularUniqueHarmonic
Calculates the Angular Unique Harmonic interaction
 = ( − 0 )2
espressopp.interaction.AngularUniqueHarmonic(K)
Parameters K (real) – (default: 1.0)
espressopp.interaction.FixedTripleAngleListAngularUniqueHarmonic(system,
ftal, potential)
Parameters
• system –
• ftal –
• potential –
espressopp.interaction.FixedTripleAngleListAngularUniqueHarmonic.setPotential(potential)
Parameters potential –
espressopp.interaction.AngularUniquePotential
This is an abstract class, only needed to be inherited from.
espressopp.interaction.AngularUniquePotential.computeEnergy(*args)
Parameters *args –
Return type
espressopp.interaction.AngularUniquePotential.computeForce(*args)
Parameters *args –
Return type
espressopp.interaction.Cosine
Calculates the Cosine Interaction
 = (1 + ( − 0 ))
3.7. interaction
67
ESPResSo++ Documentation, Release latest
espressopp.interaction.Cosine(K, theta0)
Parameters
• K (real) – (default: 1.0)
• theta0 (real) – (default: 0.0)
espressopp.interaction.FixedTripleListCosine(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedTripleListCosine.getFixedTripleList()
Return type A Python list of lists.
espressopp.interaction.FixedTripleListCosine.setPotential(potential)
Parameters potential –
class espressopp.interaction.Cosine.Cosine
The Cosine potential.
espressopp.interaction.CoulombKSpaceEwald
Coulomb potential and interaction Objects (K space part)
1
2
∑︁
∈Z3
0<||<
⃒
⃒2

⃒
2
′2 ⃒∑︁
(− 
2 ) ⃒
′ ⃒

·
(2
·

)
⃒
⃒


⃒
⃒
′2
=1
This is the K space part of potential of Coulomb long range interaction according to the Ewald summation technique. Good explanation of Ewald summation could be found here [Allen89], [Deserno98].
Example:
>>> ewaldK_pot = espressopp.interaction.CoulombKSpaceEwald(system, coulomb_prefactor, alpha, kspac
>>> ewaldK_int = espressopp.interaction.CellListCoulombKSpaceEwald(system.storage, ewaldK_pot)
>>> system.addInteraction(ewaldK_int)
!IMPORTANT Coulomb interaction needs R space part as well CoulombRSpace.
Definition:
It provides potential object CoulombKSpaceEwald and interaction object CellListCoulombKSpaceEwald based on all particles list.
The potential is based on the system information (System) and parameters: Coulomb prefactor
(coulomb_prefactor), Ewald parameter (alpha), and the cutoff in K space (kspacecutoff).
>>> ewaldK_pot = espressopp.interaction.CoulombKSpaceEwald(system, coulomb_prefactor, alpha,
Potential Properties:
• ewaldK_pot.prefactor
The property ‘prefactor’ defines the Coulomb prefactor.
• ewaldK_pot.alpha
The property ‘alpha’ defines the Ewald parameter
ℎ.
68
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• ewaldK_pot.kmax
The property ‘kmax’ defines the cutoff in K space.
The interaction is based on the all particles list. It needs the information from Storage and K space
part of potential.
>>> ewaldK_int = espressopp.interaction.CellListCoulombKSpaceEwald(system.storage, ewaldK_pot
Interaction Methods:
• getPotential()
Access to the local potential.
Adding the interaction to the system:
>>> system.addInteraction(ewaldK_int)
References:
espressopp.interaction.CoulombKSpaceEwald(system, prefactor, alpha, kmax)
Parameters
• system –
• prefactor –
• alpha –
• kmax –
espressopp.interaction.CellListCoulombKSpaceEwald(storage, potential)
Parameters
• storage –
• potential –
espressopp.interaction.CellListCoulombKSpaceEwald.getFixedPairList()
Return type A Python list of lists.
espressopp.interaction.CellListCoulombKSpaceEwald.getPotential()
Return type
espressopp.interaction.CoulombKSpaceP3M
Coulomb potential and interaction Objects (K space part)
This is the K space part of potential of Coulomb long range interaction according to the P3M summation technique.
Good explanation of P3M summation could be found here [Allen89], [Deserno98].
Example:
>>> ewaldK_pot = espressopp.interaction.CoulombKSpaceP3M(system, coulomb_prefactor, alpha, kspacec
>>> ewaldK_int = espressopp.interaction.CellListCoulombKSpaceP3M(system.storage, ewaldK_pot)
>>> system.addInteraction(ewaldK_int)
!IMPORTANT Coulomb interaction needs R space part as well CoulombRSpace.
Definition:
It provides potential object CoulombKSpaceP3M and interaction object CellListCoulombKSpaceP3M
based on all particles list.
The potential is based on the system information (System) and parameters: Coulomb prefactor
(coulomb_prefactor), P3M parameter (alpha), and the cutoff in K space (kspacecutoff).
3.7. interaction
69
ESPResSo++ Documentation, Release latest
>>> ewaldK_pot = espressopp.interaction.CoulombKSpaceP3M(system, coulomb_prefactor, alpha, ks
Potential Properties:
• ewaldK_pot.prefactor
The property ‘prefactor’ defines the Coulomb prefactor.
• ewaldK_pot.alpha
The property ‘alpha’ defines the P3M parameter
ℎ.
• ewaldK_pot.kmax
The property ‘kmax’ defines the cutoff in K space.
The interaction is based on the all particles list. It needs the information from Storage and K space
part of potential.
>>> ewaldK_int = espressopp.interaction.CellListCoulombKSpaceP3M(system.storage, ewaldK_pot)
Interaction Methods:
• getPotential()
Access to the local potential.
Adding the interaction to the system:
>>> system.addInteraction(ewaldK_int)
espressopp.interaction.CoulombKSpaceP3M(system, C_pref, alpha, M, P, rcut, interpolation)
Parameters
• system –
• C_pref –
• alpha –
• M–
• P–
• rcut –
• interpolation (int) – (default: 200192)
espressopp.interaction.CellListCoulombKSpaceP3M(storage, potential)
Parameters
• storage –
• potential –
espressopp.interaction.CellListCoulombKSpaceP3M.getPotential()
Return type
espressopp.interaction.CoulombRSpace
Coulomb potential and interaction Objects (R space part)

∑︁
=1
70
∑︁
>
 <

 
 ∑︁ 2
 ( ) − √


 =1 
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
This is the R space part of potential of Coulomb long range interaction according to the Ewald summation technique. Good explanation of Ewald summation could be found here [Allen89], [Deserno98].
Example:
>>>
>>>
>>>
>>>
>>>
vl = espressopp.VerletList(system, rspacecutoff+skin)
coulombR_pot = espressopp.interaction.CoulombRSpace(coulomb_prefactor, alpha, rspacecutoff)
coulombR_int = espressopp.interaction.VerletListCoulombRSpace(vl)
coulombR_int.setPotential(type1=0, type2=0, potential = coulombR_pot)
system.addInteraction(coulombR_int)
!IMPORTANT Coulomb interaction needs k-space part as well EwaldKSpace.
Definition:
It provides potential object CoulombRSpace and interaction object VerletListCoulombRSpace
The potential is based on parameters: Coulomb prefactor (coulomb_prefactor), Ewald parameter
(alpha), and the cutoff in R space (rspacecutoff).
>>> coulombR_pot = espressopp.interaction.CoulombRSpace(coulomb_prefactor, alpha, rspacecutof
Potential Properties:
• coulombR_pot.prefactor
The property ‘prefactor’ defines the Coulomb prefactor.
• coulombR_pot.alpha
The property ‘alpha’ defines the Ewald parameter
ℎ.
• coulombR_pot.cutoff
The property ‘cutoff’ defines the cutoff in R space.
The interaction is based on the Verlet list (VerletList)
>>> vl = espressopp.VerletList(system, rspacecutoff+skin)
>>> coulombR_int = espressopp.interaction.VerletListCoulombRSpace(vl)
It should include at least one potential
>>> coulombR_int.setPotential(type1=0, type2=0, potential = coulombR_pot)
Interaction Methods:
• setPotential(type1, type2, potential)
This method sets the potential for the particles of type1 and type2. It could be a bunch of
potentials for the different particle types.
• getVerletListLocal()
Access to the local Verlet list.
Adding the interaction to the system:
>>> system.addInteraction(coulombR_int)
espressopp.interaction.CoulombRSpace(prefactor, alpha, cutoff )
Parameters
• prefactor (real) – (default: 1.0)
• alpha (real) – (default: 1.0)
• cutoff – (default: infinity)
espressopp.interaction.VerletListCoulombRSpace(vl)
3.7. interaction
71
ESPResSo++ Documentation, Release latest
Parameters vl –
espressopp.interaction.VerletListCoulombRSpace.getPotential(type1, type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListCoulombRSpace.getVerletList()
Return type A Python list of lists.
espressopp.interaction.VerletListCoulombRSpace.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.CoulombTruncated
 =
 

where  is the user-supplied prefactor,  is the charge of particle i, and  is interparticle distance
In this interaction potential, a different charge can be associated with each particle. For a truncated Coulomb interaction potential where only one   value is specified for all interactions, see CoulombTruncatedUniqueCharge.
espressopppp.interaction.CoulombTruncated(prefactor, cutoff )
Parameters
• prefactor (real) – (default: 1.0) user-supplied prefactor k
• cutoff (real) – (default: infinity) user-supplied interaction cutoff
espressopppp.interaction.VerletListCoulombTruncated(vl)
Parameters vl (espressopp.VerletList) – verlet list object defined earlier in python
script
espressopppp.interaction.VerletListCoulombTruncated.getPotential(type1,
type2)
Parameters
• type1 (integer) – type of first atom in pair
• type2 (integer) – type of second atom in pair
espressopppp.interaction.VerletListCoulombTruncated.setPotential(type1,
type2,
potential)
Parameters
• type1 (integer) – type of first atom in pair
• type2 (integer) – type of second atom in pair
72
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• potential (CoulombTruncated potential) – potential object defined earlier
in python script
espressopppp.interaction.FixedPairListTypesCoulombTruncated(system, vl)
Parameters
• system (espressopp.System) – system object defined earlier in the python script
• vl (espressopp.FixedPairList) – fixedpairlist object defined earlier in the
python script
espressopppp.interaction.FixedPairListTypesCoulombTruncated.setPotential(potential)
Parameters
• type1 (integer) – type of first atom in pair
• type2 (integer) – type of second atom in pair
• potential (CoulombTruncated potential) – potential object defined earlier
in python script
#Example:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
pref = 138.935485
rc = 1.2
fixedpairlist = espresso.FixedPairList(system.storage)
fixedpairlist.addBonds([(1,2),(2,3)])
pot = espressopp.interaction.CoulombTruncated(prefactor=pref, cutoff=rc)
interaction=espressopp.interaction.FixedPairListTypesCoulombTruncated(system,fixedpairlist)
interaction.setPotential(type1=0, type2=1, potential=pot)
system.addInteraction(interaction)
class espressopp.interaction.CoulombTruncated.CoulombTruncated
The CoulombTruncated potential.
espressopp.interaction.CoulombTruncatedUniqueCharge
=


where  is the product of the charges of the two particles and  is their distance from each other.
In this interaction potential, a unique  =   value is specified per potential. For a more flexible truncated
Coulomb interaction potential where each individual particle has its own charge  , see CoulombTruncated.
espressopp.interaction.CoulombTruncatedUniqueCharge(qq, cutoff, shift)
Parameters
• qq (real) – (default: 1.0)
• cutoff – (default: infinity)
• shift – (default: “auto”)
espressopp.interaction.VerletListCoulombTruncatedUniqueCharge(vl)
Parameters vl –
espressopp.interaction.VerletListCoulombTruncatedUniqueCharge.getPotential(type1,
type2)
Parameters
• type1 –
• type2 –
3.7. interaction
73
ESPResSo++ Documentation, Release latest
Return type
espressopp.interaction.VerletListCoulombTruncatedUniqueCharge.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.CellListCoulombTruncatedUniqueCharge(stor)
Parameters stor –
espressopp.interaction.CellListCoulombTruncatedUniqueCharge.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.FixedPairListCoulombTruncatedUniqueCharge(system,
vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListCoulombTruncatedUniqueCharge.setPotential(potential)
Parameters potential –
class espressopp.interaction.CoulombTruncatedUniqueCharge.CoulombTruncatedUniqueCharge
The CoulombTruncatedUniqueCharge potential.
espressopp.interaction.ConstrainCOM
This class is for calculating forces of constraining center of mass of subchains. Subchains are defined as a tuple
list.
(︁
)︁2
⃗  ,
 =  ⃗ − 
⃗  stands for the desired center of mass of subchain.
where ⃗ stands for the center of mass of subchain and 
This class set 2 conditions on a tuple list defining subchains.
1. The length of all tuple must be same.
2. int(key particle id / The length of a tuple) must not be redundantly, where key particle id is the smallest
particle id in a tuple.
74
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
Reference: Equilibration of high molecular weight polymer melts: A hierarchical strategy, Macro Lett., 2014, 3,
198
espressopp.interaction.ConstrainCOM(k_com)
Parameters k_com (real) – (default: 100.)
espressopp.interaction.FixedLocalTupleListConstrainCOM(system, tuplelist, potential)
Parameters
• system –
• tuplelist –
• potential –
espressopp.interaction.FixedLocalTupleListConstrainCOM.getPotential()
Return type
espressopp.interaction.FixedLocalTupleListConstrainCOM.setCom(particlelist)
Parameters particlelist –
espressopp.interaction.ConstrainRG
This class is for calculating forces of constraining radii of gyration of subchains. Subchains are defined as a tuple
list.
(︁
)︁
2 2
 =  2 − 
where  stands for the desired radius of gyration of subchain.
This class set 2 conditions on a tuple list. defining subchains.
1. The length of all tuple must be same.
2. int(key particle id / The length of a tuple) must not be redundantly, where key particle id is the smallest
particle id in a tuple.
Reference: Equilibration of high molecular weight polymer melts: A hierarchical strategy, Macro Lett., 2014, 3,
198
espressopp.interaction.ConstrainRG(k_rg)
Parameters k_rg (real) – (default: 100.)
espressopp.interaction.FixedLocalTupleListConstrainRG(system, tuplelist, potential)
Parameters
• system –
• tuplelist –
• potential –
espressopp.interaction.FixedLocalTupleListConstrainRG.getPotential()
Return type
espressopp.interaction.FixedLocalTupleListConstrainRG.setRG(particlelist)
Parameters particlelist (python::list) –
3.7. interaction
75
ESPResSo++ Documentation, Release latest
espressopp.interaction.DihedralHarmonic
The dihedral harmonic potential
 ( ) = 0.5[ − 0 )]2
where the K is a constant, the angles should be provided in radians.
Reference: Gromacs Manual 4.6.1, section 4.2.11 (page 79-80), equation 4.60
espressopp.interaction.DihedralHarmonic(K, phi0)
Parameters
• K (real) – (default: 0.0)
• phi0 (real) – (default: 0.0)
espressopp.interaction.FixedQuadrupleListDihedralHarmonic(system, fql, potential)
Parameters
• system –
• fql –
• potential –
espressopp.interaction.FixedQuadrupleListDihedralHarmonic.getFixedQuadrupleList()
Return type A Python list of lists.
espressopp.interaction.FixedQuadrupleListDihedralHarmonic.setPotential(potential)
Parameters potential –
Example of usage
>>>
>>>
>>>
>>>
>>>
>>>
# The following example shows how to add a torsional potential to particles 1,2,3,4
fql = espressopp.FixedQuadrupleList(system.storage)
fql.addQuadruples([(1,2,3,4)])
#phi0 is in radians, IUPAC convention definition
interaction = espressopp.interaction.FixedQuadrupleListDihedralHarmonic(system,fql,potential=e
system.addInteraction(interaction)
class espressopp.interaction.DihedralHarmonic.DihedralHarmonic
The DihedralHarmonic potential.
class espressopp.interaction.DihedralHarmonic.FixedQuadrupleListDihedralHarmonicLocal(system
fql,
potential)
The (local) DihedralHarmonic interaction using FixedQuadruple lists.
espressopp.interaction.DihedralHarmonicCos
 = (() − (0 ))2
espressopp.interaction.DihedralHarmonicCos(K, phi0)
Parameters
• K (real) – (default: 0.0)
• phi0 (real) – (default: 0.0)
76
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.interaction.FixedQuadrupleListDihedralHarmonicCos(system, fql, potential)
Parameters
• system –
• fql –
• potential –
espressopp.interaction.FixedQuadrupleListDihedralHarmonicCos.getFixedQuadrupleList()
Return type A Python list of lists.
espressopp.interaction.FixedQuadrupleListDihedralHarmonicCos.setPotential(potential)
Parameters potential –
class espressopp.interaction.DihedralHarmonicCos.DihedralHarmonicCos
The DihedralHarmonicCos potential.
espressopp.interaction.DihedralHarmonicNCos
The dihedral harmonic potential
 ( ) = [1 + ( ·  − 0 )]
where the K is a constant, the angles should be provided in radians. The N is a multiplicity.
Reference: http://www.uark.edu/ua/fengwang/DLPOLY2/node49.html
espressopp.interaction.DihedralHarmonicNCos(K, phi0, multiplicity)
Parameters
• K (real) – (default: 0.0)
• phi0 (real) – (default: 0.0)
• multiplicity (int) – (default: 1)
espressopp.interaction.FixedQuadrupleListDihedralHarmonicNCos(system, fql,
potential)
Parameters
• system –
• fql –
• potential –
espressopp.interaction.FixedQuadrupleListDihedralHarmonicNCos.getFixedQuadrupleList()
Return type A Python list of lists.
espressopp.interaction.FixedQuadrupleListDihedralHarmonicNCos.setPotential(potential)
Parameters potential –
class espressopp.interaction.DihedralHarmonicNCos.DihedralHarmonicNCos
The DihedralHarmonicNCos potential.
class espressopp.interaction.DihedralHarmonicNCos.FixedQuadrupleListDihedralHarmonicNCosLo
The (local) DihedralHarmonicNCos interaction using FixedQuadruple lists.
3.7. interaction
77
ESPResSo++ Documentation, Release latest
espressopp.interaction.DihedralHarmonicUniqueCos
 = (() − (0 ))2
espressopp.interaction.DihedralHarmonicUniqueCos(K)
Parameters K (real) – (default: 0.0)
espressopp.interaction.FixedQuadrupleAngleListDihedralHarmonicUniqueCos(system,
fqal,
potential)
Parameters
• system –
• fqal –
• potential –
espressopp.interaction.FixedQuadrupleAngleListDihedralHarmonicUniqueCos.getFixedQuadrupl
Return type A Python list of lists.
espressopp.interaction.FixedQuadrupleAngleListDihedralHarmonicUniqueCos.setPotential(pote
Parameters potential –
class espressopp.interaction.DihedralHarmonicUniqueCos.DihedralHarmonicUniqueCos
The DihedralHarmonicUniqueCos potential.
espressopp.interaction.DihedralPotential
This is an abstract class, only needed to be inherited from.
espressopp.interaction.DihedralPotential.computeEnergy(*args)
Parameters *args –
Return type
espressopp.interaction.DihedralPotential.computeForce(*args)
Parameters *args –
Return type
espressopp.interaction.DihedralRB
The proper dihedral with Ryckaert-Bellemans form.
 ( ) =
5
∑︁
 (())
=0
where the  =  − 180∘ and 0...5 are the coefficients.
By default the IUPAC convention is used, where  is the angle between planes  and . The 0∘ corresponds
to the cis configuration.
Reference: http://www.gromacs.org/Documentation/Manual
espressopp.interaction.DihedralRB(K0, K1, K2, K3, K4, K5, iupac)
78
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
Parameters
• K0 (real) – (default: 0.0)
• K1 (real) – (default: 0.0)
• K2 (real) – (default: 0.0)
• K3 (real) – (default: 0.0)
• K4 (real) – (default: 0.0)
• K5 (real) – (default: 0.0)
• iupac – (default: True)
espressopp.interaction.FixedQuadrupleListDihedralRB(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedQuadrupleListDihedralRB.getFixedQuadrupleList()
Return type A Python list of lists.
espressopp.interaction.FixedQuadrupleListDihedralRB.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.DihedralUniquePotential
This is an abstract class, only needed to be inherited from.
espressopp.interaction.DihedralUniquePotential.computeEnergy(*args)
Parameters *args –
Return type
espressopp.interaction.DihedralUniquePotential.computeForce(*args)
Parameters *args –
Return type
espressopp.interaction.FENE
Implementation of the Finitely Extensible Non-linear Elastic potential:
[︃
)︂2 ]︃
(︂
 − 0
1 2
 () = − max  log 1 −
2
max
espressopp.interaction.FENE(K, r0, rMax, cutoff, shift)
Parameters
3.7. interaction
79
ESPResSo++ Documentation, Release latest
• K (real) – (default: 1.0)
• r0 (real) – (default: 0.0)
• rMax (real) – (default: 1.0)
• cutoff (real) – (default: infinity)
• shift (real) – (default: 0.0)
espressopp.interaction.FixedPairListFENE(system, pair_list, potential)
Parameters
• system (object) – your system espressopp.System()
• pair_list (object) – list of bonds espressopp.FixedPairList()
• potential (object) – espressopp.interaction.FENE()
espressopp.interaction.FixedPairListFENE.getFixedPairList()
Return type A Python list of lists.
espressopp.interaction.FixedPairListFENE.getPotential()
Return type object
espressopp.interaction.FixedPairListFENE.setFixedPairList(pair_list)
Parameters pair_list (fixedpairlist) –
espressopp.interaction.FixedPairListFENE.setPotential(potential)
Parameters potential –
Example of usage
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
# The following example shows how to bond particle 1 to particles 0 and 2 by a FENE potential.
# We assume the particles are already in the storage of the system
# Initialize list of pairs that will be bonded by FENE
pair_list = espressopp.FixedPairList(system.storage)
# Set which pairs belong to the pair_list i.e. particle 0 is bonded to particles 1 and 2.
pair_list.addBonds([(0,1),(1,2)])
# Initialize the potential and set up the parameters.
potFENE
= espressopp.interaction.FENE(K=30.0, r0=0.0, rMax=1.5)
# Set which system, pair list and potential is the interaction associated with.
interFENE = espressopp.interaction.FixedPairListFENE(system, pair_list, potFENE)
# Add the interaction to the system.
system.addInteraction(interFENE)
espressopp.interaction.FENECapped
(︂
)︂
 − 0 2
1 2
 = −   ·  1 −
2

where  =  if
 2 > 
and  =  else.
espressopp.interaction.FENECapped(K, r0, rMax, cutoff, caprad, shift)
Parameters
• K (real) – (default: 1.0)
• r0 (real) – (default: 0.0)
80
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• rMax (real) – (default: 1.0)
• cutoff – (default: infinity)
• caprad (real) – (default: 1.0)
• shift (real) – (default: 0.0)
espressopp.interaction.FixedPairListFENECapped(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListFENECapped.getFixedPairList()
Return type A Python list of lists.
espressopp.interaction.FixedPairListFENECapped.getPotential()
Return type
espressopp.interaction.FixedPairListFENECapped.setFixedPairList(fixedpairlist)
Parameters fixedpairlist –
espressopp.interaction.FixedPairListFENECapped.setPotential(potential)
Parameters potential –
class espressopp.interaction.FENECapped.FENECapped
The FENECapped potential.
espressopp.interaction.GravityTruncated
This is an implementation of a truncated (cutoff) Gravity Potential
 = ·
1 · 2
|1 − 2 |
where  is the mass of the i th particle,  its position and P a prefactor.
espressopp.interaction.GravityTruncated(prefactor, cutoff )
Parameters
• prefactor (real) – (default: 1.0)
• cutoff – (default: infinity)
espressopp.interaction.VerletListGravityTruncated(vl)
Parameters vl –
espressopp.interaction.VerletListGravityTruncated.getPotential(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListGravityTruncated.getVerletList()
Return type A Python list of lists.
3.7. interaction
81
ESPResSo++ Documentation, Release latest
espressopp.interaction.VerletListGravityTruncated.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.Harmonic
 = ( − 0 )2
espressopp.interaction.Harmonic(K, r0, cutoff, shift)
Parameters
• K (real) – (default: 1.0)
• r0 (real) – (default: 0.0)
• cutoff – (default: infinity)
• shift (real) – (default: 0.0)
espressopp.interaction.FixedPairListHarmonic(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListHarmonic.getFixedPairList()
Return type A Python list of lists.
espressopp.interaction.FixedPairListHarmonic.setFixedPairList(fixedpairlist)
Parameters fixedpairlist –
espressopp.interaction.FixedPairListHarmonic.setPotential(potential)
Parameters potential –
espressopp.interaction.FixedPairListTypesHarmonic(system, vl)
Parameters
• system –
• vl –
espressopp.interaction.FixedPairListTypesHarmonic.getFixedPairList()
Return type A Python list of lists.
espressopp.interaction.FixedPairListTypesHarmonic.setFixedPairList(fixedpairlist)
Parameters fixedpairlist –
espressopp.interaction.FixedPairListTypesHarmonic.setPotential(type1,
type2,
potential)
82
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.FixedPairListTypesHarmonic.getPotential(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
class espressopp.interaction.Harmonic.Harmonic
The Harmonic potential.
espressopp.interaction.HarmonicTrap
1
 =  2
2
espressopp.interaction.HarmonicTrap()
espressopp.interaction.SingleParticleHarmonicTrap(system, potential)
Parameters
• system –
• potential –
espressopp.interaction.SingleParticleHarmonicTrap.setPotential(potential)
Parameters potential –
class espressopp.interaction.HarmonicTrap.HarmonicTrap
The HarmonicTrap potential.
espressopp.interaction.HarmonicUnique
 = ( −  )2 ;
espressopp.interaction.HarmonicUnique(K)
Parameters K (real) – (default: 1.0)
espressopp.interaction.FixedPairDistListHarmonicUnique(system, fpl, potential)
Parameters
• system –
• fpl –
• potential –
espressopp.interaction.FixedPairDistListHarmonicUnique.getFixedPairList()
Return type A Python list of lists.
3.7. interaction
83
ESPResSo++ Documentation, Release latest
espressopp.interaction.FixedPairDistListHarmonicUnique.setFixedPairList(fixedpairlist)
Parameters fixedpairlist –
espressopp.interaction.FixedPairDistListHarmonicUnique.setPotential(potential)
Parameters potential –
class espressopp.interaction.HarmonicUnique.HarmonicUnique
The HarmonicUnique potential.
espressopp.interaction.Interaction
This is an abstract class, only needed to be inherited from.
espressopp.interaction.Interaction.bondType()
Return type int
espressopp.interaction.Interaction.computeEnergy()
Return type real
espressopp.interaction.Interaction.computeEnergyAA()
Return type real
espressopp.interaction.Interaction.computeEnergyDeriv()
Return type real
espressopp.interaction.Interaction.computeEnergyCG()
Return type real
espressopp.interaction.Interaction.computeVirial()
Return type real
espressopp.interaction.LennardJones
 () = 4
[︂(︁ )︁
 12

−
(︁  )︁6 ]︂

espressopp.interaction.LennardJones(epsilon, sigma, cutoff, shift)
Parameters
• epsilon (real) – (default: 1.0)
• sigma (real) – (default: 1.0)
• cutoff – (default: infinity)
• shift – (default: “auto”)
espressopp.interaction.VerletListLennardJones(vl)
Parameters vl –
espressopp.interaction.VerletListLennardJones.getPotential(type1, type2)
Parameters
• type1 –
• type2 –
Return type
84
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.interaction.VerletListLennardJones.getVerletList()
Return type A Python list of lists.
espressopp.interaction.VerletListLennardJones.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressLennardJones(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListAdressLennardJones.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressLennardJones.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressLennardJones2(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListAdressLennardJones2.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
3.7. interaction
85
ESPResSo++ Documentation, Release latest
espressopp.interaction.VerletListAdressLennardJones2.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressLennardJones(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListHadressLennardJones.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressLennardJones.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressLennardJones2(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListHadressLennardJones2.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
86
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.interaction.VerletListHadressLennardJones2.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.CellListLennardJones(stor)
Parameters stor –
espressopp.interaction.CellListLennardJones.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.FixedPairListLennardJones(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListLennardJones.getFixedPairList()
Return type A Python list of lists.
espressopp.interaction.FixedPairListLennardJones.getPotential()
Return type
espressopp.interaction.FixedPairListLennardJones.setFixedPairList(fixedpairlist)
Parameters fixedpairlist –
espressopp.interaction.FixedPairListLennardJones.setPotential(potential)
Parameters potential –
class espressopp.interaction.LennardJones.LennardJones
The Lennard-Jones potential.
espressopp.interaction.LennardJones93Wall
This class defines a Lennard-Jones 9-3 SingleParticlePotential in the direction x.
)︂
(︂(︁ )︁
 9 (︁  )︁3
−
 () = 


where  is the distance from the lower or upper wall in the x direction.  () = 0 after a distance sigmaCutoff.
The parameters have to be defined for every species present in the system with setParams and can be retrieved
with getParams.
Example:
3.7. interaction
87
ESPResSo++ Documentation, Release latest
>>>
>>>
>>>
>>>
LJ93 = espressopp.interaction.LennardJones93Wall()
LJ93.setParams(0, 6., 1., wall_cutoff)
SPLJ93 = espressopp.interaction.SingleParticleLennardJones93Wall(system, LJ93)
system.addInteraction(SPLJ93)
espressopp.interaction.LennardJones93Wall()
espressopp.interaction.LennardJones93Wall.getParams(type_var)
Parameters type_var –
Return type
espressopp.interaction.LennardJones93Wall.setParams(type_var, epsilon,
sigmaCutoff, r0)
sigma,
Parameters
• type_var –
• epsilon –
• sigma –
• sigmaCutoff –
• r0 –
espressopp.interaction.SingleParticleLennardJones93Wall(system, potential)
Parameters
• system –
• potential –
espressopp.interaction.SingleParticleLennardJones93Wall.setPotential(potential)
Parameters potential –
class espressopp.interaction.LennardJones93Wall.LennardJones93Wall
The LennardJones93Wall potential.
espressopp.interaction.LennardJonesAutoBonds
 () = 4
[︂(︁ )︁
 12

−
(︁  )︁6 ]︂

espressopp.interaction.LennardJonesAutoBonds(epsilon, sigma, cutoff, bondlist, maxcrosslinks)
Parameters
• epsilon (real) – (default: 1.0)
• sigma (real) – (default: 1.0)
• cutoff – (default: infinity)
• bondlist – (default: None)
• maxcrosslinks (int) – (default: 2)
espressopp.interaction.VerletListLennardJonesAutoBonds(vl)
Parameters vl –
espressopp.interaction.VerletListLennardJonesAutoBonds.getPotential(type1,
type2)
88
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListLennardJonesAutoBonds.getVerletList()
Return type A Python list of lists.
espressopp.interaction.VerletListLennardJonesAutoBonds.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressLennardJonesAutoBonds(vl,
fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListAdressLennardJonesAutoBonds.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressLennardJonesAutoBonds(vl,
fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListHadressLennardJonesAutoBonds.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.CellListLennardJonesAutoBonds(stor)
3.7. interaction
89
ESPResSo++ Documentation, Release latest
Parameters stor –
espressopp.interaction.CellListLennardJonesAutoBonds.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.FixedPairListLennardJonesAutoBonds(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListLennardJonesAutoBonds.setPotential(potential)
Parameters potential –
class espressopp.interaction.LennardJonesAutoBonds.LennardJonesAutoBonds
The Lennard-Jones auto bonds potential.
espressopp.interaction.LennardJonesCapped
 () = 4
[︂(︁ )︁
 12

−
(︁  )︁6 ]︂

where r is either the distance or the capped distance, depending on which is greater.
espressopp.interaction.LennardJonesCapped(epsilon, sigma, cutoff, caprad, shift)
Parameters
• epsilon (real) – (default: 1.0)
• sigma (real) – (default: 1.0)
• cutoff – (default: infinity)
• caprad (real) – (default: 0.0)
• shift – (default: “auto”)
espressopp.interaction.VerletListLennardJonesCapped(vl)
Parameters vl –
espressopp.interaction.VerletListLennardJonesCapped.getPotential(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
90
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.interaction.VerletListLennardJonesCapped.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressLennardJonesCapped(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListAdressLennardJonesCapped.getPotentialAT(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListAdressLennardJonesCapped.getPotentialCG(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListAdressLennardJonesCapped.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressLennardJonesCapped.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressLennardJonesCapped(vl, fixedtupleList)
Parameters
3.7. interaction
91
ESPResSo++ Documentation, Release latest
• vl –
• fixedtupleList –
espressopp.interaction.VerletListHadressLennardJonesCapped.getPotentialAT(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListHadressLennardJonesCapped.getPotentialCG(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListHadressLennardJonesCapped.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressLennardJonesCapped.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.CellListLennardJonesCapped(stor)
Parameters stor –
espressopp.interaction.CellListLennardJonesCapped.getPotential(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.CellListLennardJonesCapped.setPotential(type1,
type2,
potential)
Parameters
92
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• type1 –
• type2 –
• potential –
espressopp.interaction.FixedPairListLennardJonesCapped(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListLennardJonesCapped.getPotential()
Return type
espressopp.interaction.FixedPairListLennardJonesCapped.setPotential(potential)
Parameters potential –
class espressopp.interaction.LennardJonesCapped.LennardJonesCapped
The Lennard-Jones potential.
espressopp.interaction.LennardJonesEnergyCapped
 () = 4
[︂(︁ )︁
 12

−
(︁  )︁6 ]︂

where r is either the distance or the capped distance, depending on which is greater.
espressopp.interaction.LennardJonesEnergyCapped(epsilon, sigma, cutoff, caprad,
shift)
Parameters
• epsilon (real) – (default: 1.0)
• sigma (real) – (default: 1.0)
• cutoff – (default: infinity)
• caprad (real) – (default: 0.0)
• shift – (default: “auto”)
espressopp.interaction.VerletListLennardJonesEnergyCapped(vl)
Parameters vl –
espressopp.interaction.VerletListLennardJonesEnergyCapped.getPotential(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListLennardJonesEnergyCapped.setPotential(type1,
type2,
potential)
Parameters
3.7. interaction
93
ESPResSo++ Documentation, Release latest
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressLennardJonesEnergyCapped(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListAdressLennardJonesEnergyCapped.getPotentialAT(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListAdressLennardJonesEnergyCapped.getPotentialCG(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListAdressLennardJonesEnergyCapped.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressLennardJonesEnergyCapped.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressLennardJonesEnergyCapped(vl,
fixedtupleList)
Parameters
• vl –
• fixedtupleList –
94
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.interaction.VerletListHadressLennardJonesEnergyCapped.getPotentialAT(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListHadressLennardJonesEnergyCapped.getPotentialCG(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListHadressLennardJonesEnergyCapped.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressLennardJonesEnergyCapped.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.CellListLennardJonesEnergyCapped(stor)
Parameters stor –
espressopp.interaction.CellListLennardJonesEnergyCapped.getPotential(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.CellListLennardJonesEnergyCapped.setPotential(type1,
type2,
potential)
Parameters
• type1 –
3.7. interaction
95
ESPResSo++ Documentation, Release latest
• type2 –
• potential –
espressopp.interaction.FixedPairListLennardJonesEnergyCapped(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListLennardJonesEnergyCapped.getPotential()
Return type
espressopp.interaction.FixedPairListLennardJonesEnergyCapped.setPotential(potential)
Parameters potential –
class espressopp.interaction.LennardJonesEnergyCapped.LennardJonesEnergyCapped
The Lennard-Jones potential.
espressopp.interaction.LennardJonesExpand
 () = 4
[︂(︁ )︁
 12

−
(︁  )︁6 ]︂

espressopp.interaction.LennardJonesExpand(epsilon, sigma, delta, cutoff, shift)
Parameters
• epsilon (real) – (default: 1.0)
• sigma (real) – (default: 1.0)
• delta (real) – (default: 0.0)
• cutoff – (default: infinity)
• shift – (default: “auto”)
espressopp.interaction.VerletListLennardJonesExpand(vl)
Parameters vl –
espressopp.interaction.VerletListLennardJonesExpand.getPotential(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListLennardJonesExpand.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
96
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• potential –
espressopp.interaction.CellListLennardJonesExpand(stor)
Parameters stor –
espressopp.interaction.CellListLennardJonesExpand.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.FixedPairListLennardJonesExpand(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListLennardJonesExpand.setPotential(potential)
Parameters potential –
class espressopp.interaction.LennardJonesExpand.LennardJonesExpand
The LennardJonesExpand potential.
espressopp.interaction.LennardJonesGeneric
This class provides methods to compute forces and energies of a generic Lennard Jones potential with arbitrary
integers a and b.
]︂
[︂(︁ )︁
  (︁  )︁
−
 () = 4


espressopp.interaction.LennardJonesGeneric(epsilon, sigma, a, b, cutoff, shift)
Parameters
• epsilon (real) – (default: 1.0)
• sigma (real) – (default: 1.0)
• a (int) – (default: 12)
• b (int) – (default: 6)
• cutoff – (default: infinity)
• shift – (default: “auto”)
espressopp.interaction.VerletListLennardJonesGeneric(vl)
Parameters vl –
espressopp.interaction.VerletListLennardJonesGeneric.getPotential(type1,
type2)
Parameters
• type1 –
• type2 –
3.7. interaction
97
ESPResSo++ Documentation, Release latest
Return type
espressopp.interaction.VerletListLennardJonesGeneric.getVerletList()
Return type A Python list of lists.
espressopp.interaction.VerletListLennardJonesGeneric.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressLennardJonesGeneric(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListAdressLennardJonesGeneric.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressLennardJonesGeneric.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressLennardJonesGeneric2(vl,
fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListAdressLennardJonesGeneric2.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
98
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• type2 –
• potential –
espressopp.interaction.VerletListAdressLennardJonesGeneric2.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressLennardJonesGeneric(vl,
fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListHadressLennardJonesGeneric.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressLennardJonesGeneric.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressLennardJonesGeneric2(vl,
fixedtupleList, KTI)
Parameters
• vl –
• fixedtupleList –
• KTI – (default: False)
espressopp.interaction.VerletListHadressLennardJonesGeneric2.setPotentialAT(type1,
type2,
potential)
Parameters
3.7. interaction
99
ESPResSo++ Documentation, Release latest
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressLennardJonesGeneric2.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.CellListLennardJonesGeneric(stor)
Parameters stor –
espressopp.interaction.CellListLennardJonesGeneric.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.FixedPairListLennardJonesGeneric(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListLennardJonesGeneric.getFixedPairList()
Return type A Python list of lists.
espressopp.interaction.FixedPairListLennardJonesGeneric.getPotential()
Return type
espressopp.interaction.FixedPairListLennardJonesGeneric.setFixedPairList(fixedpairlist)
Parameters fixedpairlist –
espressopp.interaction.FixedPairListLennardJonesGeneric.setPotential(potential)
Parameters potential –
class espressopp.interaction.LennardJonesGeneric.LennardJonesGeneric
The generic Lennard-Jones potential.
espressopp.interaction.LennardJonesGromacs
if 2 > 12
 = 4(
100
6
12
−
) + ( − 1 )3 (3 + 4( − 1 ) + 5)
12

6
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
else
 = 4(
6
 12
− 6)
12


espressopp.interaction.LennardJonesGromacs(epsilon, sigma, r1, cutoff, shift)
Parameters
• epsilon (real) – (default: 1.0)
• sigma (real) – (default: 1.0)
• r1 (real) – (default: 0.0)
• cutoff – (default: infinity)
• shift – (default: “auto”)
espressopp.interaction.VerletListLennardJonesGromacs(vl)
Parameters vl –
espressopp.interaction.VerletListLennardJonesGromacs.getPotential(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListLennardJonesGromacs.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.CellListLennardJonesGromacs(stor)
Parameters stor –
espressopp.interaction.CellListLennardJonesGromacs.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.FixedPairListLennardJonesGromacs(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListLennardJonesGromacs.setPotential(potential)
3.7. interaction
101
ESPResSo++ Documentation, Release latest
Parameters potential –
class espressopp.interaction.LennardJonesGromacs.LennardJonesGromacs
The LennardJonesGromacs potential.
espressopp.interaction.LennardJonesSoftcoreTI
This module is for performing simulations (e.g. as part of Thermodynamic Integration) where some Lennard-Jones
interactions are a function of a parameter , used to construct a pathway between states A and B.
For those interactions which are a function of , the potential is softcore Lennard Jones with the following form:


 ( , ) = (1 − )
( ) + 
( )
6 
6 1/6
 = (
 + 
)
6
6 1/6
 = (
(1 − ) + 
)
where  ,  ,  and  are the parameters of states A and B, and  and  are adjustable parameters of the


softcore potential. The potentials 
( ) and 
( ) are the normal Lennard-Jones 12-6 hardcore potentials:


( ) = 4.0 (
 12  6
−
)


The user specifies a list of particles, pidlist. For all pairs of particles with particletypes interacting via this potential,
the LJ interaction between two particles i and j is calculated as follows:

(full state A hardcore LJ interaction)
if (i not in pidlist) and (j not in pidlist): 
if (i in pidlist) and (j in pidlist):
if annihilate==True:  (softcore LJ interaction, function of lambda)

if annihilate==False: 
(full state A hardcore LJ interaction)
if (i in pidlist) xor (j in pidlist):  (softcore LJ interaction, function of lambda)
The default is annihilation (interactions within pidlist are coupled to lambda, and cross-interactions between particles in pidlist and particles in the rest of the system are also coupled to lambda). The alternative is decoupling
(only cross-interactions between particles in pidlist and particles in the rest of the system are coupled to lambda.
Interactions within pidlist are not affected by the value of lambda.) If annihilation==False, then decoupling is
performed. See: http://www.alchemistry.org/wiki/Decoupling_and_annihilation
Exclusions apply as normal, i.e. interactions are only calculated for pairs of particles not already excluded.
This class does not do any automatic shifting of the potential.
So far only VerletListAdressLennardJonesSoftcoreTI is implemented, however VerletListLennardJonesSoftcoreTI, VerletListHadressLennardJonesSoftcoreTI, etc. can also be easily implemented.
The  (lambdaTI) parameter used here should not be confused with the  (lambda_adr) particle property
used in AdResS simulations.
See also the Thermodynamic Integration tutorial.
Example python script:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
102
#value of lambda
lambdaTI = 0.3
#softcore parameters
alphaSC = 0.5
powerSC = 1.0
#make list of indices of particles whose LJ parameters are different in TI states A and B
pidlist = [1,2,3,4]
#create interaction using VerletListAdress object and FixedTupleListAdress object
lj_adres_interaction=espressopp.interaction.VerletListAdressLennardJonesSoftcoreTI(verletlist,
#loop over list of all types for particles interacting with this atomistic potential
for i in types:
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
>>>
for k in types:
>>>
ljpot = espressopp.interaction.LennardJonesSoftcoreTI(epsilonA=epsA[i][k], sigmaA=sigA[i][
>>>
ljpot.addPids(pidlist)
>>>
lj_adres_interaction.setPotentialAT(type1=i, type2=k, potential=ljpot)
>>> system.addInteraction(lj_adres_interaction)
During the MD run, one can then calculate the derivative of the RF energy wrt lambda
>>> #calculate dU/dlambda
>>> dUdl = lj_adres_interaction.computeEnergyDeriv()
espressopppp.interaction.LennardJonesSoftcoreTI(epsilonA,
sigmaA,
epsilonB,
sigmaB, alpha, power, cutoff,
lambdaTI, annihilate)
Parameters
• epsilonA (real) – (default: 1.0) LJ interaction parameter
• sigmaA (real) – (default: 1.0) LJ interaction parameter
• epsilonB (real) – (default: 0.0) LJ interaction parameter
• sigmaB (real) – (default: 1.0) LJ interaction parameter
• alpha (real) – (default: 1.0) softcore parameter
• power (real) – (default: 1.0) softcore parameter
• cutoff (real) – (default: infinity) interaction cutoff
• lambdaTI (real) – (default: 0.0) TI lambda parameter
• annihilate (bool) – (default: True) switch between annihilation and decoupling
espressopppp.interaction.LennardJonesSoftcoreTI.addPids(pidlist)
Parameters pidlist (python list) – list of particle ids of particles whose interaction
parameters differ in state A and B
espressopppp.interaction.VerletListAdressLennardJones(vl, fixedtupleList)
Parameters
• vl (VerletListAdress object) – Verlet list
• fixedtupleList (FixedTupleListAdress object) – list of tuples describing mapping between CG and AT particles
espressopppp.interaction.VerletListAdressLennardJones.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 (int) – atomtype
• type2 (int) – atomtype
• potential (Potential) – espressopppp potential
espressopppp.interaction.VerletListAdressLennardJones.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 (int) – atomtype
3.7. interaction
103
ESPResSo++ Documentation, Release latest
• type2 (int) – atomtype
• potential (Potential) – espressopppp potential
class espressopp.interaction.LennardJonesSoftcoreTI.LennardJonesSoftcoreTI
The Lennard-Jones potential.
espressopp.interaction.LJcos
if 2 ≤  , then:
 = 4(
1
1
− 6) + 1 − 
12

else:
=
1
((2 + ) − 1)
2
espressopp.interaction.LJcos(phi)
Parameters phi (real) – (default: 1.0)
espressopp.interaction.VerletListLJcos(vl)
Parameters vl –
espressopp.interaction.VerletListLJcos.getPotential(type1, type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListLJcos.getVerletList()
Return type A Python list of lists.
espressopp.interaction.VerletListLJcos.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressLJcos(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListAdressLJcos.setPotentialAT(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressLJcos.setPotentialCG(type1, type2, potential)
104
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressLJcos(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListHadressLJcos.setPotentialAT(type1, type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressLJcos.setPotentialCG(type1, type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.CellListLJcos(stor)
Parameters stor –
espressopp.interaction.CellListLJcos.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.FixedPairListLJcos(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListLJcos.getFixedPairList()
Return type A Python list of lists.
espressopp.interaction.FixedPairListLJcos.setFixedPairList(fixedpairlist)
Parameters fixedpairlist –
espressopp.interaction.FixedPairListLJcos.setPotential(potential)
Parameters potential –
class espressopp.interaction.LJcos.LJcos
The Lennard-Jones potential.
3.7. interaction
105
ESPResSo++ Documentation, Release latest
espressopp.interaction.MirrorLennardJones
This class provides methods to compute forces and energies of the Mirror Lennard-Jones potential.
 () =  ( − | −  |)
where  is the 6-12 purely repulsive Lennard-Jones potential. This potential is introduced in R.L.C. Akkermans,
S. Toxvaerd and & W. J. Briels. Molecular dynamics of polymer growth. The Journal of Chemical Physics, 1998,
109, 2929-2940.
espressopp.interaction.MirrorLennardJones(epsilon, sigma)
Parameters
• epsilon (real) – (default: 1.0)
• sigma (real) – (default: 0.0)
espressopp.interaction.FixedPairListMirrorLennardJones(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListMirrorLennardJones.getFixedPairList()
Return type A Python list of lists.
espressopp.interaction.FixedPairListMirrorLennardJones.getPotential()
Return type
espressopp.interaction.FixedPairListMirrorLennardJones.setFixedPairList(fixedpairlist)
Parameters fixedpairlist –
espressopp.interaction.FixedPairListMirrorLennardJones.setPotential(potential)
Parameters potential –
class espressopp.interaction.MirrorLennardJones.MirrorLennardJones
The MirrorLennardJones potential.
espressopp.interaction.Morse
This class provides methods to compute forces and energies of the Morse potential.
(︁
)︁
 =  −2(− ) − 2−(− )
espressopp.interaction.Morse(epsilon, alpha, rMin, cutoff, shift)
Parameters
• epsilon (real) – (default: 1.0)
• alpha (real) – (default: 1.0)
• rMin (real) – (default: 0.0)
• cutoff – (default: infinity)
• shift – (default: “auto”)
espressopp.interaction.VerletListMorse(vl)
Parameters vl –
106
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.interaction.VerletListMorse.getPotential(type1, type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListMorse.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressMorse(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListAdressMorse.setPotentialAT(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressMorse.setPotentialCG(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressMorse(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListHadressMorse.setPotentialAT(type1, type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressMorse.setPotentialCG(type1, type2,
potential)
Parameters
• type1 –
• type2 –
3.7. interaction
107
ESPResSo++ Documentation, Release latest
• potential –
espressopp.interaction.CellListMorse(stor)
Parameters stor –
espressopp.interaction.CellListMorse.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.FixedPairListMorse(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListMorse.setPotential(potential)
Parameters potential –
class espressopp.interaction.Morse.Morse
The Morse potential.
espressopp.interaction.OPLS
This class provides methods to compute forces and energies of the OPLS dihedral potential. To create a new
dihedral potential.
=
4
∑︁
 (1 + ())
=1
espressopp.interaction.OPLS(K1, K2, K3, K4)
Parameters
• K1 (real) – (default: 1.0)
• K2 (real) – (default: 0.0)
• K3 (real) – (default: 0.0)
• K4 (real) – (default: 0.0)
espressopp.interaction.FixedQuadrupleListOPLS(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedQuadrupleListOPLS.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
108
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• potential –
class espressopp.interaction.OPLS.OPLS
The OPLS potential.
espressopp.interaction.Potential
This is an abstract class, only needed to be inherited from.
espressopp.interaction.Potential.computeEnergy(*args)
Parameters *args –
Return type
espressopp.interaction.Potential.computeForce(*args)
Parameters *args –
Return type
espressopp.interaction.PotentialUniqueDist
This is an abstract class, only needed to be inherited from.
espressopp.interaction.PotentialUniqueDist.computeEnergy(*args)
Parameters *args –
Return type
espressopp.interaction.PotentialUniqueDist.computeForce(*args)
Parameters *args –
Return type
espressopp.interaction.PotentialVSpherePair
This is an abstract class, only needed to be inherited from.
espressopp.interaction.PotentialVSpherePair.computeEnergy(*args)
Parameters *args –
Return type
espressopp.interaction.PotentialVSpherePair.computeForce(*args)
Parameters *args –
Return type
espressopp.interaction.Quartic
This class provides methods to compute forces and energies of the Quartic potential.
=
)︀2
 (︀ 2
 − 02
4
espressopp.interaction.Quartic(K, r0, cutoff, shift)
Parameters
• K (real) – (default: 1.0)
3.7. interaction
109
ESPResSo++ Documentation, Release latest
• r0 (real) – (default: 0.0)
• cutoff – (default: infinity)
• shift (real) – (default: 0.0)
espressopp.interaction.FixedPairListQuartic(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListQuartic.getFixedPairList()
Return type A Python list of lists.
espressopp.interaction.FixedPairListQuartic.setFixedPairList(fixedpairlist)
Parameters fixedpairlist –
espressopp.interaction.FixedPairListQuartic.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
class espressopp.interaction.Quartic.Quartic
The Quartic potential.
espressopp.interaction.ReactionFieldGeneralized
This class provides methods to compute forces and energies of the generalized reaction field.
(︁
)︁
⎞
⎛
(1 −42 )(1+ )−22  2
1
+
2
(1 +22 )(1+ )+2 
3
1
2
⎠
· 2 −
 = ⎝ −

3 2
 (22 + 1)
where P is a prefactor, Q is the product of the charges of the two particles, d is their distance from each other, and
 the cutoff-radius.
espressopp.interaction.ReactionFieldGeneralized(prefactor, kappa, epsilon1, epsilon2, cutoff, shift)
Parameters
• prefactor (real) – (default: 1.0)
• kappa (real) – (default: 0.0)
• epsilon1 (real) – (default: 1.0)
• epsilon2 (real) – (default: 80.0)
• cutoff – (default: infinity)
• shift – (default: “auto”)
espressopp.interaction.VerletListReactionFieldGeneralized(vl)
Parameters vl –
espressopp.interaction.VerletListReactionFieldGeneralized.getPotential(type1,
type2)
110
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListReactionFieldGeneralized.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressReactionFieldGeneralized(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListAdressReactionFieldGeneralized.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressReactionFieldGeneralized.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressReactionFieldGeneralized(vl,
fixedtupleList)
Parameters
• vl –
• fixedtupleList –
3.7. interaction
111
ESPResSo++ Documentation, Release latest
espressopp.interaction.VerletListHadressReactionFieldGeneralized.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressReactionFieldGeneralized.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.CellListReactionFieldGeneralized(stor)
Parameters stor –
espressopp.interaction.CellListReactionFieldGeneralized.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
class espressopp.interaction.ReactionFieldGeneralized.ReactionFieldGeneralized
The ReactionFieldGeneralized potential.
espressopp.interaction.ReactionFieldGeneralizedTI
This module is for performing simulations (e.g. as part of Thermodynamic Integration) where some interactions
are a linear function of a parameter .
 () = (1 − )
where  is the standard Reaction Field interaction. This allows one to perform TI where the charges in TI state
A ( = 0) are the particle charges contained in the particle property charge and the charges in TI state B ( = 1)
are zero.
The user specifies a list of particles, pidlist. For all pairs of particles with particletypes interacting via this potential,
the RF interaction between two particles i and j is calculated as follows:
if (i not in pidlist) and (j not in pidlist):  (full RF interaction)
if (i in pidlist) and (j in pidlist):
if annihilate==True: (1 − ) (RF interaction scaled by 1-lambda)
112
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
if annihilate==False:  (full RF interaction)
if (i in pidlist) xor (j in pidlist): (1 − ) (RF interaction scaled by 1-lambda)
The default is annihilation (completely turning off charges of particles in pidlist in state B, so that interactions
within pidlist are turned off and also cross-interactions between particles in pidlist and particles in the rest of the
system). The alternative is decoupling (only cross-interactions between particles in pidlist and particles in the rest
of the system are turned off. Interactions within pidlist are not affected.) If annihilation==False, then decoupling
is performed. See: http://www.alchemistry.org/wiki/Decoupling_and_annihilation
Exclusions apply as normal, i.e. interactions are only calculated for pairs of particles not already excluded.
So far only VerletListAdressReactionFieldGeneralizedTI is implemented, however VerletListReactionFieldGeneralizedTI, VerletListHadressReactionFieldGeneralizedTI, etc. can also be easily implemented.
The  (lambdaTI) parameter used here should not be confused with the  (lambda_adr) particle property
used in AdResS simulations.
See also the Thermodynamic Integration tutorial.
Example python script:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
#value of lambda
lambdaTI = 0.3
#construct RF potential with parameters prefactor,kappa,epsilon1,epsilon2,cutoff as in standar
pot = espressopp.interaction.ReactionFieldGeneralizedTI(prefactor=prefactor, kappa=kappa, epsi
#add list of indices of particles whose charge is 0 in TI state B
pidlist = [1,2,3,4]
pot.addPids(pidlist)
#create interaction using VerletListAdress object and FixedTupleListAdress object
qq_adres_interaction=espressopp.interaction.VerletListAdressReactionFieldGeneralizedTI(verletl
#loop over list of all types for particles interacting with this atomistic potential
for i in types:
for k in types:
qq_adres_interaction.setPotentialAT(type1=i, type2=k, potential=pot)
system.addInteraction(qq_adres_interaction)
During the MD run, one can then calculate the derivative of the RF energy wrt lambda
>>> #calculate dU/dlambda
>>> dUdl = qq_adres_interaction.computeEnergyDeriv()
espressopppp.interaction.ReactionFieldGeneralizedTI(prefactor, kappa, epsilon1,
epsilon2, cutoff, lambdaTI,
annihilate)
Parameters
• prefactor (real) – (default: 1.0) RF parameter
• kappa (real) – (default: 0.0) RF parameter
• epsilon1 (real) – (default: 1.0) RF parameter
• epsilon2 (real) – (default: 80.0) RF parameter
• cutoff (real) – (default: infinity) interaction cutoff
• lambdaTI (real) – (default: 0.0) TI lambda parameter
• annihilate (bool) – (default: True) switch between annihilation and decoupling
espressopppp.interaction.ReactionFieldGeneralizedTI.addPids(pidlist)
Parameters pidlist (python list) – list of particle ids of particles whose charge is zero
in state B
espressopppp.interaction.VerletListAdressReactionFieldGeneralized(vl,
fixedtupleList)
3.7. interaction
113
ESPResSo++ Documentation, Release latest
Parameters
• vl (VerletListAdress object) – Verlet list
• fixedtupleList (FixedTupleListAdress object) – list of tuples describing mapping between CG and AT particles
espressopppp.interaction.VerletListAdressReactionFieldGeneralized.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 (int) – atomtype
• type2 (int) – atomtype
• potential (Potential) – espressopppp potential
espressopppp.interaction.VerletListAdressReactionFieldGeneralized.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 (int) – atomtype
• type2 (int) – atomtype
• potential (Potential) – espressopppp potential
class espressopp.interaction.ReactionFieldGeneralizedTI.ReactionFieldGeneralizedTI
The ReactionFieldGeneralizedTI potential.
espressopp.interaction.SingleParticlePotential
This class is used to define single-particle interactions, typically used for external forces on the system.
The potential may depend on any of the particle properties (type, mass, etc.).
espressopp.interaction.SingleParticlePotential.computeEnergy(position, bc)
Parameters
• position –
• bc –
Return type
espressopp.interaction.SingleParticlePotential.computeForce(position, bc)
Parameters
• position –
• bc –
Return type
114
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.interaction.SoftCosine
This class provides methods to compute forces and energies ofthe SoftCosine potential.
[︂
(︂ )︂]︂

 () =  1.0 + 

espressopp.interaction.SoftCosine(A, cutoff, shift)
Parameters
• A (real) – (default: 1.0)
• cutoff – (default: infinity)
• shift – (default: “auto”)
espressopp.interaction.VerletListSoftCosine(stor)
Parameters stor –
espressopp.interaction.VerletListSoftCosine.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.CellListSoftCosine(stor)
Parameters stor –
espressopp.interaction.CellListSoftCosine.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.FixedPairListSoftCosine(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListSoftCosine.setPotential(potential)
Parameters potential –
class espressopp.interaction.SoftCosine.SoftCosine
The SoftCosine potential.
espressopp.interaction.StillingerWeberPairTerm
This class provides methods to compute forces and energies of 2 body term of Stillinger-Weber potential.
(︃
)︃
[︂ −
]︂

1
 = 
( − 1)  

 − 
where  is the cutoff-radius.
3.7. interaction
115
ESPResSo++ Documentation, Release latest
espressopp.interaction.StillingerWeberPairTerm(A, B, p, q, epsilon, sigma, cutoff )
Parameters
• A–
• B–
• p–
• q–
• epsilon (real) – (default: 1.0)
• sigma (real) – (default: 1.0)
• cutoff – (default: infinity)
espressopp.interaction.VerletListStillingerWeberPairTerm(vl)
Parameters vl –
espressopp.interaction.VerletListStillingerWeberPairTerm.getPotential(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListStillingerWeberPairTerm.getVerletList()
Return type A Python list of lists.
espressopp.interaction.VerletListStillingerWeberPairTerm.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressStillingerWeberPairTerm(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListAdressStillingerWeberPairTerm.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
116
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.interaction.VerletListAdressStillingerWeberPairTerm.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressStillingerWeberPairTerm(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListHadressStillingerWeberPairTerm.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressStillingerWeberPairTerm.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.CellListStillingerWeberPairTerm(stor)
Parameters stor –
espressopp.interaction.CellListStillingerWeberPairTerm.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.FixedPairListStillingerWeberPairTerm(system, vl, potential)
Parameters
3.7. interaction
117
ESPResSo++ Documentation, Release latest
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListStillingerWeberPairTerm.setPotential(potential)
Parameters potential –
class espressopp.interaction.StillingerWeberPairTerm.StillingerWeberPairTerm
The Lennard-Jones potential.
espressopp.interaction.StillingerWeberPairTermCapped
This class provides methods to compute forces and energies of 2 body term of Stillinger-Weber potential.
If the distance is smaller than the cap-radius:
1
12 −
 = [−
12 ( − 1)]
where  is the cutoff-radius.
espressopp.interaction.StillingerWeberPairTermCapped(A, B, p, q, epsilon, sigma,
cutoff, caprad)
Parameters
• A–
• B–
• p–
• q–
• epsilon (real) – (default: 1.0)
• sigma (real) – (default: 1.0)
• cutoff – (default: infinity)
• caprad (real) – (default: 0.0)
espressopp.interaction.VerletListStillingerWeberPairTermCapped(vl)
Parameters vl –
espressopp.interaction.VerletListStillingerWeberPairTermCapped.getCaprad()
Return type
espressopp.interaction.VerletListStillingerWeberPairTermCapped.getPotential(type1,
type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListStillingerWeberPairTermCapped.getVerletList()
Return type A Python list of lists.
espressopp.interaction.VerletListStillingerWeberPairTermCapped.setPotential(type1,
type2,
potential)
118
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressStillingerWeberPairTermCapped(vl,
fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListAdressStillingerWeberPairTermCapped.setPotentialAT(type1
type2
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressStillingerWeberPairTermCapped.setPotentialCG(type1
type2
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressStillingerWeberPairTermCapped(vl,
fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListHadressStillingerWeberPairTermCapped.setPotentialAT(type
type
potential)
Parameters
• type1 –
• type2 –
• potential –
3.7. interaction
119
ESPResSo++ Documentation, Release latest
espressopp.interaction.VerletListHadressStillingerWeberPairTermCapped.setPotentialCG(type
type
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.CellListStillingerWeberPairTermCapped(stor)
Parameters stor –
espressopp.interaction.CellListStillingerWeberPairTermCapped.setPotential(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.FixedPairListStillingerWeberPairTermCapped(system,
vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListStillingerWeberPairTermCapped.setPotential(potential)
Parameters potential –
class espressopp.interaction.StillingerWeberPairTermCapped.StillingerWeberPairTermCapped
The Lennard-Jones potential.
espressopp.interaction.StillingerWeberTripleTerm
This class provides methods to compute forces and energies of the Stillinger Weber Triple Term potential.
if 12 >= 1 or 32 >= 2
 = 0.0
else
 = 
1
|12 |−1
2
+
|32 | − 2
(︂
)︂2
12 32
− (0 )
|12 | · |32 |
espressopp.interaction.StillingerWeberTripleTerm(gamma, theta0, lmbd, epsilon,
sigma, cutoff )
Parameters
120
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• gamma (real) – (default: 0.0)
• theta0 (real) – (default: 0.0)
• lmbd (real) – (default: 0.0)
• epsilon (real) – (default: 1.0)
• sigma (real) – (default: 1.0)
• cutoff – (default: infinity)
espressopp.interaction.VerletListStillingerWeberTripleTerm(system, vl3)
Parameters
• system –
• vl3 –
espressopp.interaction.VerletListStillingerWeberTripleTerm.getPotential(type1,
type2,
type3)
Parameters
• type1 –
• type2 –
• type3 –
Return type
espressopp.interaction.VerletListStillingerWeberTripleTerm.getVerletListTriple()
Return type A Python list of lists.
espressopp.interaction.VerletListStillingerWeberTripleTerm.setPotential(type1,
type2,
type3,
potential)
Parameters
• type1 –
• type2 –
• type3 –
• potential –
espressopp.interaction.FixedTripleListStillingerWeberTripleTerm(system, ftl,
potential)
Parameters
• system –
• ftl –
• potential –
espressopp.interaction.FixedTripleListStillingerWeberTripleTerm.getFixedTripleList()
Return type A Python list of lists.
3.7. interaction
121
ESPResSo++ Documentation, Release latest
espressopp.interaction.FixedTripleListStillingerWeberTripleTerm.setPotential(type1,
type2,
type3,
potential)
Parameters
• type1 –
• type2 –
• type3 –
• potential –
class espressopp.interaction.StillingerWeberTripleTerm.StillingerWeberTripleTerm
The StillingerWeberTripleTerm potential.
espressopp.interaction.Tabulated
espressopp.interaction.Tabulated(itype, filename, cutoff )
Parameters
• itype –
• filename –
• cutoff – (default: infinity)
espressopp.interaction.VerletListAdressTabulated(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListAdressTabulated.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressTabulated.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressTabulated(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
122
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.interaction.VerletListHadressTabulated.setPotentialAT(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressTabulated.setPotentialCG(type1,
type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListTabulated(vl)
Parameters vl –
espressopp.interaction.VerletListTabulated.getPotential(type1, type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListTabulated.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.CellListTabulated(stor)
Parameters stor –
espressopp.interaction.CellListTabulated.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.FixedPairListTabulated(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListTabulated.setPotential(potential)
3.7. interaction
123
ESPResSo++ Documentation, Release latest
Parameters potential –
espressopp.interaction.FixedPairListTypesTabulated(system, ftl)
Parameters
• system (espressopp.System) – The Espresso++ system object.
• ftl (espressopp.FixedPairList) – The FixedPair list.
espressopp.interaction.FixedPairListTypesTabulated.setPotential(type1,
type2,
potential)
Defines bond potential for interaction between particles of types type1-type2-type3.
Parameters
• type1 (int) – Type of particle 1.
• type2 (int) – Type of particle 2.
• potential (espressopp.interaction.Potential) – The potential to set
up.
class espressopp.interaction.Tabulated.Tabulated
The Tabulated potential.
espressopp.interaction.TabulatedAngular
espressopp.interaction.TabulatedAngular(itype, filename)
Parameters
• itype (int) – The interpolation type: 1 - linear, 2 - akima spline, 3 - cubic spline
• filename (str) – The tabulated potential filename.
espressopp.interaction.FixedTripleListTabulatedAngular(system, ftl, potential)
Parameters
• system (espressopp.System) – The Espresso++ system object.
• ftl (espressopp.FixedTripleList) – The FixedTripleList.
• potential (espressopp.interaction.Potential) – The potential.
espressopp.interaction.FixedTripleListTabulatedAngular.setPotential(potential)
Parameters potential (espressopp.interaction.Potential) – The potential
object.
espressopp.interaction.FixedTripleListTypesTabulatedAngular(system, ftl)
Parameters
• system (espressopp.System) – The Espresso++ system object.
• ftl (espressopp.FixedTripleList) – The FixedTriple list.
espressopp.interaction.FixedTripleListTypesTabulatedAngular.setPotential(type1,
type2,
type3,
potential)
Defines angular potential for interaction between particles of types type1-type2-type3.
Parameters
• type1 (int) – Type of particle 1.
124
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• type2 (int) – Type of particle 2.
• type3 (int) – Type of particle 3.
• potential (espressopp.interaction.AngularPotential) – The potential to set up.
class espressopp.interaction.TabulatedAngular.TabulatedAngular
The TabulatedAngular potential.
espressopp.interaction.TabulatedDihedral
Calculates energies and forces for a dihedral tabulated potential. In the tabulated potential file, angles should be
in radians, and the file should cover the range -pi radians to +pi radians (-180 to +180 degrees).
Note that this class has only been tested for symmetric tabulated potentials.
espressopp.interaction.TabulatedDihedral(itype, filename)
Parameters itype – The interpolation type: 1 - linear, 2 - akima spline, 3 - cubic spline :param
filename: The tabulated potential filename. :type itype: int :type filename: str
espressopp.interaction.FixedQuadrupleListTabulatedDihedral(system, fql, potential)
Parameters
• system (espressopp.System) – The Espresso++ system object.
• fql (espressopp.FixedQuadrupleList) – The FixedQuadrupleList.
• potential (espressopp.interaction.Potential) – The potential.
espressopp.interaction.FixedQuadrupleListTabulatedDihedral.setPotential(potential)
Parameters potential (espressopp.interaction.Potential) – The potential
object.
espressopp.interaction.FixedQuadrupleListTypesTabulatedDihedral(system,
fql)
Parameters
• system (espressopp.System) – The Espresso++ system object.
• ftl (espressopp.FixedQuadrupleList) – The FixedQuadrupleList list.
espressopp.interaction.FixedQuadrupleListTypesTabulatedDihedral(system,
ftl)
Parameters
• system (espressopp.System) – The Espresso++ system object.
• ftl (espressopp.FixedQuadrupleList) – The FixedQuadruple list.
espressopp.interaction.FixedQuadrupleListTypesTabulatedDihedral.setPotential(type1,
type2,
type3,
type4,
potential)
Defines dihedral potential for interaction between particles of types type1-type2-type3-type4.
Parameters
• type1 (int) – Type of particle 1.
• type2 (int) – Type of particle 2.
3.7. interaction
125
ESPResSo++ Documentation, Release latest
• type3 (int) – Type of particle 3.
• type4 (int) – Type of particle 4.
• potential (espressopp.interaction.DihedralPotential) – The potential to set up.
class espressopp.interaction.TabulatedDihedral.TabulatedDihedral
The TabulatedDihedral potential.
espressopp.interaction.TersoffPairTerm
This class provides methods to compute forces and energies of 2 body term of Tersoff potential.
if 12 >  + 
 =0
if 12 <  − 
 = −112
else
=
)︁)︁
(︁ 
1 (︁
(12 − ) −1 12
1 − 
2
4
espressopp.interaction.TersoffPairTerm(A, lambda1, R, D, cutoff )
Parameters
• A–
• lambda1 –
• R–
• D–
• cutoff – (default: infinity)
espressopp.interaction.VerletListTersoffPairTerm(vl)
Parameters vl –
espressopp.interaction.VerletListTersoffPairTerm.getPotential(type1, type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListTersoffPairTerm.getVerletList()
Return type A Python list of lists.
espressopp.interaction.VerletListTersoffPairTerm.setPotential(type1, type2,
potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.CellListTersoffPairTerm(stor)
126
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
Parameters stor –
espressopp.interaction.CellListTersoffPairTerm.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.FixedPairListTersoffPairTerm(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListTersoffPairTerm.setPotential(potential)
Parameters potential –
class espressopp.interaction.TersoffPairTerm.TersoffPairTerm
The Lennard-Jones potential.
espressopp.interaction.TersoffTripleTerm
This class provides methods to compute forces and energies of the Tersoff Triple Term potential.
⎛
⎛
2
⎜
⎜
⎜
−
 =   ⎝1 + ⎝  ⎝1 +
2
1
⎞ ⎞− 2
⎞
⎛
2
2 +
(︁
12 32
|12 ||32 |
(︁
− (0 )
⎟  (| |−|32 |)
)︁2 ⎠  3 12
)︁
⎟ ⎟
⎠ ⎠
espressopp.interaction.VerletListTersoffTripleTerm(system, vl3)
Parameters
• system –
• vl3 –
espressopp.interaction.VerletListTersoffTripleTerm.getPotential(type1,
type2,
type3)
Parameters
• type1 –
• type2 –
• type3 –
Return type
espressopp.interaction.VerletListTersoffTripleTerm.getVerletListTriple()
Return type A Python list of lists.
espressopp.interaction.VerletListTersoffTripleTerm.setPotential(type1,
type2,
type3,
potential)
Parameters
3.7. interaction
127
ESPResSo++ Documentation, Release latest
• type1 –
• type2 –
• type3 –
• potential –
espressopp.interaction.FixedTripleListTersoffTripleTerm(system, ftl, potential)
Parameters
• system –
• ftl –
• potential –
espressopp.interaction.FixedTripleListTersoffTripleTerm.getFixedTripleList()
Return type A Python list of lists.
espressopp.interaction.FixedTripleListTersoffTripleTerm.setPotential(type1,
type2,
type3,
potential)
Parameters
• type1 –
• type2 –
• type3 –
• potential –
espressopp.interaction.VSpherePair
This class provides methods to compute forces and energies of the VSpherePair potential.
(︂
 ( ,  ) = 
2

3
)︂− 23

− 23
2


,  = |⃗
 − ⃗ | ,  = 2 + 2
Reference: Flactuating soft-sphere approach to coars-graining of polymer melts, Soft matter, 2010, 6, 2282
espressopp.interaction.VSpherePair(epsilon, cutoff, shift)
Parameters
• epsilon (real) – (default: 1.0)
• cutoff – (default: infinity)
• shift – (default: “auto”)
espressopp.interaction.VerletListVSpherePair(vl)
Parameters vl –
espressopp.interaction.VerletListVSpherePair.getPotential(type1, type2)
Parameters
• type1 –
• type2 –
Return type
128
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.interaction.VerletListVSpherePair.getVerletList()
Return type A Python list of lists.
espressopp.interaction.VerletListVSpherePair.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
class espressopp.interaction.VSpherePair.VSpherePair
The Lennard-Jones potential.
espressopp.interaction.VSphereSelf
This class provides methods to compute forces and energies of the VSphereSelf potential.
(︂
 = 1
4 2

3
)︂ 32
+
2 2
 1  3
+

6


Reference: Flactuating soft-sphere approach to coars-graining of polymer melts, Soft matter, 2010, 6, 2282
espressopp.interaction.VSphereSelf(e1, a1, a2, Nb, cutoff, shift)
Parameters
• e1 (real) – (default: 0.0)
• a1 (real) – (default: 1.0)
• a2 (real) – (default: 0.0)
• Nb (int) – (default: 1)
• cutoff – (default: infinity)
• shift (real) – (default: 0.0)
espressopp.interaction.SelfVSphere(system, potential)
Parameters
• system –
• potential –
espressopp.interaction.SelfVSphere.getPotential()
Return type
espressopp.interaction.SelfVSphere.setPotential(potential)
Parameters potential –
class espressopp.interaction.VSphereSelf.VSphereSelf
The VSphereSelf potential.
espressopp.interaction.Zero
This class provides methods for a zero potential no interactions between particles, mainly used for debugging and
testing
espressopp.interaction.Zero()
espressopp.interaction.VerletListZero(vl)
3.7. interaction
129
ESPResSo++ Documentation, Release latest
Parameters vl –
espressopp.interaction.VerletListZero.getPotential(type1, type2)
Parameters
• type1 –
• type2 –
Return type
espressopp.interaction.VerletListZero.setFixedTupleList(ftpl)
Parameters ftpl –
espressopp.interaction.VerletListZero.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressZero(vl)
Parameters vl –
espressopp.interaction.VerletListAdressZero.setFixedTupleList(ftpl)
Parameters ftpl –
espressopp.interaction.VerletListAdressZero.setPotentialAT(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListAdressZero.setPotentialCG(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.VerletListHadressZero(vl, fixedtupleList)
Parameters
• vl –
• fixedtupleList –
espressopp.interaction.VerletListHadressZero.setFixedTupleList(ftpl)
Parameters ftpl –
espressopp.interaction.VerletListHadressZero.setPotentialAT(type1, type2, potential)
Parameters
• type1 –
• type2 –
130
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• potential –
espressopp.interaction.VerletListHadressZero.setPotentialCG(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.CellListZero(stor)
Parameters stor –
espressopp.interaction.CellListZero.setPotential(type1, type2, potential)
Parameters
• type1 –
• type2 –
• potential –
espressopp.interaction.FixedPairListZero(system, vl, potential)
Parameters
• system –
• vl –
• potential –
espressopp.interaction.FixedPairListZero.setPotential(potential)
Parameters potential –
class espressopp.interaction.Zero.Zero
The Zero potential.
io
espressopp.io.DumpGRO
• dump() write configuration to trajectory GRO file. By default filename is “out.gro”, coordinates are folded.
Properties
• filename Name of trajectory file. By default trajectory file name is “out.gro”
• unfolded False if coordinates are folded, True if unfolded. By default - False
• append True if new trajectory data is appended to existing trajectory file. By default - True
• length_factor If length dimension in current system is nm, and unit is 0.23 nm, for example, then
length_factor should be 0.23
• length_unit It is length unit. Can be LJ, nm or A. By default - LJ
usage:
writing down trajectory
>>> dump_conf_gro = espressopp.io.DumpGRO(system, integrator, filename='trajectory.gro')
>>> for i in range (200):
>>>
integrator.run(10)
>>>
dump_conf_gro.dump()
3.8. io
131
ESPResSo++ Documentation, Release latest
writing down trajectory using ExtAnalyze extension
dump_conf_gro = espressopp.io.DumpGRO(system, integrator, filename='trajectory.gro')
ext_analyze = espressopp.integrator.ExtAnalyze(dump_conf_gro, 10)
integrator.addExtension(ext_analyze)
integrator.run(2000)
>>>
>>>
>>>
>>>
Both exapmles will give the same result: 200 configurations in trajectory .gro file.
setting up length scale
For example, the Lennard-Jones model for liquid argon with  = 0.34[]
>>> dump_conf_gro = espressopp.io.DumpGRO(system, integrator, filename='trj.gro', unfolded=False,
will produce trj.gro with in nanometers
espressopp.io.DumpGRO(system, integrator, filename, unfolded, length_factor, length_unit, append)
Parameters
• system –
• integrator –
• filename – (default: ‘out.gro’)
• unfolded – (default: False)
• length_factor (real) – (default: 1.0)
• length_unit – (default: ‘LJ’)
• append – (default: True)
espressopp.io.DumpGRO.dump()
Return type
espressopp.io.DumpGROAdress
dumps coordinates of atomistic particles instead of coarse-grained particles in Adress simulation
• dump() write configuration to trajectory GRO file. By default filename is “out.gro”, coordinates are folded.
Properties
• filename Name of trajectory file. By default trajectory file name is “out.gro”
• unfolded False if coordinates are folded, True if unfolded. By default - False
• append True if new trajectory data is appended to existing trajectory file. By default - True
• length_factor If length dimension in current system is nm, and unit is 0.23 nm, for example, then
length_factor should be 0.23
• length_unit It is length unit. Can be LJ, nm or A. By default - LJ
• ftpl fixedtuplelist for the adres system
usage:
>>>
>>>
>>>
>>>
ftpl = espressopp.FixedTupleListAdress(system.storage)
ftpl.addTuples(tuples)
system.storage.setFixedTuplesAdress(ftpl)
system.storage.decompose()
writing down trajectory
132
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
>>> dump_conf_gro = espressopp.io.DumpGROAdress(system, ftpl, integrator, filename='trajectory.gro
>>> for i in range (200):
>>>
integrator.run(10)
>>>
dump_conf_gro.dump()
writing down trajectory using ExtAnalyze extension
>>>
>>>
>>>
>>>
dump_conf_gro = espressopp.io.DumpGROAdress(system, ftpl, integrator, filename='trajectory.gro
ext_analyze = espressopp.integrator.ExtAnalyze(dump_conf_gro, 10)
integrator.addExtension(ext_analyze)
integrator.run(2000)
Both exapmles will give the same result: 200 configurations in trajectory .gro file.
setting up length scale
For example, the Lennard-Jones model for liquid argon with  = 0.34[]
>>> dump_conf_gro = espressopp.io.DumpGROAdress(system, ftpl, integrator, filename='trj.gro', unfo
will produce trj.gro with in nanometers
espressopp.io.DumpGROAdress(system,
fixedtuplelist,
integrator,
length_factor, length_unit, append)
filename,
unfolded,
Parameters
• system –
• fixedtuplelist –
• integrator –
• filename – (default: ‘out.gro’)
• unfolded – (default: False)
• length_factor (real) – (default: 1.0)
• length_unit – (default: ‘LJ’)
• append – (default: True)
espressopp.io.DumpGROAdress.dump()
Return type
espressopp.io.DumpXYZ
• dump()
write configuration to trajectory XYZ file. By default filename is out.xyz, coordinates are folded.
DumpXYZ works also for Multiple communicators.
Properties
• filename Name of trajectory file. By default trajectory file name is out.xyz
• unfolded False if coordinates are folded, True if unfolded. By default - False
• append True if new trajectory data is appended to existing trajectory file. By default - True
• length_factor If length dimension in current system is nm, and unit is 0.23 nm, for example, then
length_factor should be 0.23 Default: 1.0
• length_unit It is length unit. Can be LJ, nm or A. By default - LJ
• store_pids True if you want to store pids as fastwritexyz does. False otherwise (standard XYZ) Default:
False
3.8. io
133
ESPResSo++ Documentation, Release latest
• store_velocities True if you want to store velocities. False otherwise (XYZ doesn’t require it) Default:
False
usage:
writing down trajectory
>>> dump_conf_xyz = espressopp.io.DumpXYZ(system, integrator, filename='trajectory.xyz')
>>> for i in range (200):
>>>
integrator.run(10)
>>>
dump_conf_xyz.dump()
writing down trajectory using ExtAnalyze extension
>>>
>>>
>>>
>>>
dump_conf_xyz = espressopp.io.DumpXYZ(system, integrator, filename='trajectory.xyz')
ext_analyze = espressopp.integrator.ExtAnalyze(dump_conf_xyz, 10)
integrator.addExtension(ext_analyze)
integrator.run(2000)
Both examples will give the same result: 200 configurations in trajectory .xyz file.
setting up length scale
For example, the Lennard-Jones model for liquid argon with  = 0.34[]
>>> dump_conf_xyz = espressopp.io.DumpXYZ(system, integrator, filename='trj.xyz', \
>>>
unfolded=False, length_factor=0.34, \
>>>
length_unit='nm', store_pids=True, \
>>>
store_velocities = True, append=True)
will produce trj.xyz with in nanometers
espressopp.io.DumpXYZ(system, integrator, filename=out.xyz, unfolded=False, length_factor=1.0,
length_unit=’LJ’, store_pids=False,
store_velocities=False,
append=True)
Parameters
• system –
• integrator –
• filename –
• unfolded (bool) –
• length_factor (real) –
• length_unit –
• store_pids (bool) –
• store_velocities (bool) –
• append (bool) –
espressopp.io.DumpXYZ.dump()
Return type
espressopp
espressopp.Exceptions
espressopp.Error(msg)
Parameters msg –
134
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.ParticleDoesNotExistHere(msg)
Parameters msg –
espressopp.UnknownParticleProperty(msg)
Parameters msg –
espressopp.MissingFixedPairList(msg)
Parameters msg –
espressopp.FixedLocalTupleList
This class can contain many tuple which store a arbitrary positive number, which should be more than 2, of local
(real + ghost) particle id.
For using this class, there is 1 conditions:
Particles in one tuple must be in a same or neighbor cell list.
espressopp.FixedLocalTupleList(storage)
Parameters storage –
espressopp.FixedLocalTupleList.addTuple(tuple)
Parameters tuple (python::list) –
espressopp.FixedLocalTupleList.getTuples()
Return type
espressopp.FixedLocalTupleList.size()
Return type
espressopp.FixedPairDistList
espressopp.FixedPairDistList(storage)
Parameters storage –
espressopp.FixedPairDistList.add(pid1, pid2)
Parameters
• pid1 –
• pid2 –
Return type
espressopp.FixedPairDistList.addPairs(bondlist)
Parameters bondlist –
Return type
espressopp.FixedPairDistList.getDist(pid1, pid2)
Parameters
• pid1 –
• pid2 –
Return type
espressopp.FixedPairDistList.getPairs()
Return type
3.9. espressopp
135
ESPResSo++ Documentation, Release latest
espressopp.FixedPairDistList.getPairsDist()
Return type
espressopp.FixedPairDistList.size()
Return type
espressopp.FixedPairList
espressopp.FixedPairList(storage)
Parameters storage –
espressopp.FixedPairList.add(pid1, pid2)
Parameters
• pid1 –
• pid2 –
Return type
espressopp.FixedPairList.addBonds(bondlist)
Parameters bondlist –
Return type
espressopp.FixedPairList.getBonds()
Return type
espressopp.FixedPairList.remove()
‘remove the FixedPairList and disconnect’
espressopp.FixedPairList.getLongtimeMaxBond()
Return type
espressopp.FixedPairList.resetLongtimeMaxBond()
Return type
espressopp.FixedPairList.size()
Return type
espressopp.FixedPairListAdress
The FixedPairListAdress is the Fixed Pair List to be used for AdResS or H-AdResS simulations. When creating
the FixedPairListAdress one has to provide the storage and the tuples. Afterwards the bonds can be added. In the
example “bonds” is a python list of the form ( (pid1, pid2), (pid3, pid4), ...) where each inner pair defines a bond
between the particles with the given particle ids.
Example - creating the FixedPairListAdress and adding bonds:
>>> ftpl = espressopp.FixedTupleList(system.storage)
>>> fpl = espressopp.FixedPairListAdress(system.storage, ftpl)
>>> fpl.addBonds(bonds)
espressopp.FixedPairListAdress(storage, fixedtupleList)
Parameters
• storage –
• fixedtupleList –
136
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.FixedPairListAdress.add(pid1, pid2)
Parameters
• pid1 –
• pid2 –
Return type
espressopp.FixedPairListAdress.addBonds(bondlist)
Parameters bondlist –
Return type
espressopp.FixedPairListAdress.remove()
remove the FixedPairListAdress and disconnect
espressopp.FixedPairListAdress.getBonds()
Return type
espressopp.FixedQuadrupleAngleList
espressopp.FixedQuadrupleAngleList(storage)
Parameters storage –
espressopp.FixedQuadrupleAngleList.add(pid1, pid2, pid3, pid4)
Parameters
• pid1 –
• pid2 –
• pid3 –
• pid4 –
Return type
espressopp.FixedQuadrupleAngleList.addQuadruples(quadruplelist)
Parameters quadruplelist –
Return type
espressopp.FixedQuadrupleAngleList.getAngle(pid1, pid2, pid3, pid4)
Parameters
• pid1 –
• pid2 –
• pid3 –
• pid4 –
Return type
espressopp.FixedQuadrupleAngleList.getQuadruples()
Return type
espressopp.FixedQuadrupleAngleList.getQuadruplesAngles()
Return type
espressopp.FixedQuadrupleAngleList.size()
Return type
3.9. espressopp
137
ESPResSo++ Documentation, Release latest
espressopp.FixedQuadrupleList
espressopp.FixedQuadrupleList(storage)
Parameters storage –
espressopp.FixedQuadrupleList.add(pid1, pid2, pid3, pid4)
Parameters
• pid1 –
• pid2 –
• pid3 –
• pid4 –
Return type
espressopp.FixedQuadrupleList.addQuadruples(quadruplelist)
Parameters quadruplelist –
Return type
espressopp.FixedQuadrupleList.remove()
remove the FixedPairList and disconnect
espressopp.FixedQuadrupleList.getQuadruples()
Return type
espressopp.FixedQuadrupleList.size()
Return type
espressopp.FixedQuadrupleListAdress
espressopp.FixedQuadrupleListAdress(storage, fixedtupleList)
Parameters
• storage –
• fixedtupleList –
espressopp.FixedQuadrupleListAdress.add(pid1, pid2, pid3, pid4)
Parameters
• pid1 –
• pid2 –
• pid3 –
• pid4 –
Return type
espressopp.FixedQuadrupleListAdress.addQuadruples(quadruplelist)
Parameters quadruplelist –
Return type
espressopp.FixedQuadrupleListAdress.getQuadruples()
Return type
espressopp.FixedQuadrupleListAdress.size()
Return type
138
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.FixedSingleList
espressopp.FixedSingleList(storage)
Parameters storage –
espressopp.FixedSingleList.add(pid1)
Parameters pid1 –
Return type
espressopp.FixedSingleList.addSingles(singlelist)
Parameters singlelist –
Return type
espressopp.FixedSingleList.getSingles()
Return type
espressopp.FixedSingleList.size()
Return type
espressopp.FixedTripleAngleList
espressopp.FixedTripleAngleList(storage)
Parameters storage –
espressopp.FixedTripleAngleList.add(pid1, pid2, pid3)
Parameters
• pid1 –
• pid2 –
• pid3 –
Return type
espressopp.FixedTripleAngleList.addTriples(triplelist)
Parameters triplelist –
Return type
espressopp.FixedTripleAngleList.getAngle(pid1, pid2, pid3)
Parameters
• pid1 –
• pid2 –
• pid3 –
Return type
espressopp.FixedTripleAngleList.getTriples()
Return type
espressopp.FixedTripleAngleList.getTriplesAngles()
Return type
espressopp.FixedTripleAngleList.size()
Return type
3.9. espressopp
139
ESPResSo++ Documentation, Release latest
espressopp.FixedTripleList
espressopp.FixedTripleList(storage)
Parameters storage –
espressopp.FixedTripleList.add(pid1, pid2, pid3)
Parameters
• pid1 –
• pid2 –
• pid3 –
Return type
espressopp.FixedTripleList.addTriples(triplelist)
Parameters triplelist –
Return type
espressopp.FixedTripleList.getTriples()
Return type
espressopp.FixedTripleList.size()
Return type
espressopp.FixedTripleList.remove()
remove the FixedPairList and disconnect
espressopp.FixedTripleListAdress
espressopp.FixedTripleListAdress(storage, fixedtupleList)
Parameters
• storage –
• fixedtupleList –
espressopp.FixedTripleListAdress.add(pid1, pid2)
Parameters
• pid1 –
• pid2 –
Return type
espressopp.FixedTripleListAdress.remove()
remove the FixedTripleListAdress and disconnect
espressopp.FixedTripleListAdress.addTriples(triplelist)
Parameters triplelist –
Return type
espressopp.FixedTupleList
espressopp.FixedTupleList(storage)
Parameters storage –
espressopp.FixedTupleList.size()
140
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
Return type
espressopp.FixedTupleListAdress
The FixedTupleListAdress is important for AdResS and H-AdResS simulations. It is the connection between
the atomistic and coarse-grained particles. It defines which atomistic particles belong to which coarse-grained
particle. In the following example “tuples” is a python list of the form ( (pid_CG1, pidAT11, pidAT12, pidAT13,
...), (pid_CG2, pidAT21, pidAT22, pidAT23, ...), ...). Each inner list (pid_CG1, pidAT11, pidAT12, pidAT13, ...)
defines a tuple. The first number is the particle id of the coarse-grained particle while the following numbers are
the particle ids of the corresponding atomistic particles.
Example - creating the FixedTupleListAdress:
>>> ftpl = espressopp.FixedTupleListAdress(system.storage)
>>> ftpl.addTuples(tuples)
>>> system.storage.setFixedTuples(ftpl)
espressopp.FixedTupleListAdress(storage)
Parameters storage –
espressopp.FixedTupleListAdress.addTuples(tuplelist)
Parameters tuplelist –
Return type
espressopp.Int3D
espressopp.__Int3D(*args)
Parameters *args –
espressopp.__Int3D.x(v, [0)
Parameters
• v–
• [0 –
Return type
espressopp.__Int3D.y(v, [1)
Parameters
• v–
• [1 –
Return type
espressopp.__Int3D.z(v, [2)
Parameters
• v–
• [2 –
Return type
espressopp.toInt3DFromVector(*args)
Parameters *args –
espressopp.toInt3D(*args)
Parameters *args –
3.9. espressopp
141
ESPResSo++ Documentation, Release latest
espressopp.Int3D.toInt3D(*args)
Try to convert the arguments to a Int3D, returns the argument, if it is already a Int3D.
espressopp.Int3D.toInt3DFromVector(*args)
Try to convert the arguments to a Int3D.
This function will only convert to a Int3D if x, y and z are specified.
espressopp.MultiSystem
espressopp.MultiSystem()
espressopp.MultiSystem.beginSystemDefinition()
Return type
espressopp.MultiSystem.runAnalysisNPart()
Return type
espressopp.MultiSystem.runAnalysisPotential()
Return type
espressopp.MultiSystem.runAnalysisTemperature()
Return type
espressopp.MultiSystem.runIntegrator(niter)
Parameters niter –
Return type
espressopp.MultiSystem.setAnalysisNPart(npart)
Parameters npart –
espressopp.MultiSystem.setAnalysisPotential(potential)
Parameters potential –
espressopp.MultiSystem.setAnalysisTemperature(temperature)
Parameters temperature –
espressopp.MultiSystem.setIntegrator(integrator)
Parameters integrator –
class espressopp.MultiSystem.MultiSystem
MultiSystemIntegrator to simulate and analyze several systems in parallel.
class espressopp.MultiSystem.MultiSystemLocal
Local MultiSystem to simulate and analyze several systems in parallel.
espressopp.ParallelTempering
espressopp.ParallelTempering(NumberOfSystems, RNG)
Parameters
• NumberOfSystems (int) – (default: 4)
• RNG – (default: None)
espressopp.ParallelTempering.endDefiningSystem(n)
Parameters n –
Return type
142
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.ParallelTempering.exchange()
Return type
espressopp.ParallelTempering.getNumberOfCPUsPerSystem()
Return type
espressopp.ParallelTempering.getNumberOfSystems()
Return type
espressopp.ParallelTempering.run(nsteps)
Parameters nsteps –
Return type
espressopp.ParallelTempering.setAnalysisE(analysisE)
Parameters analysisE –
espressopp.ParallelTempering.setAnalysisNPart(analysisNPart)
Parameters analysisNPart –
espressopp.ParallelTempering.setAnalysisT(analysisT)
Parameters analysisT –
espressopp.ParallelTempering.setIntegrator(integrator, thermostat)
Parameters
• integrator –
• thermostat –
espressopp.ParallelTempering.startDefiningSystem(n)
Parameters n –
Return type
espressopp.Particle
espressopp.Particle(pid, storage)
Parameters
• pid –
• storage –
class espressopp.Particle.ParticleLocal(pid, storage)
The local particle.
Throws an exception: * when the particle does not exists locally
TODO: Should throw an exception: * when a ghost particle is to be written * when data is to be read from
a ghost that is not available
espressopp.ParticleAccess
Abstract base class for analysis/measurement/io
espressopp.ParticleAccess.perform_action()
Return type
3.9. espressopp
143
ESPResSo++ Documentation, Release latest
espressopp.ParticleGroup
espressopp.ParticleGroup(storage)
Parameters storage –
espressopp.ParticleGroup.add(pid)
Parameters pid –
Return type
espressopp.ParticleGroup.has(pid)
Parameters pid –
Return type
espressopp.ParticleGroup.show()
Return type
espressopp.ParticleGroup.size()
Return type
espressopp.pmi
Parallel Method Invocation (PMI) allows users to write serial Python scripts that use functions and classes that are
executed in parallel.
PMI is intended to be used in data-parallel environments, where several threads run in parallel and can communicate via MPI.
In PMI mode, a single thread of control (a python script that runs on the controller, i.e. the MPI root task) can
invoke arbitrary functions on all other threads (the workers) in parallel via call(), invoke() and reduce(). When the
function on the workers return, the control is returned to the controller.
This model is equivalent to the “Fork-Join execution model” used e.g. in OpenMP.
PMI also allows to create parallel instances of object classes via create(), i.e. instances that have a corresponding
object instance on all workers. call(), invoke() and reduce() can be used to call arbitrary methods of these instances.
to execute arbitrary code on all workers, exec_() can be used, and to import python modules to all workers, use
‘import_()’.
Main program
On the workers, the main program of a PMI script usually consists of a single call to the function startWorkerLoop(). On the workers, this will start an infinite loop on the workers that waits to receive the next PMI call,
while it will immediately return on the controller. On the workers, the loop ends only, when one of the commands
finalizeWorkers() or stopWorkerLoop() is issued on the controller. A typical PMI main program looks like this:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
144
# compute 2*factorial(42) in parallel
import pmi
# start the worker loop
# on the controller, this function returns immediately
pmi.startWorkerLoop()
# Do the parallel computation
pmi.import_('math')
pmi.reduce('lambda a,b: a+b', 'math.factorial', 42)
# exit all workers
pmi.finalizeWorkers()
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
Instead of using finalizeWorkers() at the end of the script, you can call registerAtExit() anywhere else, which will
cause finalizeWorkers() to be called when the python interpreter exits.
Alternatively, it is possible to use PMI in an SPMD-like fashion, where each call to a PMI command on the
controller must be accompanied by a corresponding call on the worker. This can be either a simple call to receive()
that accepts any PMI command, or a call to the identical PMI command. In that case, the arguments of the call to
the PMI command on the workers are ignored. In this way, it is possible to write SPMD scripts that profit from
the PMI communication patterns.
>>>
>>>
>>>
>>>
>>>
# compute 2*factorial(42) in parallel
import pmi
pmi.exec_('import math')
pmi.reduce('lambda a,b: a+b', 'math.factorial', 42)
To start the worker loop, the command startWorkerLoop() can be issued on the workers. To stop the worker loop,
stopWorkerLoop() can be issued on the controller, which will end the worker loop without exiting the workers.
Controller commands
These commands can be called in the controller script. When any of these commands is issued on a worker during
the worker loop, a UserError is raised.
• call(), invoke(), reduce() to call functions and methods in parallel
• create() to create parallel object instances
• exec_() and import_() to execute arbitrary python code in parallel and to import classes and functions into
the global namespace of pmi.
• sync() to make sure that all deleted PMI objects have been deleted.
• finalizeWorkers() to stop and exit all workers
• registerAtExit() to make sure that finalizeWorkers() is called when python exits on the controller
• stopWorkerLoop() to interrupt the worker loop an all workers and to return control to the single workers
Worker commands
These commands can be called on a worker.
• startWorkerLoop() to start the worker loop
• receive() to receive a single PMI command
• call(), invoke(), reduce(), create() and exec_() to receive a single corresponding PMI command. Note that
these commands will ignore any arguments when called on a worker.
PMI Proxy metaclass
The Proxy metaclass can be used to easily generate front-end classes to distributed PMI classes. . . .
Useful constants and variables
The pmi module defines the following useful constants and variables:
• isController is True when used on the controller, False otherwise
• isWorker = not isController
• ID is the rank of the MPI task
• CONTROLLER is the rank of the Controller (normally the MPI root)
• workerStr is a string describing the thread (‘Worker #’ or ‘Controller’)
• inWorkerLoop is True, if PMI currently executes the worker loop on the workers.
espressopp.pmi.exec_(*args)
Controller command that executes arbitrary python code on all (active) workers.
3.9. espressopp
145
ESPResSo++ Documentation, Release latest
exec_() allows to execute arbitrary Python code on all workers. It can be used to define classes and functions
on all workers. Modules should not be imported via exec_(), instead import_() should be used.
Each element of args should be string that is executed on all workers.
Example:
>>> pmi.exec_('import hello')
>>> hw = pmi.create('hello.HelloWorld')
espressopp.pmi.import_(*args)
Controller command that imports python modules on all (active) workers.
Each element of args should be a module name that is imported to all workers.
Example:
>>> pmi.import_('hello')
>>> hw = pmi.create('hello.HelloWorld')
espressopp.pmi.create(cls=None, *args, **kwds)
Controller command that creates an object on all workers.
cls describes the (new-style) class that should be instantiated. args are the arguments to the constructor of
the class. Only classes that are known to PMI can be used, that is, classes that have been imported to pmi
via exec_() or import_().
Example:
>>>
>>>
>>>
MPI
MPI
...
pmi.exec_('import hello')
hw = pmi.create('hello.HelloWorld')
print(hw)
process #0: Hello World!
process #1: Hello World!
Alternative: Note that in this case the class has to be imported to the calling module and via PMI.
>>>
>>>
>>>
>>>
MPI
MPI
...
import hello
pmi.exec_('import hello')
hw = pmi.create(hello.HelloWorld)
print(hw)
process #0: Hello World!
process #1: Hello World!
espressopp.pmi.call(*args, **kwds)
Call a function on all workers, returning only the return value on the controller.
function denotes the function that is to be called, args and kwds are the arguments to the function. If kwds
contains keys that start with with the prefix ‘__pmictr_’, they are stripped of the prefix and are passed only
to the controller. If the function should return any results, it will be locally returned. Only functions that are
known to PMI can be used, that is functions that have been imported to pmi via exec_() or import_().
Example:
>>>
>>>
>>>
>>>
>>>
pmi.exec_('import hello')
hw = pmi.create('hello.HelloWorld')
pmi.call(hw.hello)
# equivalent:
pmi.call('hello.HelloWorld', hw)
Note, that you can use only functions that are know to PMI when call() is called, i.e. functions in modules
that have been imported via exec_().
espressopp.pmi.invoke(*args, **kwds)
Invoke a function on all workers, gathering the return values into a list.
146
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
function denotes the function that is to be called, args and kwds are the arguments to the function. If kwds
contains keys that start with with the prefix ‘__pmictr_’, they are stripped of the prefix and are passed only
to the controller.
On the controller, invoke() returns the results of the different workers as a list. On the workers, invoke
returns None. Only functions that are known to PMI can be used, that is functions that have been imported
to pmi via exec_() or import_().
Example:
>>>
>>>
>>>
>>>
>>>
pmi.exec_('import hello')
hw = pmi.create('hello.HelloWorld')
messages = pmi.invoke(hw.hello())
# alternative:
messages = pmi.invoke('hello.HelloWorld.hello', hw)
espressopp.pmi.reduce(*args, **kwds)
Invoke a function on all workers, reducing the return values to a single value.
reduceOp is the (associative) operator that is used to process the return values, function denotes the function
that is to be called, args and kwds are the arguments to the function. If kwds contains keys that start with
with the prefix ‘__pmictr_’, they are stripped of the prefix and are passed only to the controller.
reduce() reduces the results of the different workers into a single value via the operation reduceOp. reduceOp is assumed to be associative. Both reduceOp and function have to be known to PMI, that is they
must have been imported to pmi via exec_() or import_().
Example:
>>>
>>>
>>>
>>>
>>>
>>>
...
...
...
pmi.exec_('import hello')
pmi.exec_('joinstr=lambda a,b: "\n".join(a,b)')
hw = pmi.create('hello.HelloWorld')
print(pmi.reduce('joinstr', hw.hello()))
# equivalent:
print(
pmi.reduce('lambda a,b: "\n".join(a,b)',
'hello.HelloWorld.hello', hw)
)
espressopp.pmi.sync()
Controller command that deletes the PMI objects on the workers that have already been deleted on the
controller.
espressopp.pmi.receive(expected=None)
Worker command that receives and handles the next PMI command.
This function waits to receive and handle a single PMI command. If expected is not None and the received
command does not equal expected, raise a UserError.
espressopp.pmi.startWorkerLoop()
Worker command that starts the main worker loop.
This function starts a loop that expects to receive PMI commands until stopWorkerLoop() or finalizeWorkers() is called on the controller.
espressopp.pmi.finalizeWorkers()
Controller command that stops and exits all workers.
espressopp.pmi.stopWorkerLoop(doExit=False)
Controller command that stops all workers.
If doExit is set, the workers exit afterwards.
espressopp.pmi.registerAtExit()
Controller command that registers the function finalizeWorkers() via atexit.
3.9. espressopp
147
ESPResSo++ Documentation, Release latest
class espressopp.pmi.Proxy(name, bases, dict)
A metaclass to be used to create frontend serial objects.
exception espressopp.pmi.UserError(msg)
Raised when PMI has encountered a user error.
espressopp.Quaternion
This class provides quaternions with the associate methods. Quaternions can be used as an efficient representation
for the orientation and rotation of 3D vector objects in 3D euclidean space. A Quaternion as such has a real part
and an imaginary part. For implementation purposes, the representation through one real scalar and one real 3D
vector is used here. The vector part is defined using the Real3D class of espressopp.
The format of a quaternion is “(real_part, unreal_part)” with the types “real” and “Real3D”, respectively.
While there are other possible applications for quaternions (rotation) in the simulation code, they will be used
at the C++-level in order to per- form the integration of the Euler equations of motion regarding the partic- les
angular motion, i.e. the rigid body dynamics.
Usage:
The following methods from C++-level are available at the python-level:
• getReal() return the scalar part of the quaternion
• setReal(real) sets the scalar part of the quaternion
• getImag() returns the vector part of the quaternion
• getImagItem(i) returns element i of vector part of the quaternion
• setImag(Real3D) sets the vector part of the quaternion
• setImagItem(i, real) sets element i of vector part of the quaternion
• sqr() the inner product of the quaternion
• abs() the absolute value of the quaternion
• normalize() normalizes the quaternion to unit length
• transpose() transposes the quaternion (changes sign of unreal_part)
The multiplication operator is overloaded in order to perform quaternion multiplication, see examples below.
Furthermore, it is possible to multi- ply a quaternion with a scalar, in order to rescale it.
Examples:
Initialize:
>>> espressopp.Quaternion()
Quaternion(0.0, Real3D(0.0, 0.0, 0.0))
>>> espressopp.Quaternion(0.0, 1.0, 2.0, 3.0)
Quaternion(1.0, Real3D(1.0, 2.0, 3.0))
>>> vec = espressopp.Real3D(1.0, 2.0, 3.0)
>>> Quaternion(vec)
Quaternion(0.0, Real3D(1.0, 2.0, 3.0))
>>> espressopp.Quaternion(1.0)
Quaternion(1.0, Real3D(0.0, 0.0, 0.0))
Get:
148
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
>>> q = espressopp.Quaternion(0.0, 1.0, 2.0, 3.0)
>>> q.getReal()
0.0
>>> q.getImag()
Real3D(1.0, 2.0, 3.0)
>>> q.getImagItem(0)
1.0
Set:
>>> q = espressopp.Quaternion(0.0, 0.0, 0.0, 0.0)
>>> q.setReal(1.0)
>>> vec = espressopp.Real3D(1.0, 2.0, 3.0)
>>> q.setImag(vec)
>>> q
Quaternion(1.0, Real3D(1.0, 2.0, 3.0))
>>> q.setImagItem(0, 0.0)
Quaternion(1.0, Real3D(0.0, 2.0, 3.0))
Transpose and normalize:
>>> q = Quaternion(0.0, 1.0, 2.0, 3.0)
>>> q.transpose()
Quaternion(0.0, Real3D(-1.0, -2.0, -3.0))
>>> q = Quaternion(0.0, 1.0, 2.0, 3.0)
>>> q.normalize()
Quaternion(0.0, Real3D(0.2672612419124244, 0.5345224838248488, 0.8017837257372732))
Inner product and absolute value:
>>> q = Quaternion(0.0, 1.0, 2.0, 3.0)
>>> q.sqr()
14.0
>>> q.abs()
3.7416573867739413
Quaternion multiplication (compare, e.g., wikipedia):
>>> p = Quaternion(0.0, 1.0, 2.0, 3.0)
>>> q = Quaternion(0.0, 1.0, 2.0, 3.0)
Quaternion(-14.0, Real3D(0.0, 0.0, 0.0))
espressopp.Quaternion.toQuaternion(*args)
Try to convert the arguments to a Quaternion, return the argument if it is already a Quaternion.
espressopp.Quaternion.toQuaternionFromVector(*args)
Try to convert the arguments to a Quaternion.
This function will only convert to a Quaternion if real_part, unreal_part[0], unreal_part[1] and unreal_part[2] are specified.
espressopp.Real3D
espressopp.__Real3D(*args)
Parameters *args –
espressopp.__Real3D.x(v, [0)
Parameters
• v–
• [0 –
Return type
3.9. espressopp
149
ESPResSo++ Documentation, Release latest
espressopp.__Real3D.y(v, [1)
Parameters
• v–
• [1 –
Return type
espressopp.__Real3D.z(v, [2)
Parameters
• v–
• [2 –
Return type
espressopp.toReal3DFromVector(*args)
Parameters *args –
espressopp.toReal3D(*args)
Parameters *args –
espressopp.Real3D.toReal3D(*args)
Try to convert the arguments to a Real3D, returns the argument, if it is already a Real3D.
espressopp.Real3D.toReal3DFromVector(*args)
Try to convert the arguments to a Real3D.
This function will only convert to a Real3D if x, y and z are specified.
espressopp.RealND
This is the object which represents N-dimensional vector. It is an extended Real3D, basicly, it hase the same
functionallity but in N-dimetions. First of all it is usefull for classes in ‘espressopp.analysis’.
Description
...
espressopp.__RealND(*args)
Parameters *args –
espressopp.toRealNDFromVector(*args)
Parameters *args –
espressopp.toRealND(*args)
Parameters *args –
espressopp.RealND.toRealND(*args)
Try to convert the arguments to a RealND, returns the argument, if it is already a RealND.
espressopp.RealND.toRealNDFromVector(*args)
Try to convert the arguments to a RealND.
This function will only convert to a RealND if x, y and z are specified.
150
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.System
The main purpose of this class is to store pointers to some important other classes and thus make them available to
C++. In a way the System class can be viewed as a container for system wide global variables. If you need to run
more than one system at the same time you can combine several systems with the help of the Multisystem class.
In detail the System class holds pointers to:
• the storage (e.g. DomainDecomposition)
• the boundary conditions bc for the system (e.g. OrthorhombicBC)
• a random number generator rng which is for example used by a thermostat
• the skin which is needed for the Verlet lists and the cell grid
• a list of short range interactions that apply to the system these interactions are added with the addInteraction() method of the System
Example (not complete):
>>>
>>>
>>>
>>>
>>>
LJSystem
= espressopp.System()
LJSystem.bc
= espressopp.bc.OrthorhombicBC(rng, boxsize)
LJSystem.rng
LJSystem.skin = 0.4
LJSystem.addInteraction(interLJ)
espressopp.System()
espressopp.System.addInteraction(interaction, name)
Parameters
• interaction –
• name (string) – The optional name of the interaction.
Return type bool
espressopp.System.getInteraction(number)
Parameters number –
Return type
espressopp.System.getNumberOfInteractions()
Return type
espressopp.System.removeInteraction(number)
Parameters number –
Return type
espressopp.System.removeInteractionByName(self, name)
Parameters name (str) – The name of the interaction to remove.
espressopp.System.getAllInteractions()
Return type The dictionary with name as a key and Interaction object.
espressopp.System.scaleVolume(*args)
Parameters *args –
Return type
espressopp.System.setTrace(switch)
Parameters switch –
3.9. espressopp
151
ESPResSo++ Documentation, Release latest
espressopp.Tensor
espressopp.Tensor.toTensor(*args)
Try to convert the arguments to a Tensor, returns the argument, if it is already a Tensor.
espressopp.Tensor.toTensorFromVector(*args)
Try to convert the arguments to a Tensor.
This function will only convert to a Tensor if x, y and z are specified.
espressopp.VerletList
espressopp.VerletList(system, cutoff, exclusionlist)
Parameters
• system –
• cutoff –
• exclusionlist – (default: [])
espressopp.VerletList.exclude(exclusionlist)
Parameters exclusionlist –
Return type
espressopp.VerletList.getAllPairs()
Return type
espressopp.VerletList.localSize()
Return type
espressopp.VerletList.totalSize()
Return type
espressopp.VerletListAdress
The VerletListAdress is the Verlet List to be used for AdResS or H-AdResS simulations. When creating the
VerletListAdress one has to provide the system and specify both cutoff for the CG interaction and adrcutoff for the
atomistic interaction. Often, it is important to set the atomistic adrcutoff much bigger than the actual interaction’s
cutoff would be, since also the atomistic part of the VerletListAdress (adrPairs) is built based on the coarse-grained
particle positions. For a much larger coarse-grained cutoff it is for example possible to also set the atomistic cutoff
on the same value as the coarse-grained one.
Furthermore, the sizes of the explicit and hybrid region have to be provided (dEx and dHy in the example below)
and the center of the atomistic region has to be set (adrCenter). Additionally, it can be chosen between a spherical
and a slab-like geometry (sphereAdr).
The AdResS region can also be defined based on one or more particles. For a single particle, in this case a spherical
region moves along with the particle. For many such region defining particles, the high-resolution/hybrid region
corresponds to the overlap of the different spherical regions based on the individual particles (for details see Kreis
et al., JCTC doi: 10.1021/acs.jctc.6b00440). Note that more region defining particles mean a higher computational
overhead as these particles need to be communicated among all processors (also see explanations in AdResS.py).
Also note that region defining particles should be normal/CG particles, not atomistic/AdResS ones.
Bascially the VerListAdress provides 4 lists:
• adrZone: A list which holds all particles in the atomistic and hybrid region
• cgZone: A list which holds all particles in the coarse-grained region
152
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• adrPairs: A list which holds all pairs which have at least one particle in the adrZone, i.e. in the atomistic or
hybrid region
• vlPairs: A list which holds all pairs which have both particles in the cgZone, i.e. in the coarse-grained
region
Example - creating the VerletListAdress for a slab-type adress region fixed in space (only the x value of adrCenter
is used):
>>> vl
= espressopp.VerletListAdress(system, cutoff=rc, adrcut=rc, dEx=ex_size, dHy=hy_size,
or
>>> vl
= espressopp.VerletListAdress(system, cutoff=rc, adrcut=rc, dEx=ex_size, dHy=hy_size,
Example - creating the VerletListAdress for a spherical adress region centered on adrCenter and fixed in space:
>>> vl
= espressopp.VerletListAdress(system, cutoff=rc, adrcut=rc, dEx=ex_size, dHy=hy_size,
Example - creating the VerletListAdress for a spherical adress region centered on one particle and moving with
the particle
>>> vl
= espressopp.VerletListAdress(system, cutoff=rc, adrcut=rc, dEx=ex_size, dHy=hy_size,
Example - creating the VerletListAdress for a adress region based on the overlapping spherical regions by several
particles
>>> vl
= espressopp.VerletListAdress(system, cutoff=rc, adrcut=rc, dEx=ex_size, dHy=hy_size,
espressopp.VerletListAdress(system, cutoff, adrcut, dEx, dHy, adrCenter, pids, exclusionlist,
sphereAdr)
Parameters
• system –
• cutoff –
• adrcut –
• dEx –
• dHy –
• adrCenter – (default: [])
• pids – (default: [])
• exclusionlist – (default: [])
• sphereAdr – (default: False)
espressopp.VerletListAdress.addAdrParticles(pids, rebuild)
Parameters
• pids –
• rebuild – (default: True)
Return type
espressopp.VerletListAdress.exclude(exclusionlist)
Parameters exclusionlist –
Return type
espressopp.VerletListAdress.rebuild()
Return type
espressopp.VerletListAdress.totalSize()
3.9. espressopp
153
ESPResSo++ Documentation, Release latest
Return type
espressopp.VerletListTriple
espressopp.VerletListTriple(system, cutoff, exclusionlist)
Parameters
• system –
• cutoff –
• exclusionlist – (default: [])
espressopp.VerletListTriple.exclude(exclusionlist)
Parameters exclusionlist –
Return type
espressopp.VerletListTriple.getAllTriples()
Return type
espressopp.VerletListTriple.localSize()
Return type
espressopp.VerletListTriple.totalSize()
Return type
espressopp.Version
Return version information of espressopp module
Example:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
version
= espressopp.Version()
print "Name
= ", version.name
print "Major version number
= ", version.major
print "Minor version number
= ", version.minor
print "Git revision = ", version.gitrevision
print "boost version
= ", version.boostversion
print "Patchlevel
= ", version.patchlevel
print "Compilation date
= ", version.date
print "Compilation time
= ", version.time
to print a full version info string:
>>> print version.info()
espressopp.Version()
standard_system
espressopp.standard_system.Default
espressopp.standard_system.Default(box, rc = 1.12246, skin = 0.3, dt = 0.005, temperature
= None)
Parameters
• box –
154
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• rc (real) –
• skin (real) –
• dt (real) –
• temperature –
Return default system and integrator, no interactions, no particles are set if tempearture is != None then
Langevin thermostat is set to temperature (gamma is 1.0)
espressopp.standard_system.KGMelt
espressopp.standard_system.KGMelt(num_chains, chain_len)
Parameters
• num_chains –
• chain_len –
espressopp.standard_system.LennardJones
espressopp.standard_system.LennardJones(num_particles, box, rc, skin, dt, epsilon, sigma,
shift, temperature, xyzfilename, xyzrfilename)
Parameters
• num_particles –
• box – (default: (000))
• rc (real) – (default: 1.12246)
• skin (real) – (default: 0.3)
• dt (real) – (default: 0.005)
• epsilon (real) – (default: 1.0)
• sigma (real) – (default: 1.0)
• shift – (default: ‘auto’)
• temperature – (default: None)
• xyzfilename – (default: None)
• xyzrfilename – (default: None)
return random Lennard Jones system and integrator: if tempearture is != None then Langevin thermostat is
set to temperature (gamma is 1.0)
espressopp.standard_system.Minimal
espressopp.standard_system.Minimal(num_particles, box, rc, skin, dt, temperature)
Parameters
• num_particles –
• box –
• rc (real) – (default: 1.12246)
• skin (real) – (default: 0.3)
• dt (real) – (default: 0.005)
3.10. standard_system
155
ESPResSo++ Documentation, Release latest
• temperature – (default: None)
Return minimal system and integrator whithout any interactions defined: particles have random positions in
box if tempearture is != None then Langevin thermostat is set to temperature (gamma is 1.0)
espressopp.standard_system.PolymerMelt
espressopp.standard_system.PolymerMelt(num_chains,
monomers_per_chain,
box,
bondlen, rc, skin, dt, epsilon, sigma, shift,
temperature, xyzfilename, xyzrfilename)
Parameters
• num_chains –
• monomers_per_chain –
• box – (default: (000))
• bondlen (real) – (default: 0.97)
• rc (real) – (default: 1.12246)
• skin (real) – (default: 0.3)
• dt (real) – (default: 0.005)
• epsilon (real) – (default: 1.0)
• sigma (real) – (default: 1.0)
• shift – (default: ‘auto’)
• temperature – (default: None)
• xyzfilename – (default: None)
• xyzrfilename – (default: None)
returns random walk polymer melt system and integrator: if tempearture is != None then Langevin thermostat is set to temperature (gamma is 1.0)
storage
espressopp.storage.DomainDecomposition
espressopp.storage.DomainDecomposition(system, nodeGrid, cellGrid)
Parameters
• system –
• nodeGrid –
• cellGrid –
espressopp.storage.DomainDecomposition.getCellGrid()
Return type
espressopp.storage.DomainDecomposition.getNodeGrid()
Return type
156
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.storage.DomainDecompositionAdress
The DomainDecompositionAdress is the Domain Decomposition for AdResS and H- AdResS simulations. It
makes sure that tuples (i.e. a coarse-grained particle and its corresponding atomistic particles) are always stored
together on one CPU. When setting DomainDecompositionAdress you have to provide the system as well as the
nodegrid and the cellgrid.
Example - setting DomainDecompositionAdress:
>>> system.storage = espressopp.storage.DomainDecompositionAdress(system, nodeGrid, cellGrid)
espressopp.storage.DomainDecompositionAdress(system, nodeGrid, cellGrid)
Parameters
• system –
• nodeGrid –
• cellGrid –
espressopp.storage.DomainDecompositionNonBlocking
espressopp.storage.DomainDecompositionNonBlocking(system, nodeGrid, cellGrid)
Parameters
• system –
• nodeGrid –
• cellGrid –
espressopp.storage.Storage
This is the base class for all storage objects. All derived classes implement at least the following methods:
• decompose()
Send all particles to their corresponding cell/cpu
• addParticle(pid, pos):
Add a particle to the storage
• removeParticle(pid):
Remove a particle with id number pid from the storage.
>>> system.storage.removeParticle(4)
There is an example in examples folder
• getParticle(pid):
Get a particle object. This can be used to get specific particle information:
>>> particle = system.storage.getParticle(15)
>>> print "Particle ID is
: ", particle.id
>>> print "Particle position is : ", particle.pos
you cannot use this particle object to modify particle data. You have to use the modifyParticle
command for that (see below).
• addAdrParticle(pid, pos, last_pos):
Add an AdResS Particle to the storage
3.11. storage
157
ESPResSo++ Documentation, Release latest
• setFixedTuplesAdress(fixed_tuple_list):
• addParticles(particle_list, *properties):
This routine adds particles with certain properties to the storage.
param particleList list of particles (and properties) to be added
param properties property strings
Each particle in the list must be itself a list where each entry corresponds to the property specified
in properties.
Example:
>>> addParticles([[id, pos, type, ... ], ...], 'id', 'pos', 'type', ...)
• modifyParticle(pid, property, value, decompose=’yes’)
This routine allows to modify any properties of an already existing particle.
Example:
>>> modifyParticle(pid, 'pos', Real3D(new_x, new_y, new_z))
• removeAllParticles():
This routine removes all particles from the storage.
• ‘system’:
The property ‘system’ returns the System object of the storage.
Examples:
>>> s.storage.addParticles([[1, espressopp.Real3D(3,3,3)], [2, espressopp.Real3D(4,4,4)]],'id','po
>>> s.storage.decompose()
>>> s.storage.modifyParticle(15, 'pos', Real3D(new_x, new_y, new_z))
espressopp.storage.Storage.addAdrATParticle(pid, *args)
Parameters
• pid –
• *args –
Return type
espressopp.storage.Storage.addParticle(pid, pos)
Parameters
• pid –
• pos –
Return type
espressopp.storage.Storage.addParticles(particleList, *properties)
Parameters
• particleList –
• *properties –
Return type
espressopp.storage.Storage.clearSavedPositions()
Return type
espressopp.storage.Storage.getParticle(pid)
158
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
Parameters pid –
Return type
espressopp.storage.Storage.getRealParticleIDs()
Return type
espressopp.storage.Storage.modifyParticle(pid, property, value)
Parameters
• pid –
• property –
• value –
Return type
espressopp.storage.Storage.particleExists(pid)
Parameters pid –
Return type
espressopp.storage.Storage.printRealParticles()
Return type
espressopp.storage.Storage.removeAllParticles()
Return type
espressopp.storage.Storage.removeParticle(pid)
Parameters pid –
Return type
espressopp.storage.Storage.restorePositions()
Return type
espressopp.storage.Storage.savePositions(idList)
Parameters idList –
Return type
espressopp.storage.Storage.setFixedTuplesAdress(fixedtuples)
Parameters fixedtuples –
tools
information and analysis
Overview
espressopp.tools.analyse
espressopp.tools.info
espressopp.tools.timers
espressopp.tools.vmd
Details
3.12. tools
159
ESPResSo++ Documentation, Release latest
espressopp.tools.analyse
espressopp.tools.analyse.final_info(system, integrator, vl, start_time, end_time)
final report on the simulation statistics
espressopp.tools.analyse.info(system, integrator, per_atom=False)
reports on the simulation progress
espressopp.tools.info
espressopp.tools.info.getAllBonds(system)
return all bonds of the system (currently only FixedPairLists are supported)
espressopp.tools.info.getAllParticles(system, *properties)
returns a list of all particle properties of all particles of the system (currently no atomistic AdResS particles
are included)
espressopp.tools.timers
espressopp.tools.timers.show(alltimers, precision=1)
Python functions to print timings from C++.
espressopp.tools.vmd
espressopp.tools.vmd.connect(system, molsize=10, pqrfile=False, vmd_path=’vmd’)
Connects to the VMD.
Parameters
• system (espressopp.system) – The system object.
• molsize (int) – The optional size of the molecule.
• pqrfile (bool) – If set to True then the pqr vmd.pqr file will be used otherwise
(default) the vmd.pdb file will be used.
• vmd_path (str) – The path to the executable of vmd, by default it is set to ‘vmd’.
Returns Socket to the VMD.
initializing particles
Overview
espressopp.tools.lattice
espressopp.tools.replicate(bonds, angles, x, ...)
espressopp.tools.topology
espressopp.tools.velocities
espressopp.tools.warmup(system, integrator)
Replicates configuration in each dimension.
Warm up for a system with a density of 0.85.
Details
espressopp.tools.lattice
espressopp.tools.lattice.createCubic(N, rho, perfect=True, RNG=None)
Initializes particles on the sites of a simple cubic lattice. By setting perfect=False the particle positions
will be given random displacements with a magnitude of one-tenth the lattice spacing.
160
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
espressopp.tools.lattice.createDiamond(N, rho, perfect=True, RNG=None)
Initializes particles on the sites of a diamond lattice.
espressopp.tools.replicate
espressopp.tools.replicate.replicate(bonds, angles, x, y, z, Lx, Ly, Lz, xdim=1, ydim=1,
zdim=1)
Replicates configuration in each dimension.
This may be used to increase the size of an equilibrated melt by a factor of 8 or more.
Presently this routine works only for semiflexible polymers. A general class should be written to deal with
files containing coordinates and topology data.
xdim = ydim = zdim = 1 returns the original system not replicated. xdim = ydim = zdim = 2 returns the
original system replicated to 8x. xdim = ydim = zdim = 3 returns the original system replicated to 27x.
xdim = ydim = 1, zdim = 2 returns the original system replicated in the z-direction.
espressopp.tools.topology
espressopp.tools.topology.polymerRW(pid, startpos, numberOfMonomers, bondlength,
return_angles=False,
return_dihedrals=False,
mindist=None, rng=None)
Initializes polymers through random walk
espressopp.tools.velocities
espressopp.tools.velocities.gaussian(T, N, particle_mass=None, zero_momentum=True,
seed=7654321, kb=1.0)
Generates velocities with temperature T according to a Maxwell-Boltzmann distribution.
Args: T: The desired temperature expre. N: The number of particles. particle_mass: The list of particle
mass if not then every particle has mass 1.0 zero_momentum: Remove the center-of-mass motion.
seed: The seed for the random number generator. kb: The Boltzmann constant.
Returns: The tuple with lists of x,y,z components of the velocity.
espressopp.tools.warmup
espressopp.tools.warmup.warmup(system, integrator, number=80)
Warm up for a system with a density of 0.85.
The method needs the following parameters:
•system, integrator ESPResSo system which schoul be warmed up and the correspondig integrator e.g.:
>>> system, integrator = espressopp.standard_system.LennardJones(100,(10,10,10))
•number number of steps of the warm up
for a system with a density of 0.85, if it explodes try a higher number
decomp - Domain Decomposition python functions
• nodeGrid(n,box_size,rc,skin,eh_size=0,ratioMS=0,idealGas=0,slabMSDims=[0,0,0]):
It determines how the processors are distributed and how the cells are arranged. The algorithm is dimensional sensitive for both homogeneous and inhomogeneous setups. On top of
such functionality it presents specific features for region divided heterogenous setups (e.g. for
3.12. tools
161
ESPResSo++ Documentation, Release latest
AdResS) [see H.V. Guzman et. al, Phys. Rev. E, 96, 053311 (2017)] Link to the paper:
https://doi.org/10.1103/PhysRevE.96.053311
box_size - 3D vector cointainig the size of the simulation box box_size [L_x,L_y,L_z] rc - cutoff
radius of interaction skin - skin size for the verlet list calculation n - total number of processes
eh_size - 1D length of the high-resolution region (e.g. for AdResS Atomistic/Explicit+Hybrid
regions) ratioMS - spatial mapping ratio between high-resolution region and the low-resolution
one
(e.g. for AdResS mapping the atomistic water molecule to the CG-model; leads to a
ratioMS=3)
idealGas - this is a Flag for treating the low-resolution region as an Ideal Gas, when TRUE (no interactions includ
thus none force computations load)
slabMSDims - 3D vector cointainig flags describing the type of axis, if heterogeneous value is 1,
else 0
• nodeGridSimple(n): It determines how the processors are distributed and how the cells are arranged. Note:
Use it exclusively for Lattice-Boltzmann simulations, or non-parallelized tests. n - number of processes
• cherrypickTotalProcs(box_size,rc,skin,MnN,CpN,percTol=0.2,eh_size=0,ratioMS=0,idealGas=0,slabMSDims=[0,0,0]):
To be used for heterogenous simulations where the spatial heterogeinity is known on an a-priori
manner, where this function returns n as the total number of processes to be used for the best
decomposition of the system as a function of a tolerance ratio which depending on the giving
range [0, MnN*CpN] of processors availability different combinations of P_x,P_y and P_z can
be found and hence several values of n this ‘n’ can become an array. Most of the parameters have
been described for nodeGrid(...), except:
MnN - M number of Nodes to be available (e.g. 128 processes/cores, 16 cores per Node gives a
total of 8 Nodes) CpN - C number of Cores available in each Node (e.g. 16 Cores per Node or 20
Cores per Node) percTol - Axis base tolerance percentage to the ideal distribution of P-processors
per axes P_x,P_y,P_z
• neiListHom(node_grid,box,rc,skin):
The new domain decomposition divides the subdomains in a neighborlist of corse in a grid of 3
arrays [N_x,N_y,N_z]. In this case, the neighbor list is homogeneous (non a-priori load imbalance). Most of the parameters have been described above, except:
node_grid - M number of Nodes to be available (e.g. 128 processes/cores, 16 cores per Node
gives a total of 8 Nodes)
• neiListAdress(node_grid, cell_grid,rc,skin,eh_size,adrCenter,ratioMS,idealGasFlag=True,sphereAdr=False,slabMSDims=[1
The new domain decomposition divides the subdomains in a neighborlist of corse in a grid of 3
arrays [N_x,N_y,N_z]. In this case, the neighbor list is homogeneous (non a-priori load imbalance). Most of the parameters have been described above, except:
cell_grid - Based on the homogenous allocation of cells per subdomain, a referential value adrCenter - Box center of the heterogeneous simulation box [adrCenter_x,adrCenter_y,adrCenter_z], commonly the middle of
high-resolution region.
idealGasFlag - This is a Flag for treating the low-resolution region as an Ideal Gas (no interactions included,
thus less load)
sphereAdr - Geometry of the high-resolution region, if TRUE spherical, otherwise Slab-like
• cellGrid(box_size, node_grid, rc, skin):
It returns an appropriate grid of cells.
• tuneSkin(system, integrator, minSkin=0.01, maxSkin=1.2, precision=0.001):
It tunes the skin size for the current system
162
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
• printTimeVsSkin(system, integrator, minSkin=0.01, maxSkin=1.5, skinStep = 0.01):
It prints time of running versus skin size in the range [minSkin, maxSkin] with the step skinStep
DumpConfigurations - read/write xyz files
espressopp.tools.DumpConfigurations.fastreadxyz(filename)
espressopp.tools.DumpConfigurations.fastwritexyz(filename,
system,
velocities=True,
unfolded=True,
append=False, scale=1.0)
espressopp.tools.DumpConfigurations.fastwritexyz_standard(filename, system,
unfolded=False,
append=False)
Fast write standard xyz file. Generally standard xyz file is
>>>
>>>
>>>
>>>
>>>
>>>
number of particles
comment line
type x y z
......
......
......
Additional information can be found here: Wiki: http://en.wikipedia.org/wiki/XYZ_file_format OpenBabel: http://openbabel.org/wiki/XYZ_%28format%29
In this case one can choose folded or unfolded coordinates. Currently it writes only particle type = 0 and
pid is a line number. Later different types should be implemented.
espressopp.tools.DumpConfigurations.readxyz(filename)
espressopp.tools.DumpConfigurations.readxyzr(filename)
espressopp.tools.DumpConfigurations.writexyz(filename, system, velocities=True, unfolded=False, append=False)
espressopp.tools.DumpConfigurations.xyzfilewrite(filename, system, append=False,
atomtypes={0: ‘Fe’, 1: ‘O’,
2:
‘C’}, velocities=False,
charge=False)
This method creates a xyz file with the data from a specific system: 1. row: number of the atoms 2.
row: REMARK generated by ESPResSo++ following rows: atomsymbol positionX positionY positionZ
(velocityX velocityY velocityZ) (charge) last row: END
The method needs the following parameters:
•filename
name of the file where the table schould be saved in
•system
ESPResSo system which creates the data e.g.:
>>> system, integrator = espressopp.standard_system.LennardJones(100,(10,10,10))
•append
=False the data in the file will be overwritten
=True the data will be appended
•atomtypes the xyz file needs atom symbols, so it has to translate the numbers insert a dictionary with
the right translation
•velocities
=False does not save the velocity vectors
3.12. tools
163
ESPResSo++ Documentation, Release latest
=True creates collumns for the velocity vectors and saves the data
•charge
=False does not save the charge
=True creates collumns for the charges and saves the data
espresso_old - read espressomd files
This Python module allows one to use ESPResSo data files as the input to an ESPResSo++ simulation.
espressopp.tools.espresso_old.read(file)
Read ESPResSo data files.
Keyword argument: file – contains simulation variables, data of all particles, and information about bonds.
(angles and dihedrals are currently not read)
gromacs - parser for Gromacs files
This Python module allows one to use GROMACS data files as the input to an ESPResSo++ simulation, set
interactions for given particle types and convert GROMACS potential tables into ESPResSo++ tables. It containts
functions: read(), setInteractions(), convertTable()
Some tips for using the gromacs parser:
Tip 1.
topol.top includes solvent via #include statements
If the included .itp file ONLY contains the solvent molecule you’re using (e.g. spc/e water using spce.itp) then
this is okay.
But if the .itp file contains info about many molecules (e.g. you want to use one ion from ions.itp), then gromacs.py
will just take the first one listed. You must edit your topol.top file to explicitly include the solvent molecule you’re
using.
e.g. replace:
; Include topology for ions
#include "amber03.ff/ions.itp"
by:
; Include topology for ions
[ moleculetype ]
; molname
nrexcl
CL
1
[ atoms ]
; id
at type
1
Cl
res nr
1
residu name
CL
at name
CL
cg nr
1
charge
-1.00000
Tip 2. impropers
impropers in the topol.top file (function type 4) need to be labelled ‘[ impropers ]’, not ‘[ dihedrals ]’ as in standard
gromacs format”
Also, the dihedrals should be listed before the impropers (this is usuall the case by default in gromacs-format
files).
Tip 3.
For rigid SPC/E water using Settle, spce.itp file should look like this:
164
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
[ moleculetype ]
; molname
nrexcl
SOL
2
[ atoms ]
; id at type
1
OW_spc
2
HW_spc
3
HW_spc
res nr
1
1
1
res name
SOL
SOL
SOL
at name
OW
HW1
HW2
[ bonds ]
; i
j
1
2
1
3
funct
1
1
length
0.1
0.1
force.c.
345000 0.1
345000 0.1
[ angles ]
; i
j
2
1
k
3
funct
1
angle
109.47
cg nr
1
1
1
charge
-0.8476
0.4238
0.4238
mass
15.99940
1.00800
1.00800
345000
345000
force.c.
383
109.47
383
The bonds section is used to generate exclusions, but bond and angle parameters are not relevant if the Settle
extension is used. The geometry is that specified in the python script when adding the Settle extension
Include modified spce file in topol.top, e.g. replace
#include “amber03.ff/spce.itp”
by
#include “amber03.ff/spce-for-espressopp.itp”
Tip 4.
Use absolute paths for any include files which are not in the standard gromacs topology directory ($GMXLIB)
e.g. replace
#include “mynewresidue.itp”
by
#include “path/to/mynewres/file/mynewresidue.itp”
Tip 5.
The parser won’t work if the particles ids in the include files conflict with the particle ids in the topol.top file itself,
and the bonded interaction parameters in the itp file need to be looked up via particle type in the standard gromacs
topology directory ($GMXLIB)
i.e. Okay for an itp file like spce.itp above, where the bonds and angles parameters are given in the itp file, as in:
[ bonds ]
; i
j
1
2
funct
1
length
0.1
force.c.
345000 0.1
345000
Not okay for an itp file containing lines like:
[ bonds ]
; i
j
1
2
funct
1
length
force.c.
espressopp.tools.gromacs.convertTable(gro_in_file, esp_out_file, sigma=1.0, epsilon=1.0,
c6=1.0, c12=1.0)
Convert GROMACS tabulated file into ESPResSo++ tabulated file (new file is created). First column of
input file can be either distance or angle. For non-bonded files, c6 and c12 can be provided. Default value
for sigma, epsilon, c6 and c12 is 1.0. Electrostatics are not taken into account (f and fd columns).
3.12. tools
165
ESPResSo++ Documentation, Release latest
Keyword arguments: gro_in_file – the GROMACS tabulated file name (bonded, nonbonded, angle or dihedral). esp_out_file – filename of the ESPResSo++ tabulated file to be written. sigma – optional, depending
on whether you want to convert units or not. epsilon – optional, depending on whether you want to convert
units or not. c6 – optional c12 – optional
espressopp.tools.gromacs.read(gro_file, top_file=’‘, doRegularExcl=True)
Read GROMACS data files.
Arguments: :param gro_file: – contains coordinates of all particles, the number of particles, velocities
and box size. :type gro_file: string :param top_file: – contains topology information. Included topology
files (.itp) are also read :type gro_file: string :param doRegularExcl: – if True, exclusions are generated
automatically based on the nregxcl parameter (see gromacs manual) :type doRegularExcl: bool
espressopp.tools.gromacs.setLennardJones14Interactions(system, defaults, atomtypeparams, onefourlist,
cutoff )
Set lennard jones interactions which were read from gromacs based on the atomypes
espressopp.tools.gromacs.setLennardJonesInteractions(system, defaults, atomtypeparams,
verletlist,
cutoff,
hadress=False,
adress=False, ftpl=None)
Set lennard jones interactions which were read from gromacs based on the atomypes
espressopp.tools.gromacs.setLennardJonesInteractionsTI(system, defaults, atomtypeparams, verletlist,
cutoff, epsilonB, sigmaSC, alphaSC, powerSC, lambdaTI, pidlist,
annihilate=True,
hadress=False,
adress=False,
ftpl=None)
Set lennard jones interactions which were read from gromacs based on the atomypes
espressopp.tools.gromacs.setTabulatedInteractions(potentials, particleTypes, system, interaction)
Set interactions for all given particle types. Return value is a system with all interactions added.
Keyword arguments: potentials – is a dictionary where key is a string composed of two particle types
and value is a potential. example: {“A_A”:potAA, “A_B”:potAB, “B_B”:potBB} particleTypes – is a
dictionary where key is the particle type, and value is a list of particles of that type. example: {“A”:[”A1m”,
“A2m”],”B”:[”B1u”,”B2u”]} system – is the system to which the interaction will be added interaction – is
the interaction to which to add the potentials
io_extended - read/write configurational files
This Python module allows one to read and write configurational files. One can choose folded or unfolded coordinates and write down velocities or not. It is similar to lammps read and write, but it writes down only: 1) number
of particles + types 2) number of bonds (number of pairs) + types 3) number of angles (number of triples) + types
4) number of dihedrals (number of quadruples) + types 5) system size (Lx,Ly,Lz) 6) p_id, p_type, p_positions 7)
velocities (if true) 8) bonds (if exist) 9) angles (if exist) 10)dihedrals (if exist)
read returns: Lx, Ly, Lz, p_ids, p_types, poss, vels, bonds, angles, dihedrals if something does not exist then it
will return the empty list bonds, angles, dihedrals - will return list [type, (x,x,x,x)], where type is the type of bond,
angle or dihedral (x,x,x,x) is (pid1,pid2) for bonds,
(pid1,pid2,pid3) for angles
(pid1,pid2,pid3,pid4) for dihedrals
166
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
lammps - read lammps files
This Python module allows one to use a LAMMPS data file as the input to an ESPResSo++ simulation.
pathintegral - nuclear quantum effects
• method to automatically run the system including nuclear quantum effects using the Feynman path-integral
!!WARNING: THIS IS STILL AN EXPERIMENTAL FEATURE!!
This method creates, based on the supplied topology of the system, an path-integral representation with P beads.
The path-integral system is a fully classical analog, which has to be run at an effective temperature P*T.
The method needs the following parameters:
• allParticles particles of the sytem
• props particle properties
• types types, e.g. read from the gromacs parser
• system
• exclusions non-bonded exclusions
• integrator
• langevin langevin integrator
• rcut the cutoff used for the rings non-bonded interactions
• P the Trotter Number (number of imaginary time slices)
• polymerInitR polymer radius for setting up ring in 2d plane
• hbar hbar in gromacs units [kJ/mol ps]
• disableVVl disable Virtual Verlet List (slow but safe). If false, the neighbour search is based on the VirtualParticles extension, which contain the rings. This speeds up neighbour search significantly.
PDB - read and write pdb format
espressopp.tools.pdbwrite(filename, system, molsize=4, append=False, typenames=None)
Writes a file in PDB format
Parameters
• filename (string) – output file name
• system (espressopp System object) – espressopp system
• molsize (int) – if molsize>0, the molecule count is increased every molsize particles
(default 4)
• append (bool) – if True, append to filename, other over-write filename (default False)
• typenames (dict, key=int, value=string) – dictionary used for mapping
from espressopp’s integer particle types to the particle type strings written in a pdb file
espressopp.tools.pdbread(filename, natoms, header)
Reads one frame of a pdb format file
Parameters
• filename (string) – input file name
• natoms (int) – number of atoms in pdf file
• header (int) – number of header lines to skip at start of file
3.12. tools
167
ESPResSo++ Documentation, Release latest
Returns:
index,atomname,resname,resid,x,y,z,alpha,beta,segid,element
int,str,str,int,float,float,float,float,float,str,str)
(lists
of
type
povwrite - write povray files
prepareComplexMolecules - set up proteins
various helper functions for setting up systems containing complex molecules such as proteins
espressopp.tools.findConstrainedBonds(atomPids, bondtypes, bondtypeparams, masses,
massCutoff = 1.1)
Finds all heavyatom-hydrogen bonds in a given list of particle IDs, and outputs a list describing the bonds,
in a format suitable for use with the RATTLE algorithm for constrained bonds
Parameters
• atomPids (list of int) – list of pids of atoms between which to search for bonds
• bondtypes (dict, key: (int,int), value: int) – dictionary mapping from tuple of pids to bondtypeid, e.g. as returned by tools.gromacs.read()
• bondtypeparams
(dict, key: int, value: espressopp bond
type) – dictionary mapping from bondtypeid to class storing parameters of that bond
type, e.g. as returned by tools.gromacs.read()
• masses (list of float) – list of masses, e.g. as returned by tools.gromacs.read()
• massCutoff (float) – for identifying light atoms (hydrogens), default 1.1 mass
units, can also be increased e.g. for use with deuterated systems
Returns
hydrogenIDs - list of pids (integer) of light atoms (hydrogens)
constrainedBondsDict - dict, keys: pid (integer) of heavy atom, values: list of pids of light
atoms that are bonded to it
constrainedBondsList - list of lists, one entry for each constrained bond with format: [pid
of heavy atom, pid of light atom, bond distance, mass of heavy atom ,mass of light atom]
Can then be used with RATTLE, e.g.
>>> rattle = espressopp.integrator.Rattle(system, maxit = 1000, tol = 1e-6, rptol = 1e-6)
>>> rattle.addConstrainedBonds(constrainedBondsList)
>>> integrator.addExtension(rattle)
espressopp.tools.getInternalNonbondedInteractions(atExclusions, pidlist)
Gets the non-bonded pairs within a list of particle indices, excluding those which are in a supplied list of
exclusions. Useful for example for getting the internal atomistic non-bonded interactions in a coarse-grained
particle and adding them as a fixedpairlist
Parameters
• atExclusions (list of 2-tuples of int) – list of excluded pairs
• pidlist (list of int) – list of pids among which to create pairs
Returns list of pairs which are not in atExclusions
Return type list of 2-tuples of int
espressopp.tools.readSimpleSystem(filename, nparticles, header)
Read in a column-formatted file containing information about the particles in a simple system, for example
a coarsegrained protein.
168
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
This function expects the input file to have between 2 and 5 columns. The number of columns in the file is
automatically detected. The function reads each column into a list and returns the lists. Column types are
interpreted as follows: 2 columns: float, float 3 columns: float, float, int 4 columns: float, float, int, str 5
columns: float, float, int, str, str
For example in the case of a coarsegrained protein model, these could be: mass, charge, corresponding
atomistic index, beadname, beadtype
Parameters
• filename (string) – name of file to open and read
• nparticles (int) – number of particles in file
• header (int) – number of lines to skip at start of file (default 0)
Returns: between 2 and 5 lists
espressopp.tools.applyBoreschRestraints(system,
restraintAtoms,
restraintK, restraintR0)
Applies restraints between ligand and protein as defined in Boresch et al, JPCB 2003, 107, 9535-9551 The
restraints (one bond, two angles and three dihedrals) are applied between three ligand atoms A,B,C and
three protein atoms a,b,c.
In espressopp, the potential for harmonic bond and angles is k(x-x0)^2, but the harmonic dihedral potential
is 0.5*k(x-x0)^2. This is taken care of in this function, i.e. the user should supply the force constants exactly
as given in Boresch et al.
Parameters
• system (System object) – espressopp system
• restraintAtoms (python dictionary) – dictionary identifying the six atoms
involved in the restraints, key = atom label (one of ‘A’,’B’,’C’,’a’,’b’,’c’), value = atom
index
• restraintK (python dictionary) – dictionary of force constants, key = restraint label (‘aA’ for the bond, ‘baA’ and ‘aAB’ for the angles, ‘aABC’, ‘cbaA’ and
‘baAB’ for the dihedrals), value = force constant (units as for the simulation forcefield,
angle and dihedral constants should be in rad^-2)
• restraintR0 (python dictionary) – dictionary of equilibrium values (distance or angle), key = restraint label, value = distance (in distance units) or angle (in
degrees)
Examples of the three dictionaries:
>>> restraintAtoms = {'A':1981,'B':1966,'C':1993,'a':1588,'b':1581,'c':1567}
>>> restraintK = {'aA':4184,'baA':41.84,'aAB':41.84,'aABC':41.84,'cbaA':41.84,'baAB':41.84} #
>>> restraintR0 = {'aA':0.31,'baA':120.0,'aAB':90.0,'aABC':100.0,'cbaA':-170.0,'baAB':-105.0}
prepareAdress - setup AdResS simulation
Auxiliary python functions for preparation of an Adress Simulation based on a configuration from an all-atomistic
simulation.
If one uses a configuration file from an all-atomistic simulation as start configuration for an AdResS simulation, the
particles are probably all located inside the simulation box. However, in AdResS only the coarse-grained centerof-mass particles have to be in the box, the atomistic particles of the coarse grained might be outside around their
CoM CG particle. When in the start configuration atomistic particles belonging to a molecule are folded such that
some of the atoms are on the one side of the box while the others are folded to the other side the calculation of
the center of mass goes wrong and the simulation will be incorrect. This script ensures a proper center of mass
calculation and a proper folding and configuration for the AdResS simulation by simply putting the CG particle in
one of the atoms (AdressSetCG) first. Then the molecules will be put together properly afterwards when calling
AdressDecomp.
3.12. tools
169
ESPResSo++ Documentation, Release latest
PSF - read and write psf format
PSF file format given at http://www.ks.uiuc.edu/Training/Tutorials/namd/namd-tutorial-win-html/node24.html
espressopp.tools.psfwrite(filename, system, maxdist=None, molsize=4, typenames=None)
Writes !NATOM and !NBOND sections of a psf format file
Parameters
• filename (string) – output file name
• system (espressopp System object) – espressopp system
• maxdist (float) – if this is specified, only bonds in which the pair of particles are
separated by a distance < maxdist are written to the !NBOND section
• molsize (int) – if molsize>0, the molecule count is increased every molsize particles
• typenames (dict, key=int, value=string) – dictionary used for mapping
from espressopp’s integer particle types to the particle type strings written in a psf file
espressopp.tools.psfread(filename)
Reads !NATOM section of a psf format file
Parameters filename (string) – input file name
Returns pid,segname,resindex,resname,atomname,atomtype,mass,charge
int,str,int,str,str,str,float,float)
(lists
of
type
tabulated - write tabulated file
espressopp.tools.tabulated.writeTabFile(pot, name, N, low=0.0, high=2.5, body=2)
writeTabFile can be used to create a table for any potential Parameters are: * pot : this is any espressopp.interaction potential * name : filename * N : number of line to write * low : lowest r (default is 0.0) *
high : highest r (default is 2.5)
This function has not been tested for 3 and 4 body interactions
topology_helper
units - convert to real units
Espresso++ returns temperature, energy, pressure, box length etc. in dimensionless units. Usually user should
take care about real length, energy, mass and charge units. This python class is a helper in order to simplify the
conversion which is based on basic units. However, user always should use it carefully for complicated systems.
Currently it is implemented for SI units. Make sure that you are using length in [nm] energy in [kJ/mol] mass in
[amu] q in [e]
and it will return you pressure in [bar] temperature in [K] time in [ps] density in [kg/m^3]
Example:
Logging mechanism
ESPResSo++ uses Loggers
Logging can be switched on in your python script with the following command:
>>> logging.getLogger("*name of the logger*").setLevel(logging.*Level*)
170
Chapter 3. User Interface
ESPResSo++ Documentation, Release latest
Level is one of the following:
ERROR
WARN
INFO
DEBUG
for errors that might still allow the application to continue
for potentially harmful situations
informational messages highlighting progress
designates fine-grained informational events
Example:
>>> import espressopp
>>> import logging
>>> logging.getLogger("Storage").setLevel(logging.ERROR)
To log everything (WARNING: this will produce lots of output):
>>> logging.getLogger("").setLevel(logging.DEBUG)
The following loggers are currently available:
• Configurations
• Observable
• Velocities
• BC
• Logger
• FixedListComm
• FixedPairList
• FixedQuadrupleList
• FixedTripleList
• FixedTupleList
• Langevin
• MDIntegrator
• AngularPotential
• DihedralPotential
• Interaction
• InterpolationAkima
• InterpolationCubic
• InterpolationLinear
• InterpolationTable
• Potential
• CellListAllPairsIterator
• DomainDecomposition.CellGrid
• DomainDecomposition
• DomainDecomposition.NodeGrid
• Storage
• DomainDecompositionAdress
• StorageAdress
• VerletList
3.13. Logging mechanism
171
ESPResSo++ Documentation, Release latest
• VerletList
172
Chapter 3. User Interface
CHAPTER
FOUR
CREDITS
ESPResSo++ Developers
The core of the developer team comes from the Polymer Theory Group of Prof. Kurt Kremer at the Max Planck
Institute for Polymer Research in Mainz.
A full list of active and former developers is available at the main website of ESPResSo++.
FAQ
A short list of frequently asked questions is given here.
Getting Help
If you have any questions do not hesitate to contact us.
173
ESPResSo++ Documentation, Release latest
174
Chapter 4. Credits
BIBLIOGRAPHY
[Berendsen84] Berendsen et al., J. Chem. Phys., 81, 1984, p. 3684
[Quigley04]
4. Quigley, M.I.J. Probert, J. Chem. Phys., 120, 2004, p. 11432
[Martyna94]
7. Martyna, D. Tobias, M. Klein, J. Chem. Phys., 101, 1994, p. 4177
[Allen89] M.P.Allen, D.J.Tildesley, Computer simulation of liquids, Clarendon Press, 1989 385 p.
[Deserno98] M.Deserno and C.Holm, J. Chem. Phys., 109(18), 1998, p.7678
175
ESPResSo++ Documentation, Release latest
176
Bibliography
PYTHON MODULE INDEX
e
espressopp.analysis.Test, 32
espressopp.analysis.Velocities, 41
espressopp.analysis.AdressDensity, 37
espressopp.analysis.AllParticlePos, 27 espressopp.analysis.VelocityAutocorrelation,
41
espressopp.analysis.AnalysisBase, 32
espressopp.analysis.Viscosity,
41
espressopp.analysis.Autocorrelation,
espressopp.analysis.XDensity,
40
32
espressopp.analysis.XPressure, 40
espressopp.analysis.CenterOfMass, 37
espressopp.analysis.XTemperature, 40
espressopp.analysis.CMVelocity, 33
espressopp.bc.BC,
42
espressopp.analysis.ConfigsParticleDecomp,
espressopp.bc.OrthorhombicBC,
43
33
espressopp.bc.SlabBC,
43
espressopp.analysis.Configurations, 34
espressopp.analysis.ConfigurationsExt, espressopp.check.System, 44
espressopp.esutil.Collectives, 44
34
espressopp.esutil.GammaVariate, 44
espressopp.analysis.Energy, 35
espressopp.analysis.IntraChainDistSq, espressopp.esutil.Grid, 44
espressopp.esutil.NormalVariate, 44
36
espressopp.esutil.RNG, 44
espressopp.analysis.LBOutput, 27
espressopp.analysis.LBOutputScreen, 28 espressopp.esutil.UniformOnSphere, 44
espressopp.analysis.LBOutputVzInTime, espressopp.Exceptions, 134
espressopp.FixedLocalTupleList, 135
28
espressopp.FixedPairDistList, 135
espressopp.analysis.LBOutputVzOfX, 28
espressopp.FixedPairList, 136
espressopp.analysis.MaxPID, 37
espressopp.FixedPairListAdress, 136
espressopp.analysis.MeanSquareDispl,
espressopp.FixedQuadrupleAngleList,
36
137
espressopp.analysis.MeanSquareInternalDist,
espressopp.FixedQuadrupleList,
137
36
espressopp.FixedQuadrupleListAdress,
espressopp.analysis.NeighborFluctuation,
138
37
espressopp.FixedSingleList, 138
espressopp.analysis.NPart, 38
espressopp.FixedTripleAngleList, 139
espressopp.analysis.Observable, 40
espressopp.analysis.OrderParameter, 29 espressopp.FixedTripleList, 139
espressopp.FixedTripleListAdress, 140
espressopp.analysis.ParticleRadiusDistribution,
espressopp.FixedTupleList, 140
29
espressopp.FixedTupleListAdress, 141
espressopp.analysis.PotentialEnergy,
espressopp.Int3D, 141
38
espressopp.integrator.Adress, 44
espressopp.analysis.Pressure, 38
espressopp.analysis.PressureTensor, 29 espressopp.integrator.AssociationReaction,
45
espressopp.analysis.PressureTensorLayer,
espressopp.integrator.BerendsenBarostat,
30
espressopp.analysis.PressureTensorMultiLayer, 45
espressopp.integrator.BerendsenBarostatAnisotropi
31
46
espressopp.analysis.RadialDistrF, 38
espressopp.integrator.BerendsenThermostat,
espressopp.analysis.RDFatomistic, 38
47
espressopp.analysis.StaticStructF, 39
espressopp.integrator.CapForce, 48
espressopp.analysis.SystemMonitor, 40
espressopp.integrator.DPDThermostat,
espressopp.analysis.Temperature, 31
49
177
ESPResSo++ Documentation, Release latest
espressopp.integrator.EmptyExtension,
67
49
espressopp.interaction.AngularUniquePotential,
espressopp.integrator.ExtAnalyze, 49
67
espressopp.integrator.Extension, 49
espressopp.interaction.ConstrainCOM,
espressopp.integrator.ExtForce, 50
74
espressopp.integrator.FixPositions, 50 espressopp.interaction.ConstrainRG, 75
espressopp.integrator.FreeEnergyCompensation,
espressopp.interaction.Cosine, 67
50
espressopp.interaction.CoulombKSpaceEwald,
espressopp.integrator.GeneralizedLangevinThermostat,
68
51
espressopp.interaction.CoulombKSpaceP3M,
espressopp.integrator.Isokinetic, 51
69
espressopp.integrator.LangevinBarostat, espressopp.interaction.CoulombRSpace,
51
70
espressopp.integrator.LangevinThermostat,
espressopp.interaction.CoulombTruncated,
53
72
espressopp.integrator.LangevinThermostat1D,
espressopp.interaction.CoulombTruncatedUniqueChar
53
73
espressopp.integrator.LangevinThermostatHybrid,
espressopp.interaction.DihedralHarmonic,
53
75
espressopp.integrator.LangevinThermostatOnGroup,
espressopp.interaction.DihedralHarmonicCos,
54
76
espressopp.integrator.LangevinThermostatOnRadius,
espressopp.interaction.DihedralHarmonicNCos,
54
77
espressopp.integrator.LatticeBoltzmann, espressopp.interaction.DihedralHarmonicUniqueCos,
55
77
espressopp.integrator.LBInit, 58
espressopp.interaction.DihedralPotential,
espressopp.integrator.LBInitConstForce,
78
59
espressopp.interaction.DihedralRB, 78
espressopp.integrator.LBInitPeriodicForce,
espressopp.interaction.DihedralUniquePotential,
60
79
espressopp.integrator.LBInitPopUniform, espressopp.interaction.FENE, 79
59
espressopp.interaction.FENECapped, 80
espressopp.integrator.LBInitPopWave,
espressopp.interaction.GravityTruncated,
59
81
espressopp.integrator.MDIntegrator, 60 espressopp.interaction.Harmonic, 82
espressopp.integrator.MinimizeEnergy, espressopp.interaction.HarmonicTrap,
60
83
espressopp.integrator.OnTheFlyFEC, 61
espressopp.interaction.HarmonicUnique,
espressopp.integrator.Rattle, 62
83
espressopp.integrator.Settle, 63
espressopp.interaction.Interaction, 84
espressopp.integrator.StochasticVelocityRescaling,
espressopp.interaction.LennardJones,
63
84
espressopp.integrator.TDforce, 63
espressopp.interaction.LennardJones93Wall,
espressopp.integrator.VelocityVerlet,
87
64
espressopp.interaction.LennardJonesAutoBonds,
espressopp.integrator.VelocityVerletOnGroup, 88
64
espressopp.interaction.LennardJonesCapped,
espressopp.integrator.VelocityVerletOnRadius, 90
64
espressopp.interaction.LennardJonesEnergyCapped,
espressopp.interaction.AngularCosineSquared, 93
65
espressopp.interaction.LennardJonesExpand,
espressopp.interaction.AngularHarmonic,
96
65
espressopp.interaction.LennardJonesGeneric,
espressopp.interaction.AngularPotential,
97
66
espressopp.interaction.LennardJonesGromacs,
espressopp.interaction.AngularUniqueCosineSquared,
100
66
espressopp.interaction.LennardJonesSoftcoreTI,
espressopp.interaction.AngularUniqueHarmonic, 102
178
Python Module Index
ESPResSo++ Documentation, Release latest
espressopp.interaction.LJcos, 104
156
espressopp.interaction.MirrorLennardJones,
espressopp.storage.DomainDecomposition,
105
156
espressopp.interaction.Morse, 106
espressopp.storage.DomainDecompositionAdress,
espressopp.interaction.OPLS, 108
156
espressopp.interaction.Potential, 109
espressopp.storage.DomainDecompositionNonBlocking
espressopp.interaction.PotentialUniqueDist,
157
109
espressopp.storage.Storage, 157
espressopp.interaction.PotentialVSpherePair,
espressopp.System, 150
109
espressopp.Tensor, 151
espressopp.interaction.Quartic, 109
espressopp.tools.analyse, 160
espressopp.interaction.ReactionFieldGeneralized,
espressopp.tools.decomp, 161
110
espressopp.tools.DumpConfigurations,
espressopp.interaction.ReactionFieldGeneralizedTI,
163
112
espressopp.tools.espresso_old, 164
espressopp.interaction.SingleParticlePotential,
espressopp.tools.gromacs, 164
114
espressopp.tools.info, 160
espressopp.interaction.SoftCosine, 114 espressopp.tools.io_extended, 166
espressopp.interaction.StillingerWeberPairTerm,
espressopp.tools.lammps, 166
115
espressopp.tools.lattice, 160
espressopp.interaction.StillingerWeberPairTermCapped,
espressopp.tools.pathintegral, 167
118
espressopp.tools.pdb, 167
espressopp.interaction.StillingerWeberTripleTerm,
espressopp.tools.povwrite, 168
120
espressopp.tools.prepareAdress, 169
espressopp.interaction.Tabulated, 122
espressopp.tools.prepareComplexMolecules,
espressopp.interaction.TabulatedAngular,
168
124
espressopp.tools.psf, 169
espressopp.interaction.TabulatedDihedral,
espressopp.tools.replicate, 161
125
espressopp.tools.tabulated, 170
espressopp.interaction.TersoffPairTerm, espressopp.tools.timers, 160
126
espressopp.tools.topology, 161
espressopp.interaction.TersoffTripleTerm,
espressopp.tools.topology_helper, 170
127
espressopp.tools.units, 170
espressopp.interaction.VSpherePair,
espressopp.tools.velocities, 161
128
espressopp.tools.vmd, 160
espressopp.interaction.VSphereSelf,
espressopp.tools.warmup, 161
129
espressopp.VerletList, 152
espressopp.interaction.Zero, 129
espressopp.VerletListAdress, 152
espressopp.io.DumpGRO, 131
espressopp.VerletListTriple, 154
espressopp.io.DumpGROAdress, 132
espressopp.Version, 154
espressopp.io.DumpXYZ, 133
espressopp.MultiSystem, 142
espressopp.ParallelTempering, 142
espressopp.Particle, 143
espressopp.ParticleAccess, 143
espressopp.ParticleGroup, 143
espressopp.pmi, 144
espressopp.Quaternion, 148
espressopp.Real3D, 149
espressopp.RealND, 150
espressopp.standard_system.Default,
154
espressopp.standard_system.KGMelt, 155
espressopp.standard_system.LennardJones,
155
espressopp.standard_system.Minimal,
155
espressopp.standard_system.PolymerMelt,
Python Module Index
179
ESPResSo++ Documentation, Release latest
180
Python Module Index
INDEX
A
E
addForce() (espressopp.integrator.LBInit.espressopp.integrator.LBInit
espressopp.__Int3D() (in module espressopp.Int3D),
method), 59
141
AngularCosineSquared
(class
in
espres- espressopp.__Int3D.x() (in module espressopp.Int3D),
sopp.interaction.AngularCosineSquared),
141
65
espressopp.__Int3D.y() (in module espressopp.Int3D),
AngularHarmonic
(class
in
espres141
sopp.interaction.AngularHarmonic), 66
espressopp.__Int3D.z() (in module espressopp.Int3D),
AngularUniqueCosineSquared (class in espres141
sopp.interaction.AngularUniqueCosineSquared),espressopp.__Real3D()
(in
module
espres67
sopp.Real3D), 149
espressopp.__Real3D.x()
(in
module
espresC
sopp.Real3D), 149
call() (in module espressopp.pmi), 146
espressopp.__Real3D.y()
(in
module
espresconnect() (in module espressopp.tools.vmd), 160
sopp.Real3D), 149
convertTable() (in module espressopp.tools.gromacs), espressopp.__Real3D.z()
(in
module
espres165
sopp.Real3D), 150
Cosine (class in espressopp.interaction.Cosine), 68
espressopp.__RealND()
(in
module
espresCoulombTruncated
(class
in
espressopp.RealND), 150
sopp.interaction.CoulombTruncated), 73
espressopp.analysis.AdressDensity (module), 37
CoulombTruncatedUniqueCharge (class in espres- espressopp.analysis.AdressDensity()
(in
module
sopp.interaction.CoulombTruncatedUniqueCharge),
espressopp.analysis.AdressDensity), 37
74
espressopp.analysis.AdressDensity.addExclusions() (in
create() (in module espressopp.pmi), 146
module espressopp.analysis.AdressDensity),
createCubic() (in module espressopp.tools.lattice), 160
37
createDenVel()
(espres- espressopp.analysis.AdressDensity.compute() (in modsopp.integrator.LBInit.espressopp.integrator.LBInit
ule espressopp.analysis.AdressDensity), 37
method), 58
espressopp.analysis.AllParticlePos (module), 27
createDiamond() (in module espressopp.tools.lattice), espressopp.analysis.AllParticlePos.gatherAllPositions()
160
(in
module
espressopp.analysis.AllParticlePos), 27
D
espressopp.analysis.AnalysisBase (module), 32
Default() (espressopp.standard_system.Default.espressopp.standard_system
espressopp.analysis.AnalysisBase.compute() (in modmethod), 154
ule espressopp.analysis.AnalysisBase), 32
DihedralHarmonic
(class
in
espres- espressopp.analysis.AnalysisBase.getAverageValue()
sopp.interaction.DihedralHarmonic), 76
(in
module
espresDihedralHarmonicCos
(class
in
espressopp.analysis.AnalysisBase), 32
sopp.interaction.DihedralHarmonicCos),
espressopp.analysis.AnalysisBase.getNumberOfMeasurements()
77
(in
module
espresDihedralHarmonicNCos
(class
in
espressopp.analysis.AnalysisBase), 32
sopp.interaction.DihedralHarmonicNCos),
espressopp.analysis.AnalysisBase.performMeasurement()
77
(in
module
espresDihedralHarmonicUniqueCos (class in espressopp.analysis.AnalysisBase), 32
sopp.interaction.DihedralHarmonicUniqueCos),espressopp.analysis.AnalysisBase.reset() (in module
78
espressopp.analysis.AnalysisBase), 32
displacement
(in
module
espres- espressopp.analysis.Autocorrelation (module), 32
sopp.integrator.MinimizeEnergy), 61
181
ESPResSo++ Documentation, Release latest
espressopp.analysis.Autocorrelation() (in module
35
espressopp.analysis.Autocorrelation), 33
espressopp.analysis.ConfigurationsExt.gather()
espressopp.analysis.Autocorrelation.clear() (in module
(in
module
espresespressopp.analysis.Autocorrelation), 33
sopp.analysis.ConfigurationsExt), 35
espressopp.analysis.Autocorrelation.compute()
espressopp.analysis.Energy (module), 35
(in
module
espres- espressopp.analysis.EnergyKin() (in module espressopp.analysis.Autocorrelation), 33
sopp.analysis.Energy), 35
espressopp.analysis.Autocorrelation.gather() (in mod- espressopp.analysis.EnergyKin.compute() (in module
ule espressopp.analysis.Autocorrelation), 33
espressopp.analysis.Energy), 36
espressopp.analysis.CenterOfMass (module), 37
espressopp.analysis.EnergyPot() (in module espresespressopp.analysis.CenterOfMass() (in module espressopp.analysis.Energy), 35
sopp.analysis.CenterOfMass), 37
espressopp.analysis.EnergyPot.compute() (in module
espressopp.analysis.CMVelocity (class in espresespressopp.analysis.Energy), 35
sopp.analysis.CMVelocity), 33
espressopp.analysis.EnergyTot() (in module espresespressopp.analysis.CMVelocity (module), 33
sopp.analysis.Energy), 36
espressopp.analysis.CMVelocity.compute() (in module espressopp.analysis.EnergyTot.compute() (in module
espressopp.analysis.CMVelocity), 33
espressopp.analysis.Energy), 36
espressopp.analysis.CMVelocity.reset() (in module espressopp.analysis.IntraChainDistSq (module), 36
espressopp.analysis.CMVelocity), 33
espressopp.analysis.IntraChainDistSq() (in module
espressopp.analysis.ConfigsParticleDecomp (module),
espressopp.analysis.IntraChainDistSq), 36
33
espressopp.analysis.IntraChainDistSq.compute()
espressopp.analysis.ConfigsParticleDecomp()
(in
module
espres(in
module
espressopp.analysis.IntraChainDistSq), 36
sopp.analysis.ConfigsParticleDecomp),
espressopp.analysis.LBOutput (module), 27
33
espressopp.analysis.LBOutputScreen (class in espresespressopp.analysis.ConfigsParticleDecomp.clear()
sopp.analysis.LBOutputScreen), 28
(in
module
espres- espressopp.analysis.LBOutputScreen (module), 28
sopp.analysis.ConfigsParticleDecomp),
espressopp.analysis.LBOutputVzInTime (class in
33
espressopp.analysis.LBOutputVzInTime), 28
espressopp.analysis.ConfigsParticleDecomp.compute() espressopp.analysis.LBOutputVzInTime (module), 28
(in
module
espres- espressopp.analysis.LBOutputVzOfX (class in espressopp.analysis.ConfigsParticleDecomp),
sopp.analysis.LBOutputVzOfX), 28
34
espressopp.analysis.LBOutputVzOfX (module), 28
espressopp.analysis.ConfigsParticleDecomp.gather()
espressopp.analysis.MaxPID (module), 37
(in
module
espres- espressopp.analysis.MaxPID() (in module espressopp.analysis.ConfigsParticleDecomp),
sopp.analysis.MaxPID), 37
34
espressopp.analysis.MeanSquareDispl (module), 36
espressopp.analysis.ConfigsParticleDecomp.gatherFromFile()
espressopp.analysis.MeanSquareDispl() (in module
(in
module
espresespressopp.analysis.MeanSquareDispl), 36
sopp.analysis.ConfigsParticleDecomp),
espressopp.analysis.MeanSquareDispl.computeG2()
34
(in
module
espresespressopp.analysis.Configurations (module), 34
sopp.analysis.MeanSquareDispl), 36
espressopp.analysis.Configurations()
(in
module espressopp.analysis.MeanSquareDispl.computeG3()
espressopp.analysis.Configurations), 34
(in
module
espresespressopp.analysis.Configurations.back() (in module
sopp.analysis.MeanSquareDispl), 36
espressopp.analysis.Configurations), 34
espressopp.analysis.MeanSquareDispl.strange()
espressopp.analysis.Configurations.clear() (in module
(in
module
espresespressopp.analysis.Configurations), 34
sopp.analysis.MeanSquareDispl), 36
espressopp.analysis.Configurations.gather() (in module espressopp.analysis.MeanSquareInternalDist (module),
espressopp.analysis.Configurations), 34
36
espressopp.analysis.ConfigurationsExt (module), 34
espressopp.analysis.MeanSquareInternalDist()
espressopp.analysis.ConfigurationsExt() (in module
(in
module
espresespressopp.analysis.ConfigurationsExt), 35
sopp.analysis.MeanSquareInternalDist),
espressopp.analysis.ConfigurationsExt.back() (in mod36
ule espressopp.analysis.ConfigurationsExt), espressopp.analysis.MeanSquareInternalDist.strange()
35
(in
module
espresespressopp.analysis.ConfigurationsExt.clear() (in modsopp.analysis.MeanSquareInternalDist),
ule espressopp.analysis.ConfigurationsExt),
36
182
Index
ESPResSo++ Documentation, Release latest
espressopp.analysis.NeighborFluctuation (module), 37
espressopp.analysis.NeighborFluctuation() (in module
espressopp.analysis.NeighborFluctuation),
38
espressopp.analysis.NPart (module), 38
espressopp.analysis.NPart() (in module espressopp.analysis.NPart), 38
espressopp.analysis.Observable (module), 40
espressopp.analysis.Observable.compute() (in module
espressopp.analysis.Observable), 40
espressopp.analysis.OrderParameter (module), 29
espressopp.analysis.OrderParameter() (in module
espressopp.analysis.OrderParameter), 29
espressopp.analysis.ParticleRadiusDistribution (module), 29
espressopp.analysis.ParticleRadiusDistribution()
(in
module
espressopp.analysis.ParticleRadiusDistribution),
29
espressopp.analysis.PotentialEnergy (module), 38
espressopp.analysis.PotentialEnergy() (in module
espressopp.analysis.PotentialEnergy), 38
espressopp.analysis.Pressure (module), 38
espressopp.analysis.Pressure() (in module espressopp.analysis.Pressure), 38
espressopp.analysis.PressureTensor (module), 29
espressopp.analysis.PressureTensor()
(in
module
espressopp.analysis.PressureTensor), 30
espressopp.analysis.PressureTensorLayer (module), 30
espressopp.analysis.PressureTensorLayer() (in module
espressopp.analysis.PressureTensorLayer),
30
espressopp.analysis.PressureTensorMultiLayer (module), 31
espressopp.analysis.PressureTensorMultiLayer()
(in
module
espressopp.analysis.PressureTensorMultiLayer),
31
espressopp.analysis.RadialDistrF (module), 38
espressopp.analysis.RadialDistrF() (in module espressopp.analysis.RadialDistrF), 38
espressopp.analysis.RadialDistrF.compute() (in module
espressopp.analysis.RadialDistrF), 38
espressopp.analysis.RDFatomistic (module), 38
espressopp.analysis.RDFatomistic() (in module espressopp.analysis.RDFatomistic), 39
espressopp.analysis.RDFatomistic.compute() (in module espressopp.analysis.RDFatomistic), 39
espressopp.analysis.StaticStructF (module), 39
espressopp.analysis.StaticStructF() (in module espressopp.analysis.StaticStructF), 39
espressopp.analysis.StaticStructF.compute() (in module
espressopp.analysis.StaticStructF), 39
espressopp.analysis.StaticStructF.computeSingleChain()
(in
module
espressopp.analysis.StaticStructF), 39
espressopp.analysis.SystemMonitor (module), 40
espressopp.analysis.SystemMonitor()
(in
module
Index
espressopp.analysis.SystemMonitor), 40
espressopp.analysis.SystemMonitor.add_observable()
(in
module
espressopp.analysis.SystemMonitor), 41
espressopp.analysis.SystemMonitor.info() (in module
espressopp.analysis.SystemMonitor), 41
espressopp.analysis.SystemMonitorOutputCSV() (in
module espressopp.analysis.SystemMonitor),
41
espressopp.analysis.Temperature (module), 31
espressopp.analysis.Temperature() (in module espressopp.analysis.Temperature), 31
espressopp.analysis.Test (module), 32
espressopp.analysis.Test()
(in
module
espressopp.analysis.Test), 32
espressopp.analysis.Velocities (module), 41
espressopp.analysis.Velocities() (in module espressopp.analysis.Velocities), 41
espressopp.analysis.Velocities.clear()
(in
module
espressopp.analysis.Velocities), 41
espressopp.analysis.Velocities.gather() (in module
espressopp.analysis.Velocities), 41
espressopp.analysis.VelocityAutocorrelation (module),
41
espressopp.analysis.VelocityAutocorrelation()
(in
module
espressopp.analysis.VelocityAutocorrelation),
41
espressopp.analysis.Viscosity (module), 41
espressopp.analysis.Viscosity() (in module espressopp.analysis.Viscosity), 42
espressopp.analysis.Viscosity.compute() (in module
espressopp.analysis.Viscosity), 42
espressopp.analysis.Viscosity.gather() (in module
espressopp.analysis.Viscosity), 42
espressopp.analysis.XDensity (module), 40
espressopp.analysis.XDensity() (in module espressopp.analysis.XDensity), 40
espressopp.analysis.XDensity.compute() (in module
espressopp.analysis.XDensity), 40
espressopp.analysis.XPressure (module), 40
espressopp.analysis.XPressure() (in module espressopp.analysis.XPressure), 40
espressopp.analysis.XPressure.compute() (in module
espressopp.analysis.XPressure), 40
espressopp.analysis.XTemperature (module), 40
espressopp.analysis.XTemperature() (in module espressopp.analysis.XTemperature), 40
espressopp.analysis.XTemperature.compute() (in module espressopp.analysis.XTemperature), 40
espressopp.bc.BC (class in espressopp.bc.BC), 42
espressopp.bc.BC (module), 42
espressopp.bc.OrthorhombicBC (module), 43
espressopp.bc.SlabBC (module), 43
espressopp.check.System (module), 44
espressopp.Error() (in module espressopp.Exceptions),
134
espressopp.esutil.Collectives (module), 44
183
ESPResSo++ Documentation, Release latest
espressopp.esutil.GammaVariate (module), 44
espressopp.esutil.GammaVariate() (in module espressopp.esutil.GammaVariate), 44
espressopp.esutil.Grid (module), 44
espressopp.esutil.NormalVariate (module), 44
espressopp.esutil.NormalVariate() (in module espressopp.esutil.NormalVariate), 44
espressopp.esutil.RNG (module), 44
espressopp.esutil.UniformOnSphere (module), 44
espressopp.Exceptions (module), 134
espressopp.FixedLocalTupleList (module), 135
espressopp.FixedLocalTupleList() (in module espressopp.FixedLocalTupleList), 135
espressopp.FixedLocalTupleList.addTuple() (in module espressopp.FixedLocalTupleList), 135
espressopp.FixedLocalTupleList.getTuples() (in module espressopp.FixedLocalTupleList), 135
espressopp.FixedLocalTupleList.size() (in module
espressopp.FixedLocalTupleList), 135
espressopp.FixedPairDistList (module), 135
espressopp.FixedPairDistList() (in module espressopp.FixedPairDistList), 135
espressopp.FixedPairDistList.add() (in module espressopp.FixedPairDistList), 135
espressopp.FixedPairDistList.addPairs() (in module
espressopp.FixedPairDistList), 135
espressopp.FixedPairDistList.getDist() (in module
espressopp.FixedPairDistList), 135
espressopp.FixedPairDistList.getPairs() (in module
espressopp.FixedPairDistList), 135
espressopp.FixedPairDistList.getPairsDist() (in module
espressopp.FixedPairDistList), 135
espressopp.FixedPairDistList.size() (in module espressopp.FixedPairDistList), 136
espressopp.FixedPairList (module), 136
espressopp.FixedPairList() (in module espressopp.FixedPairList), 136
espressopp.FixedPairList.add() (in module espressopp.FixedPairList), 136
espressopp.FixedPairList.addBonds()
(in
module
espressopp.FixedPairList), 136
espressopp.FixedPairList.getBonds()
(in
module
espressopp.FixedPairList), 136
espressopp.FixedPairList.getLongtimeMaxBond() (in
module espressopp.FixedPairList), 136
espressopp.FixedPairList.remove() (in module espressopp.FixedPairList), 136
espressopp.FixedPairList.resetLongtimeMaxBond() (in
module espressopp.FixedPairList), 136
espressopp.FixedPairList.size() (in module espressopp.FixedPairList), 136
espressopp.FixedPairListAdress (module), 136
espressopp.FixedPairListAdress() (in module espressopp.FixedPairListAdress), 136
espressopp.FixedPairListAdress.add() (in module
espressopp.FixedPairListAdress), 136
espressopp.FixedPairListAdress.addBonds() (in module espressopp.FixedPairListAdress), 137
184
espressopp.FixedPairListAdress.getBonds() (in module
espressopp.FixedPairListAdress), 137
espressopp.FixedPairListAdress.remove() (in module
espressopp.FixedPairListAdress), 137
espressopp.FixedQuadrupleAngleList (module), 137
espressopp.FixedQuadrupleAngleList() (in module
espressopp.FixedQuadrupleAngleList), 137
espressopp.FixedQuadrupleAngleList.add() (in module
espressopp.FixedQuadrupleAngleList), 137
espressopp.FixedQuadrupleAngleList.addQuadruples()
(in
module
espressopp.FixedQuadrupleAngleList), 137
espressopp.FixedQuadrupleAngleList.getAngle()
(in
module
espressopp.FixedQuadrupleAngleList), 137
espressopp.FixedQuadrupleAngleList.getQuadruples()
(in
module
espressopp.FixedQuadrupleAngleList), 137
espressopp.FixedQuadrupleAngleList.getQuadruplesAngles()
(in
module
espressopp.FixedQuadrupleAngleList), 137
espressopp.FixedQuadrupleAngleList.size() (in module
espressopp.FixedQuadrupleAngleList), 137
espressopp.FixedQuadrupleList (module), 137
espressopp.FixedQuadrupleList() (in module espressopp.FixedQuadrupleList), 138
espressopp.FixedQuadrupleList.add() (in module
espressopp.FixedQuadrupleList), 138
espressopp.FixedQuadrupleList.addQuadruples() (in
module
espressopp.FixedQuadrupleList),
138
espressopp.FixedQuadrupleList.getQuadruples()
(in
module
espressopp.FixedQuadrupleList),
138
espressopp.FixedQuadrupleList.remove() (in module
espressopp.FixedQuadrupleList), 138
espressopp.FixedQuadrupleList.size() (in module
espressopp.FixedQuadrupleList), 138
espressopp.FixedQuadrupleListAdress (module), 138
espressopp.FixedQuadrupleListAdress() (in module
espressopp.FixedQuadrupleListAdress), 138
espressopp.FixedQuadrupleListAdress.add() (in module espressopp.FixedQuadrupleListAdress),
138
espressopp.FixedQuadrupleListAdress.addQuadruples()
(in
module
espressopp.FixedQuadrupleListAdress), 138
espressopp.FixedQuadrupleListAdress.getQuadruples()
(in
module
espressopp.FixedQuadrupleListAdress), 138
espressopp.FixedQuadrupleListAdress.size() (in module espressopp.FixedQuadrupleListAdress),
138
espressopp.FixedSingleList (module), 138
espressopp.FixedSingleList() (in module espressopp.FixedSingleList), 139
espressopp.FixedSingleList.add() (in module espressopp.FixedSingleList), 139
Index
ESPResSo++ Documentation, Release latest
espressopp.FixedSingleList.addSingles() (in module
espressopp.FixedSingleList), 139
espressopp.FixedSingleList.getSingles() (in module
espressopp.FixedSingleList), 139
espressopp.FixedSingleList.size() (in module espressopp.FixedSingleList), 139
espressopp.FixedTripleAngleList (module), 139
espressopp.FixedTripleAngleList() (in module espressopp.FixedTripleAngleList), 139
espressopp.FixedTripleAngleList.add() (in module
espressopp.FixedTripleAngleList), 139
espressopp.FixedTripleAngleList.addTriples() (in module espressopp.FixedTripleAngleList), 139
espressopp.FixedTripleAngleList.getAngle() (in module espressopp.FixedTripleAngleList), 139
espressopp.FixedTripleAngleList.getTriples() (in module espressopp.FixedTripleAngleList), 139
espressopp.FixedTripleAngleList.getTriplesAngles()
(in
module
espressopp.FixedTripleAngleList), 139
espressopp.FixedTripleAngleList.size() (in module
espressopp.FixedTripleAngleList), 139
espressopp.FixedTripleList (module), 139
espressopp.FixedTripleList() (in module espressopp.FixedTripleList), 140
espressopp.FixedTripleList.add() (in module espressopp.FixedTripleList), 140
espressopp.FixedTripleList.addTriples() (in module
espressopp.FixedTripleList), 140
espressopp.FixedTripleList.getTriples() (in module
espressopp.FixedTripleList), 140
espressopp.FixedTripleList.remove()
(in
module
espressopp.FixedTripleList), 140
espressopp.FixedTripleList.size() (in module espressopp.FixedTripleList), 140
espressopp.FixedTripleListAdress (module), 140
espressopp.FixedTripleListAdress() (in module espressopp.FixedTripleListAdress), 140
espressopp.FixedTripleListAdress.add() (in module
espressopp.FixedTripleListAdress), 140
espressopp.FixedTripleListAdress.addTriples()
(in
module espressopp.FixedTripleListAdress),
140
espressopp.FixedTripleListAdress.remove() (in module
espressopp.FixedTripleListAdress), 140
espressopp.FixedTupleList (module), 140
espressopp.FixedTupleList() (in module espressopp.FixedTupleList), 140
espressopp.FixedTupleList.size() (in module espressopp.FixedTupleList), 140
espressopp.FixedTupleListAdress (module), 141
espressopp.FixedTupleListAdress() (in module espressopp.FixedTupleListAdress), 141
espressopp.FixedTupleListAdress.addTuples()
(in
module espressopp.FixedTupleListAdress),
141
espressopp.Int3D (module), 141
espressopp.integrator.Adress
(class
in
espres-
Index
sopp.integrator.Adress), 45
espressopp.integrator.Adress (module), 44
espressopp.integrator.AssociationReaction (module),
45
espressopp.integrator.BerendsenBarostat (module), 45
espressopp.integrator.BerendsenBarostat() (in module
espressopp.integrator.BerendsenBarostat), 46
espressopp.integrator.BerendsenBarostatAnisotropic
(module), 46
espressopp.integrator.BerendsenBarostatAnisotropic()
(in
module
espressopp.integrator.BerendsenBarostatAnisotropic),
47
espressopp.integrator.BerendsenThermostat (module),
47
espressopp.integrator.BerendsenThermostat()
(in
module
espressopp.integrator.BerendsenThermostat),
48
espressopp.integrator.CapForce (module), 48
espressopp.integrator.CapForce() (in module espressopp.integrator.CapForce), 49
espressopp.integrator.DPDThermostat (module), 49
espressopp.integrator.DPDThermostat() (in module
espressopp.integrator.DPDThermostat), 49
espressopp.integrator.EmptyExtension (module), 49
espressopp.integrator.EmptyExtension() (in module
espressopp.integrator.EmptyExtension), 49
espressopp.integrator.ExtAnalyze (module), 49
espressopp.integrator.ExtAnalyze() (in module espressopp.integrator.ExtAnalyze), 49
espressopp.integrator.Extension (module), 49
espressopp.integrator.Extension.connect() (in module
espressopp.integrator.Extension), 50
espressopp.integrator.Extension.disconnect() (in module espressopp.integrator.Extension), 50
espressopp.integrator.ExtForce (module), 50
espressopp.integrator.ExtForce() (in module espressopp.integrator.ExtForce), 50
espressopp.integrator.FixPositions (module), 50
espressopp.integrator.FixPositions() (in module espressopp.integrator.FixPositions), 50
espressopp.integrator.FreeEnergyCompensation (module), 50
espressopp.integrator.FreeEnergyCompensation()
(in
module
espressopp.integrator.FreeEnergyCompensation),
50
espressopp.integrator.FreeEnergyCompensation.addForce()
(in
module
espressopp.integrator.FreeEnergyCompensation),
50
espressopp.integrator.FreeEnergyCompensation.computeCompEnergy()
(in
module
espressopp.integrator.FreeEnergyCompensation),
51
espressopp.integrator.GeneralizedLangevinThermostat
(module), 51
185
ESPResSo++ Documentation, Release latest
espressopp.integrator.GeneralizedLangevinThermostat() espressopp.integrator.MDIntegrator.addExtension() (in
(in
module
espresmodule espressopp.integrator.MDIntegrator),
sopp.integrator.GeneralizedLangevinThermostat),
60
51
espressopp.integrator.MDIntegrator.getExtension() (in
espressopp.integrator.GeneralizedLangevinThermostat.addCoeffs() module espressopp.integrator.MDIntegrator),
(in
module
espres60
sopp.integrator.GeneralizedLangevinThermostat),
espressopp.integrator.MDIntegrator.getNumberOfExtensions()
51
(in
module
espresespressopp.integrator.Isokinetic (module), 51
sopp.integrator.MDIntegrator), 60
espressopp.integrator.Isokinetic() (in module espres- espressopp.integrator.MDIntegrator.run() (in module
sopp.integrator.Isokinetic), 51
espressopp.integrator.MDIntegrator), 60
espressopp.integrator.LangevinBarostat (module), 51
espressopp.integrator.MinimizeEnergy (module), 60
espressopp.integrator.LangevinBarostat() (in module espressopp.integrator.MinimizeEnergy() (in module
espressopp.integrator.LangevinBarostat), 53
espressopp.integrator.MinimizeEnergy), 61
espressopp.integrator.LangevinThermostat (module), espressopp.integrator.MinimizeEnergy.run() (in module
53
espressopp.integrator.MinimizeEnergy), 61
espressopp.integrator.LangevinThermostat()
espressopp.integrator.OnTheFlyFEC (module), 61
(in
module
espres- espressopp.integrator.OnTheFlyFEC() (in module
sopp.integrator.LangevinThermostat), 53
espressopp.integrator.OnTheFlyFEC), 62
espressopp.integrator.LangevinThermostat.addExclusions()
espressopp.integrator.OnTheFlyFEC.getBins()
(in
module
espres(in
module
espressopp.integrator.LangevinThermostat), 53
sopp.integrator.OnTheFlyFEC), 62
espressopp.integrator.LangevinThermostat1D (mod- espressopp.integrator.OnTheFlyFEC.getGap() (in module), 53
ule espressopp.integrator.OnTheFlyFEC), 62
espressopp.integrator.LangevinThermostat1D()
espressopp.integrator.OnTheFlyFEC.getSteps()
(in
module
espres(in
module
espressopp.integrator.LangevinThermostat1D),
sopp.integrator.OnTheFlyFEC), 62
53
espressopp.integrator.OnTheFlyFEC.makeArrays()
espressopp.integrator.LangevinThermostatHybrid
(in
module
espres(module), 53
sopp.integrator.OnTheFlyFEC), 62
espressopp.integrator.LangevinThermostatOnGroup
espressopp.integrator.OnTheFlyFEC.resetCounter()
(module), 54
(in
module
espresespressopp.integrator.LangevinThermostatOnGroup()
sopp.integrator.OnTheFlyFEC), 62
(in
module
espres- espressopp.integrator.OnTheFlyFEC.writeFEC()
sopp.integrator.LangevinThermostatOnGroup),
(in
module
espres54
sopp.integrator.OnTheFlyFEC), 62
espressopp.integrator.LangevinThermostatOnRadius
espressopp.integrator.Rattle (module), 62
(module), 54
espressopp.integrator.Settle (module), 63
espressopp.integrator.LangevinThermostatOnRadius() espressopp.integrator.Settle() (in module espres(in
module
espressopp.integrator.Settle), 63
sopp.integrator.LangevinThermostatOnRadius), espressopp.integrator.Settle.addMolecules() (in module
55
espressopp.integrator.Settle), 63
espressopp.integrator.LangevinThermostatOnRadius.addExclusions()
espressopp.integrator.StochasticVelocityRescaling
(in
module
espres(module), 63
sopp.integrator.LangevinThermostatOnRadius), espressopp.integrator.StochasticVelocityRescaling()
55
(in
module
espresespressopp.integrator.LatticeBoltzmann
(class
in
sopp.integrator.StochasticVelocityRescaling),
espressopp.integrator.LatticeBoltzmann), 55
63
espressopp.integrator.LatticeBoltzmann (module), 55
espressopp.integrator.TDforce (module), 63
espressopp.integrator.LBInit
(class
in
espres- espressopp.integrator.TDforce() (in module espressopp.integrator.LBInit), 58
sopp.integrator.TDforce), 64
espressopp.integrator.LBInit (module), 58
espressopp.integrator.TDforce.addForce() (in module
espressopp.integrator.LBInitConstForce (module), 59
espressopp.integrator.TDforce), 64
espressopp.integrator.LBInitPeriodicForce (module), espressopp.integrator.VelocityVerlet (module), 64
60
espressopp.integrator.VelocityVerlet() (in module
espressopp.integrator.LBInitPopUniform (module), 59
espressopp.integrator.VelocityVerlet), 64
espressopp.integrator.LBInitPopWave (module), 59
espressopp.integrator.VelocityVerletOnGroup
(modespressopp.integrator.MDIntegrator (module), 60
ule), 64
186
Index
ESPResSo++ Documentation, Release latest
espressopp.integrator.VelocityVerletOnGroup()
(in
module
espres(in
module
espressopp.interaction.CoulombKSpaceEwald),
sopp.integrator.VelocityVerletOnGroup),
69
64
espressopp.interaction.CellListCoulombKSpaceP3M()
espressopp.integrator.VelocityVerletOnRadius (mod(in
module
espresule), 64
sopp.interaction.CoulombKSpaceP3M),
espressopp.integrator.VelocityVerletOnRadius()
70
(in
module
espres- espressopp.interaction.CellListCoulombKSpaceP3M.getPotential()
sopp.integrator.VelocityVerletOnRadius),
(in
module
espres65
sopp.interaction.CoulombKSpaceP3M),
espressopp.interaction.AngularCosineSquared (mod70
ule), 65
espressopp.interaction.CellListCoulombTruncatedUniqueCharge()
espressopp.interaction.AngularCosineSquared()
(in
module
espres(in
module
espressopp.interaction.CoulombTruncatedUniqueCharge),
sopp.interaction.AngularCosineSquared),
74
65
espressopp.interaction.CellListCoulombTruncatedUniqueCharge.setPoten
espressopp.interaction.AngularHarmonic (module), 65
(in
module
espresespressopp.interaction.AngularHarmonic() (in module
sopp.interaction.CoulombTruncatedUniqueCharge),
espressopp.interaction.AngularHarmonic),
74
65
espressopp.interaction.CellListLennardJones()
espressopp.interaction.AngularPotential (module), 66
(in
module
espresespressopp.interaction.AngularPotential.computeEnergy()
sopp.interaction.LennardJones), 87
(in
module
espres- espressopp.interaction.CellListLennardJones.setPotential()
sopp.interaction.AngularPotential), 66
(in
module
espresespressopp.interaction.AngularPotential.computeForce()
sopp.interaction.LennardJones), 87
(in
module
espres- espressopp.interaction.CellListLennardJonesAutoBonds()
sopp.interaction.AngularPotential), 66
(in
module
espresespressopp.interaction.AngularUniqueCosineSquared
sopp.interaction.LennardJonesAutoBonds),
(module), 66
89
espressopp.interaction.AngularUniqueCosineSquared() espressopp.interaction.CellListLennardJonesAutoBonds.setPotential()
(in
module
espres(in
module
espressopp.interaction.AngularUniqueCosineSquared),
sopp.interaction.LennardJonesAutoBonds),
66
90
espressopp.interaction.AngularUniqueHarmonic (mod- espressopp.interaction.CellListLennardJonesCapped()
ule), 67
(in
module
espresespressopp.interaction.AngularUniqueHarmonic()
sopp.interaction.LennardJonesCapped),
(in
module
espres92
sopp.interaction.AngularUniqueHarmonic),
espressopp.interaction.CellListLennardJonesCapped.getPotential()
67
(in
module
espresespressopp.interaction.AngularUniquePotential (modsopp.interaction.LennardJonesCapped),
ule), 67
92
espressopp.interaction.AngularUniquePotential.computeEnergy()
espressopp.interaction.CellListLennardJonesCapped.setPotential()
(in
module
espres(in
module
espressopp.interaction.AngularUniquePotential),
sopp.interaction.LennardJonesCapped),
67
92
espressopp.interaction.AngularUniquePotential.computeForce()
espressopp.interaction.CellListLennardJonesEnergyCapped()
(in
module
espres(in
module
espressopp.interaction.AngularUniquePotential),
sopp.interaction.LennardJonesEnergyCapped),
67
95
espressopp.interaction.CellListCoulombKSpaceEwald() espressopp.interaction.CellListLennardJonesEnergyCapped.getPotential()
(in
module
espres(in
module
espressopp.interaction.CoulombKSpaceEwald),
sopp.interaction.LennardJonesEnergyCapped),
69
95
espressopp.interaction.CellListCoulombKSpaceEwald.getFixedPairList()
espressopp.interaction.CellListLennardJonesEnergyCapped.setPotential()
(in
module
espres(in
module
espressopp.interaction.CoulombKSpaceEwald),
sopp.interaction.LennardJonesEnergyCapped),
69
95
espressopp.interaction.CellListCoulombKSpaceEwald.getPotential()
espressopp.interaction.CellListLennardJonesExpand()
Index
187
ESPResSo++ Documentation, Release latest
(in
module
espressopp.interaction.StillingerWeberPairTermCapped),
sopp.interaction.LennardJonesExpand),
120
97
espressopp.interaction.CellListTabulated() (in module
espressopp.interaction.CellListLennardJonesExpand.setPotential() espressopp.interaction.Tabulated), 123
(in
module
espres- espressopp.interaction.CellListTabulated.setPotential()
sopp.interaction.LennardJonesExpand),
(in module espressopp.interaction.Tabulated),
97
123
espressopp.interaction.CellListLennardJonesGeneric() espressopp.interaction.CellListTersoffPairTerm()
(in
module
espres(in
module
espressopp.interaction.LennardJonesGeneric),
sopp.interaction.TersoffPairTerm), 126
100
espressopp.interaction.CellListTersoffPairTerm.setPotential()
espressopp.interaction.CellListLennardJonesGeneric.setPotential() (in
module
espres(in
module
espressopp.interaction.TersoffPairTerm), 127
sopp.interaction.LennardJonesGeneric),
espressopp.interaction.CellListZero()
(in
module
100
espressopp.interaction.Zero), 131
espressopp.interaction.CellListLennardJonesGromacs() espressopp.interaction.CellListZero.setPotential() (in
(in
module
espresmodule espressopp.interaction.Zero), 131
sopp.interaction.LennardJonesGromacs),
espressopp.interaction.ConstrainCOM (module), 74
101
espressopp.interaction.ConstrainCOM() (in module
espressopp.interaction.CellListLennardJonesGromacs.setPotential()espressopp.interaction.ConstrainCOM), 75
(in
module
espres- espressopp.interaction.ConstrainRG (module), 75
sopp.interaction.LennardJonesGromacs),
espressopp.interaction.ConstrainRG() (in module
101
espressopp.interaction.ConstrainRG), 75
espressopp.interaction.CellListLJcos() (in module espressopp.interaction.Cosine (module), 67
espressopp.interaction.LJcos), 105
espressopp.interaction.Cosine() (in module espresespressopp.interaction.CellListLJcos.setPotential() (in
sopp.interaction.Cosine), 67
module espressopp.interaction.LJcos), 105
espressopp.interaction.CoulombKSpaceEwald (modespressopp.interaction.CellListMorse() (in module
ule), 68
espressopp.interaction.Morse), 108
espressopp.interaction.CoulombKSpaceEwald()
espressopp.interaction.CellListMorse.setPotential() (in
(in
module
espresmodule espressopp.interaction.Morse), 108
sopp.interaction.CoulombKSpaceEwald),
espressopp.interaction.CellListReactionFieldGeneralized()
69
(in
module
espres- espressopp.interaction.CoulombKSpaceP3M (module),
sopp.interaction.ReactionFieldGeneralized),
69
112
espressopp.interaction.CoulombKSpaceP3M()
espressopp.interaction.CellListReactionFieldGeneralized.setPotential()
(in
module
espres(in
module
espressopp.interaction.CoulombKSpaceP3M),
sopp.interaction.ReactionFieldGeneralized),
70
112
espressopp.interaction.CoulombRSpace (module), 70
espressopp.interaction.CellListSoftCosine() (in module espressopp.interaction.CoulombRSpace() (in module
espressopp.interaction.SoftCosine), 115
espressopp.interaction.CoulombRSpace), 71
espressopp.interaction.CellListSoftCosine.setPotential() espressopp.interaction.CoulombTruncated (module),
(in
module
espres72
sopp.interaction.SoftCosine), 115
espressopp.interaction.CoulombTruncatedUniqueCharge
espressopp.interaction.CellListStillingerWeberPairTerm()
(module), 73
(in
module
espres- espressopp.interaction.CoulombTruncatedUniqueCharge()
sopp.interaction.StillingerWeberPairTerm),
(in
module
espres117
sopp.interaction.CoulombTruncatedUniqueCharge),
espressopp.interaction.CellListStillingerWeberPairTerm.setPotential()
73
(in
module
espres- espressopp.interaction.DihedralHarmonic (module), 75
sopp.interaction.StillingerWeberPairTerm),
espressopp.interaction.DihedralHarmonic() (in module
117
espressopp.interaction.DihedralHarmonic),
espressopp.interaction.CellListStillingerWeberPairTermCapped() 76
(in
module
espres- espressopp.interaction.DihedralHarmonicCos (modsopp.interaction.StillingerWeberPairTermCapped),
ule), 76
120
espressopp.interaction.DihedralHarmonicCos()
espressopp.interaction.CellListStillingerWeberPairTermCapped.setPotential()
(in
module
espres(in
module
espressopp.interaction.DihedralHarmonicCos),
188
Index
ESPResSo++ Documentation, Release latest
76
(in
module
espresespressopp.interaction.DihedralHarmonicNCos (modsopp.interaction.HarmonicUnique), 83
ule), 77
espressopp.interaction.FixedPairDistListHarmonicUnique.getFixedPairLi
espressopp.interaction.DihedralHarmonicNCos()
(in
module
espres(in
module
espressopp.interaction.HarmonicUnique), 83
sopp.interaction.DihedralHarmonicNCos),
espressopp.interaction.FixedPairDistListHarmonicUnique.setFixedPairLis
77
(in
module
espresespressopp.interaction.DihedralHarmonicUniqueCos
sopp.interaction.HarmonicUnique), 83
(module), 77
espressopp.interaction.FixedPairDistListHarmonicUnique.setPotential()
espressopp.interaction.DihedralHarmonicUniqueCos()
(in
module
espres(in
module
espressopp.interaction.HarmonicUnique), 84
sopp.interaction.DihedralHarmonicUniqueCos),espressopp.interaction.FixedPairListCoulombTruncatedUniqueCharge()
78
(in
module
espresespressopp.interaction.DihedralPotential (module), 78
sopp.interaction.CoulombTruncatedUniqueCharge),
espressopp.interaction.DihedralPotential.computeEnergy()
74
(in
module
espres- espressopp.interaction.FixedPairListCoulombTruncatedUniqueCharge.set
sopp.interaction.DihedralPotential), 78
(in
module
espresespressopp.interaction.DihedralPotential.computeForce()
sopp.interaction.CoulombTruncatedUniqueCharge),
(in
module
espres74
sopp.interaction.DihedralPotential), 78
espressopp.interaction.FixedPairListFENE() (in modespressopp.interaction.DihedralRB (module), 78
ule espressopp.interaction.FENE), 80
espressopp.interaction.DihedralRB()
(in
module espressopp.interaction.FixedPairListFENE.getFixedPairList()
espressopp.interaction.DihedralRB), 78
(in module espressopp.interaction.FENE), 80
espressopp.interaction.DihedralUniquePotential (mod- espressopp.interaction.FixedPairListFENE.getPotential()
ule), 79
(in module espressopp.interaction.FENE), 80
espressopp.interaction.DihedralUniquePotential.computeEnergy()
espressopp.interaction.FixedPairListFENE.setFixedPairList()
(in
module
espres(in module espressopp.interaction.FENE), 80
sopp.interaction.DihedralUniquePotential),
espressopp.interaction.FixedPairListFENE.setPotential()
79
(in module espressopp.interaction.FENE), 80
espressopp.interaction.DihedralUniquePotential.computeForce()
espressopp.interaction.FixedPairListFENECapped()
(in
module
espres(in
module
espressopp.interaction.DihedralUniquePotential),
sopp.interaction.FENECapped), 81
79
espressopp.interaction.FixedPairListFENECapped.getFixedPairList()
espressopp.interaction.FENE (module), 79
(in
module
espresespressopp.interaction.FENE() (in module espressopp.interaction.FENECapped), 81
sopp.interaction.FENE), 79
espressopp.interaction.FixedPairListFENECapped.getPotential()
espressopp.interaction.FENECapped (module), 80
(in
module
espresespressopp.interaction.FENECapped() (in module
sopp.interaction.FENECapped), 81
espressopp.interaction.FENECapped), 80
espressopp.interaction.FixedPairListFENECapped.setFixedPairList()
espressopp.interaction.FixedLocalTupleListConstrainCOM()
(in
module
espres(in
module
espressopp.interaction.FENECapped), 81
sopp.interaction.ConstrainCOM), 75
espressopp.interaction.FixedPairListFENECapped.setPotential()
espressopp.interaction.FixedLocalTupleListConstrainCOM.getPotential()
(in
module
espres(in
module
espressopp.interaction.FENECapped), 81
sopp.interaction.ConstrainCOM), 75
espressopp.interaction.FixedPairListHarmonic()
(in
espressopp.interaction.FixedLocalTupleListConstrainCOM.setCom()
module espressopp.interaction.Harmonic),
(in
module
espres82
sopp.interaction.ConstrainCOM), 75
espressopp.interaction.FixedPairListHarmonic.getFixedPairList()
espressopp.interaction.FixedLocalTupleListConstrainRG()
(in
module
espres(in
module
espressopp.interaction.Harmonic), 82
sopp.interaction.ConstrainRG), 75
espressopp.interaction.FixedPairListHarmonic.setFixedPairList()
espressopp.interaction.FixedLocalTupleListConstrainRG.getPotential()
(in
module
espres(in
module
espressopp.interaction.Harmonic), 82
sopp.interaction.ConstrainRG), 75
espressopp.interaction.FixedPairListHarmonic.setPotential()
espressopp.interaction.FixedLocalTupleListConstrainRG.setRG() (in
module
espres(in
module
espressopp.interaction.Harmonic), 82
sopp.interaction.ConstrainRG), 75
espressopp.interaction.FixedPairListLennardJones()
espressopp.interaction.FixedPairDistListHarmonicUnique()
(in
module
espres-
Index
189
ESPResSo++ Documentation, Release latest
sopp.interaction.LennardJones), 87
(in
module
espresespressopp.interaction.FixedPairListLennardJones.getFixedPairList()
sopp.interaction.LennardJonesGeneric),
(in
module
espres100
sopp.interaction.LennardJones), 87
espressopp.interaction.FixedPairListLennardJonesGeneric.getPotential()
espressopp.interaction.FixedPairListLennardJones.getPotential() (in
module
espres(in
module
espressopp.interaction.LennardJonesGeneric),
sopp.interaction.LennardJones), 87
100
espressopp.interaction.FixedPairListLennardJones.setFixedPairList()
espressopp.interaction.FixedPairListLennardJonesGeneric.setFixedPairLi
(in
module
espres(in
module
espressopp.interaction.LennardJones), 87
sopp.interaction.LennardJonesGeneric),
espressopp.interaction.FixedPairListLennardJones.setPotential() 100
(in
module
espres- espressopp.interaction.FixedPairListLennardJonesGeneric.setPotential()
sopp.interaction.LennardJones), 87
(in
module
espresespressopp.interaction.FixedPairListLennardJonesAutoBonds()
sopp.interaction.LennardJonesGeneric),
(in
module
espres100
sopp.interaction.LennardJonesAutoBonds),
espressopp.interaction.FixedPairListLennardJonesGromacs()
90
(in
module
espresespressopp.interaction.FixedPairListLennardJonesAutoBonds.setPotential()
sopp.interaction.LennardJonesGromacs),
(in
module
espres101
sopp.interaction.LennardJonesAutoBonds),
espressopp.interaction.FixedPairListLennardJonesGromacs.setPotential()
90
(in
module
espresespressopp.interaction.FixedPairListLennardJonesCapped()
sopp.interaction.LennardJonesGromacs),
(in
module
espres101
sopp.interaction.LennardJonesCapped),
espressopp.interaction.FixedPairListLJcos() (in module
93
espressopp.interaction.LJcos), 105
espressopp.interaction.FixedPairListLennardJonesCapped.getPotential()
espressopp.interaction.FixedPairListLJcos.getFixedPairList()
(in
module
espres(in module espressopp.interaction.LJcos),
sopp.interaction.LennardJonesCapped),
105
93
espressopp.interaction.FixedPairListLJcos.setFixedPairList()
espressopp.interaction.FixedPairListLennardJonesCapped.setPotential()
(in module espressopp.interaction.LJcos),
(in
module
espres105
sopp.interaction.LennardJonesCapped),
espressopp.interaction.FixedPairListLJcos.setPotential()
93
(in module espressopp.interaction.LJcos),
espressopp.interaction.FixedPairListLennardJonesEnergyCapped() 105
(in
module
espres- espressopp.interaction.FixedPairListMirrorLennardJones()
sopp.interaction.LennardJonesEnergyCapped),
(in
module
espres96
sopp.interaction.MirrorLennardJones),
espressopp.interaction.FixedPairListLennardJonesEnergyCapped.getPotential()
106
(in
module
espres- espressopp.interaction.FixedPairListMirrorLennardJones.getFixedPairLis
sopp.interaction.LennardJonesEnergyCapped),
(in
module
espres96
sopp.interaction.MirrorLennardJones),
espressopp.interaction.FixedPairListLennardJonesEnergyCapped.setPotential()
106
(in
module
espres- espressopp.interaction.FixedPairListMirrorLennardJones.getPotential()
sopp.interaction.LennardJonesEnergyCapped),
(in
module
espres96
sopp.interaction.MirrorLennardJones),
espressopp.interaction.FixedPairListLennardJonesExpand()
106
(in
module
espres- espressopp.interaction.FixedPairListMirrorLennardJones.setFixedPairList
sopp.interaction.LennardJonesExpand),
(in
module
espres97
sopp.interaction.MirrorLennardJones),
espressopp.interaction.FixedPairListLennardJonesExpand.setPotential()
106
(in
module
espres- espressopp.interaction.FixedPairListMirrorLennardJones.setPotential()
sopp.interaction.LennardJonesExpand),
(in
module
espres97
sopp.interaction.MirrorLennardJones),
espressopp.interaction.FixedPairListLennardJonesGeneric()
106
(in
module
espres- espressopp.interaction.FixedPairListMorse() (in modsopp.interaction.LennardJonesGeneric),
ule espressopp.interaction.Morse), 108
100
espressopp.interaction.FixedPairListMorse.setPotential()
espressopp.interaction.FixedPairListLennardJonesGeneric.getFixedPairList()
(in module espressopp.interaction.Morse),
190
Index
ESPResSo++ Documentation, Release latest
108
espressopp.interaction.FixedPairListTypesHarmonic.setPotential()
espressopp.interaction.FixedPairListQuartic() (in mod(in
module
espresule espressopp.interaction.Quartic), 110
sopp.interaction.Harmonic), 82
espressopp.interaction.FixedPairListQuartic.getFixedPairList()
espressopp.interaction.FixedPairListTypesTabulated()
(in module espressopp.interaction.Quartic),
(in module espressopp.interaction.Tabulated),
110
124
espressopp.interaction.FixedPairListQuartic.setFixedPairList()
espressopp.interaction.FixedPairListTypesTabulated.setPotential()
(in module espressopp.interaction.Quartic),
(in module espressopp.interaction.Tabulated),
110
124
espressopp.interaction.FixedPairListQuartic.setPotential()espressopp.interaction.FixedPairListZero() (in module
(in module espressopp.interaction.Quartic),
espressopp.interaction.Zero), 131
110
espressopp.interaction.FixedPairListZero.setPotential()
espressopp.interaction.FixedPairListSoftCosine() (in
(in module espressopp.interaction.Zero), 131
module espressopp.interaction.SoftCosine), espressopp.interaction.FixedQuadrupleAngleListDihedralHarmonicUniqu
115
(in
module
espresespressopp.interaction.FixedPairListSoftCosine.setPotential()
sopp.interaction.DihedralHarmonicUniqueCos),
(in
module
espres78
sopp.interaction.SoftCosine), 115
espressopp.interaction.FixedQuadrupleAngleListDihedralHarmonicUniqu
espressopp.interaction.FixedPairListStillingerWeberPairTerm()
(in
module
espres(in
module
espressopp.interaction.DihedralHarmonicUniqueCos),
sopp.interaction.StillingerWeberPairTerm),
78
117
espressopp.interaction.FixedQuadrupleAngleListDihedralHarmonicUniqu
espressopp.interaction.FixedPairListStillingerWeberPairTerm.setPotential()
(in
module
espres(in
module
espressopp.interaction.DihedralHarmonicUniqueCos),
sopp.interaction.StillingerWeberPairTerm),
78
118
espressopp.interaction.FixedQuadrupleListDihedralHarmonic()
espressopp.interaction.FixedPairListStillingerWeberPairTermCapped()
(in
module
espres(in
module
espressopp.interaction.DihedralHarmonic), 76
sopp.interaction.StillingerWeberPairTermCapped),
espressopp.interaction.FixedQuadrupleListDihedralHarmonic.getFixedQu
120
(in
module
espresespressopp.interaction.FixedPairListStillingerWeberPairTermCapped.setPotential()
sopp.interaction.DihedralHarmonic), 76
(in
module
espres- espressopp.interaction.FixedQuadrupleListDihedralHarmonic.setPotential
sopp.interaction.StillingerWeberPairTermCapped),
(in
module
espres120
sopp.interaction.DihedralHarmonic), 76
espressopp.interaction.FixedPairListTabulated()
(in espressopp.interaction.FixedQuadrupleListDihedralHarmonicCos()
module
espressopp.interaction.Tabulated),
(in
module
espres123
sopp.interaction.DihedralHarmonicCos),
espressopp.interaction.FixedPairListTabulated.setPotential()
77
(in module espressopp.interaction.Tabulated), espressopp.interaction.FixedQuadrupleListDihedralHarmonicCos.getFixe
123
(in
module
espresespressopp.interaction.FixedPairListTersoffPairTerm()
sopp.interaction.DihedralHarmonicCos),
(in
module
espres77
sopp.interaction.TersoffPairTerm), 127
espressopp.interaction.FixedQuadrupleListDihedralHarmonicCos.setPote
espressopp.interaction.FixedPairListTersoffPairTerm.setPotential() (in
module
espres(in
module
espressopp.interaction.DihedralHarmonicCos),
sopp.interaction.TersoffPairTerm), 127
77
espressopp.interaction.FixedPairListTypesHarmonic()
espressopp.interaction.FixedQuadrupleListDihedralHarmonicNCos()
(in
module
espres(in
module
espressopp.interaction.Harmonic), 82
sopp.interaction.DihedralHarmonicNCos),
espressopp.interaction.FixedPairListTypesHarmonic.getFixedPairList()
77
(in
module
espres- espressopp.interaction.FixedQuadrupleListDihedralHarmonicNCos.getFix
sopp.interaction.Harmonic), 82
(in
module
espresespressopp.interaction.FixedPairListTypesHarmonic.getPotential() sopp.interaction.DihedralHarmonicNCos),
(in
module
espres77
sopp.interaction.Harmonic), 83
espressopp.interaction.FixedQuadrupleListDihedralHarmonicNCos.setPo
espressopp.interaction.FixedPairListTypesHarmonic.setFixedPairList()
(in
module
espres(in
module
espressopp.interaction.DihedralHarmonicNCos),
sopp.interaction.Harmonic), 82
77
Index
191
ESPResSo++ Documentation, Release latest
espressopp.interaction.FixedQuadrupleListDihedralRB() espressopp.interaction.FixedTripleListAngularHarmonic()
(in
module
espres(in
module
espressopp.interaction.DihedralRB), 79
sopp.interaction.AngularHarmonic), 66
espressopp.interaction.FixedQuadrupleListDihedralRB.getFixedQuadrupleList()
espressopp.interaction.FixedTripleListAngularHarmonic.setPotential()
(in
module
espres(in
module
espressopp.interaction.DihedralRB), 79
sopp.interaction.AngularHarmonic), 66
espressopp.interaction.FixedQuadrupleListDihedralRB.setPotential()
espressopp.interaction.FixedTripleListCosine()
(in
(in
module
espresmodule espressopp.interaction.Cosine), 68
sopp.interaction.DihedralRB), 79
espressopp.interaction.FixedTripleListCosine.getFixedTripleList()
espressopp.interaction.FixedQuadrupleListOPLS() (in
(in module espressopp.interaction.Cosine),
module espressopp.interaction.OPLS), 108
68
espressopp.interaction.FixedQuadrupleListOPLS.setPotential()
espressopp.interaction.FixedTripleListCosine.setPotential()
(in module espressopp.interaction.OPLS),
(in module espressopp.interaction.Cosine),
108
68
espressopp.interaction.FixedQuadrupleListTabulatedDihedral()
espressopp.interaction.FixedTripleListStillingerWeberTripleTerm()
(in
module
espres(in
module
espressopp.interaction.TabulatedDihedral), 125
sopp.interaction.StillingerWeberTripleTerm),
espressopp.interaction.FixedQuadrupleListTabulatedDihedral.setPotential()
121
(in
module
espres- espressopp.interaction.FixedTripleListStillingerWeberTripleTerm.getFixe
sopp.interaction.TabulatedDihedral), 125
(in
module
espresespressopp.interaction.FixedQuadrupleListTypesTabulatedDihedral()sopp.interaction.StillingerWeberTripleTerm),
(in
module
espres121
sopp.interaction.TabulatedDihedral), 125
espressopp.interaction.FixedTripleListStillingerWeberTripleTerm.setPoten
espressopp.interaction.FixedQuadrupleListTypesTabulatedDihedral.setPotential()
(in
module
espres(in
module
espressopp.interaction.StillingerWeberTripleTerm),
sopp.interaction.TabulatedDihedral), 125
121
espressopp.interaction.FixedTripleAngleListAngularUniqueCosineSquared()
espressopp.interaction.FixedTripleListTabulatedAngular()
(in
module
espres(in
module
espressopp.interaction.AngularUniqueCosineSquared),
sopp.interaction.TabulatedAngular), 124
66
espressopp.interaction.FixedTripleListTabulatedAngular.setPotential()
espressopp.interaction.FixedTripleAngleListAngularUniqueCosineSquared.getFixedTripleList()
(in
module
espres(in
module
espressopp.interaction.TabulatedAngular), 124
sopp.interaction.AngularUniqueCosineSquared),espressopp.interaction.FixedTripleListTersoffTripleTerm()
67
(in
module
espresespressopp.interaction.FixedTripleAngleListAngularUniqueCosineSquared.setPotential()
sopp.interaction.TersoffTripleTerm), 128
(in
module
espres- espressopp.interaction.FixedTripleListTersoffTripleTerm.getFixedTripleL
sopp.interaction.AngularUniqueCosineSquared),
(in
module
espres67
sopp.interaction.TersoffTripleTerm), 128
espressopp.interaction.FixedTripleAngleListAngularUniqueHarmonic()
espressopp.interaction.FixedTripleListTersoffTripleTerm.setPotential()
(in
module
espres(in
module
espressopp.interaction.AngularUniqueHarmonic),
sopp.interaction.TersoffTripleTerm), 128
67
espressopp.interaction.FixedTripleListTypesTabulatedAngular()
espressopp.interaction.FixedTripleAngleListAngularUniqueHarmonic.setPotential()
(in
module
espres(in
module
espressopp.interaction.TabulatedAngular), 124
sopp.interaction.AngularUniqueHarmonic),
espressopp.interaction.FixedTripleListTypesTabulatedAngular.setPotentia
67
(in
module
espresespressopp.interaction.FixedTripleListAngularCosineSquared()
sopp.interaction.TabulatedAngular), 124
(in
module
espres- espressopp.interaction.GravityTruncated (module), 81
sopp.interaction.AngularCosineSquared),
espressopp.interaction.GravityTruncated() (in module
65
espressopp.interaction.GravityTruncated), 81
espressopp.interaction.FixedTripleListAngularCosineSquared.getFixedTripleList()
espressopp.interaction.Harmonic (module), 82
(in
module
espres- espressopp.interaction.Harmonic() (in module espressopp.interaction.AngularCosineSquared),
sopp.interaction.Harmonic), 82
65
espressopp.interaction.HarmonicTrap (module), 83
espressopp.interaction.FixedTripleListAngularCosineSquared.setPotential()
espressopp.interaction.HarmonicTrap() (in module
(in
module
espresespressopp.interaction.HarmonicTrap), 83
sopp.interaction.AngularCosineSquared),
espressopp.interaction.HarmonicUnique (module), 83
65
espressopp.interaction.HarmonicUnique() (in module
192
Index
ESPResSo++ Documentation, Release latest
espressopp.interaction.HarmonicUnique), 83
sopp.interaction.LennardJonesExpand),
espressopp.interaction.Interaction (module), 84
96
espressopp.interaction.Interaction.bondType() (in mod- espressopp.interaction.LennardJonesGeneric (module),
ule espressopp.interaction.Interaction), 84
97
espressopp.interaction.Interaction.computeEnergy() (in espressopp.interaction.LennardJonesGeneric()
module espressopp.interaction.Interaction),
(in
module
espres84
sopp.interaction.LennardJonesGeneric),
espressopp.interaction.Interaction.computeEnergyAA()
97
(in
module
espres- espressopp.interaction.LennardJonesGromacs (modsopp.interaction.Interaction), 84
ule), 100
espressopp.interaction.Interaction.computeEnergyCG() espressopp.interaction.LennardJonesGromacs()
(in
module
espres(in
module
espressopp.interaction.Interaction), 84
sopp.interaction.LennardJonesGromacs),
espressopp.interaction.Interaction.computeEnergyDeriv()
101
(in
module
espres- espressopp.interaction.LennardJonesSoftcoreTI (modsopp.interaction.Interaction), 84
ule), 102
espressopp.interaction.Interaction.computeVirial() (in espressopp.interaction.LJcos (module), 104
module espressopp.interaction.Interaction), espressopp.interaction.LJcos() (in module espres84
sopp.interaction.LJcos), 104
espressopp.interaction.LennardJones (module), 84
espressopp.interaction.MirrorLennardJones (module),
espressopp.interaction.LennardJones() (in module
105
espressopp.interaction.LennardJones), 84
espressopp.interaction.MirrorLennardJones()
espressopp.interaction.LennardJones93Wall (module),
(in
module
espres87
sopp.interaction.MirrorLennardJones),
espressopp.interaction.LennardJones93Wall()
106
(in
module
espres- espressopp.interaction.Morse (module), 106
sopp.interaction.LennardJones93Wall),
espressopp.interaction.Morse() (in module espres88
sopp.interaction.Morse), 106
espressopp.interaction.LennardJones93Wall.getParams() espressopp.interaction.OPLS (module), 108
(in
module
espres- espressopp.interaction.OPLS() (in module espressopp.interaction.LennardJones93Wall),
sopp.interaction.OPLS), 108
88
espressopp.interaction.Potential (module), 109
espressopp.interaction.LennardJones93Wall.setParams() espressopp.interaction.Potential.computeEnergy() (in
(in
module
espresmodule
espressopp.interaction.Potential),
sopp.interaction.LennardJones93Wall),
109
88
espressopp.interaction.Potential.computeForce()
(in
espressopp.interaction.LennardJonesAutoBonds (modmodule
espressopp.interaction.Potential),
ule), 88
109
espressopp.interaction.LennardJonesAutoBonds()
espressopp.interaction.PotentialUniqueDist (module),
(in
module
espres109
sopp.interaction.LennardJonesAutoBonds),
espressopp.interaction.PotentialUniqueDist.computeEnergy()
88
(in
module
espresespressopp.interaction.LennardJonesCapped (module),
sopp.interaction.PotentialUniqueDist),
90
109
espressopp.interaction.LennardJonesCapped()
espressopp.interaction.PotentialUniqueDist.computeForce()
(in
module
espres(in
module
espressopp.interaction.LennardJonesCapped),
sopp.interaction.PotentialUniqueDist),
90
109
espressopp.interaction.LennardJonesEnergyCapped
espressopp.interaction.PotentialVSpherePair (module),
(module), 93
109
espressopp.interaction.LennardJonesEnergyCapped()
espressopp.interaction.PotentialVSpherePair.computeEnergy()
(in
module
espres(in
module
espressopp.interaction.LennardJonesEnergyCapped),
sopp.interaction.PotentialVSpherePair),
93
109
espressopp.interaction.LennardJonesExpand (module), espressopp.interaction.PotentialVSpherePair.computeForce()
96
(in
module
espresespressopp.interaction.LennardJonesExpand()
sopp.interaction.PotentialVSpherePair),
(in
module
espres109
Index
193
ESPResSo++ Documentation, Release latest
espressopp.interaction.Quartic (module), 109
espressopp.interaction.StillingerWeberTripleTerm
espressopp.interaction.Quartic() (in module espres(module), 120
sopp.interaction.Quartic), 109
espressopp.interaction.StillingerWeberTripleTerm()
espressopp.interaction.ReactionFieldGeneralized
(in
module
espres(module), 110
sopp.interaction.StillingerWeberTripleTerm),
espressopp.interaction.ReactionFieldGeneralized()
120
(in
module
espres- espressopp.interaction.Tabulated (module), 122
sopp.interaction.ReactionFieldGeneralized), espressopp.interaction.Tabulated() (in module espres110
sopp.interaction.Tabulated), 122
espressopp.interaction.ReactionFieldGeneralizedTI
espressopp.interaction.TabulatedAngular
(module),
(module), 112
124
espressopp.interaction.SelfVSphere()
(in
module espressopp.interaction.TabulatedAngular() (in module
espressopp.interaction.VSphereSelf), 129
espressopp.interaction.TabulatedAngular),
espressopp.interaction.SelfVSphere.getPotential() (in
124
module espressopp.interaction.VSphereSelf), espressopp.interaction.TabulatedDihedral
(module),
129
125
espressopp.interaction.SelfVSphere.setPotential() (in espressopp.interaction.TabulatedDihedral() (in module
module espressopp.interaction.VSphereSelf),
espressopp.interaction.TabulatedDihedral),
129
125
espressopp.interaction.SingleParticleHarmonicTrap()
espressopp.interaction.TersoffPairTerm (module), 126
(in
module
espres- espressopp.interaction.TersoffPairTerm() (in module
sopp.interaction.HarmonicTrap), 83
espressopp.interaction.TersoffPairTerm), 126
espressopp.interaction.SingleParticleHarmonicTrap.setPotential()
espressopp.interaction.TersoffTripleTerm
(module),
(in
module
espres127
sopp.interaction.HarmonicTrap), 83
espressopp.interaction.VerletListAdressLennardJones()
espressopp.interaction.SingleParticleLennardJones93Wall()
(in
module
espres(in
module
espressopp.interaction.LennardJones), 85
sopp.interaction.LennardJones93Wall),
espressopp.interaction.VerletListAdressLennardJones.setPotentialAT()
88
(in
module
espresespressopp.interaction.SingleParticleLennardJones93Wall.setPotential()
sopp.interaction.LennardJones), 85
(in
module
espres- espressopp.interaction.VerletListAdressLennardJones.setPotentialCG()
sopp.interaction.LennardJones93Wall),
(in
module
espres88
sopp.interaction.LennardJones), 85
espressopp.interaction.SingleParticlePotential (mod- espressopp.interaction.VerletListAdressLennardJones2()
ule), 114
(in
module
espresespressopp.interaction.SingleParticlePotential.computeEnergy()
sopp.interaction.LennardJones), 85
(in
module
espres- espressopp.interaction.VerletListAdressLennardJones2.setPotentialAT()
sopp.interaction.SingleParticlePotential),
(in
module
espres114
sopp.interaction.LennardJones), 85
espressopp.interaction.SingleParticlePotential.computeForce()
espressopp.interaction.VerletListAdressLennardJones2.setPotentialCG()
(in
module
espres(in
module
espressopp.interaction.SingleParticlePotential),
sopp.interaction.LennardJones), 85
114
espressopp.interaction.VerletListAdressLennardJonesAutoBonds()
espressopp.interaction.SoftCosine (module), 114
(in
module
espresespressopp.interaction.SoftCosine() (in module espressopp.interaction.LennardJonesAutoBonds),
sopp.interaction.SoftCosine), 115
89
espressopp.interaction.StillingerWeberPairTerm (mod- espressopp.interaction.VerletListAdressLennardJonesAutoBonds.setPoten
ule), 115
(in
module
espresespressopp.interaction.StillingerWeberPairTerm()
sopp.interaction.LennardJonesAutoBonds),
(in
module
espres89
sopp.interaction.StillingerWeberPairTerm),
espressopp.interaction.VerletListAdressLennardJonesCapped()
115
(in
module
espresespressopp.interaction.StillingerWeberPairTermCapped
sopp.interaction.LennardJonesCapped),
(module), 118
91
espressopp.interaction.StillingerWeberPairTermCapped() espressopp.interaction.VerletListAdressLennardJonesCapped.getPotential
(in
module
espres(in
module
espressopp.interaction.StillingerWeberPairTermCapped),
sopp.interaction.LennardJonesCapped),
118
91
194
Index
ESPResSo++ Documentation, Release latest
espressopp.interaction.VerletListAdressLennardJonesCapped.getPotentialCG()
espressopp.interaction.VerletListAdressLJcos.setPotentialAT()
(in
module
espres(in module espressopp.interaction.LJcos),
sopp.interaction.LennardJonesCapped),
104
91
espressopp.interaction.VerletListAdressLJcos.setPotentialCG()
espressopp.interaction.VerletListAdressLennardJonesCapped.setPotentialAT()
(in module espressopp.interaction.LJcos),
(in
module
espres104
sopp.interaction.LennardJonesCapped),
espressopp.interaction.VerletListAdressMorse()
(in
91
module espressopp.interaction.Morse), 107
espressopp.interaction.VerletListAdressLennardJonesCapped.setPotentialCG()
espressopp.interaction.VerletListAdressMorse.setPotentialAT()
(in
module
espres(in module espressopp.interaction.Morse),
sopp.interaction.LennardJonesCapped),
107
91
espressopp.interaction.VerletListAdressMorse.setPotentialCG()
espressopp.interaction.VerletListAdressLennardJonesEnergyCapped()
(in module espressopp.interaction.Morse),
(in
module
espres107
sopp.interaction.LennardJonesEnergyCapped), espressopp.interaction.VerletListAdressReactionFieldGeneralized()
94
(in
module
espresespressopp.interaction.VerletListAdressLennardJonesEnergyCapped.getPotentialAT()
sopp.interaction.ReactionFieldGeneralized),
(in
module
espres111
sopp.interaction.LennardJonesEnergyCapped), espressopp.interaction.VerletListAdressReactionFieldGeneralized.setPote
94
(in
module
espresespressopp.interaction.VerletListAdressLennardJonesEnergyCapped.getPotentialCG()
sopp.interaction.ReactionFieldGeneralized),
(in
module
espres111
sopp.interaction.LennardJonesEnergyCapped), espressopp.interaction.VerletListAdressReactionFieldGeneralized.setPote
94
(in
module
espresespressopp.interaction.VerletListAdressLennardJonesEnergyCapped.setPotentialAT()
sopp.interaction.ReactionFieldGeneralized),
(in
module
espres111
sopp.interaction.LennardJonesEnergyCapped), espressopp.interaction.VerletListAdressStillingerWeberPairTerm()
94
(in
module
espresespressopp.interaction.VerletListAdressLennardJonesEnergyCapped.setPotentialCG()
sopp.interaction.StillingerWeberPairTerm),
(in
module
espres116
sopp.interaction.LennardJonesEnergyCapped), espressopp.interaction.VerletListAdressStillingerWeberPairTerm.setPoten
94
(in
module
espresespressopp.interaction.VerletListAdressLennardJonesGeneric()
sopp.interaction.StillingerWeberPairTerm),
(in
module
espres116
sopp.interaction.LennardJonesGeneric),
espressopp.interaction.VerletListAdressStillingerWeberPairTerm.setPoten
98
(in
module
espresespressopp.interaction.VerletListAdressLennardJonesGeneric.setPotentialAT()
sopp.interaction.StillingerWeberPairTerm),
(in
module
espres116
sopp.interaction.LennardJonesGeneric),
espressopp.interaction.VerletListAdressStillingerWeberPairTermCapped()
98
(in
module
espresespressopp.interaction.VerletListAdressLennardJonesGeneric.setPotentialCG()
sopp.interaction.StillingerWeberPairTermCapped),
(in
module
espres119
sopp.interaction.LennardJonesGeneric),
espressopp.interaction.VerletListAdressStillingerWeberPairTermCapped.s
98
(in
module
espresespressopp.interaction.VerletListAdressLennardJonesGeneric2() sopp.interaction.StillingerWeberPairTermCapped),
(in
module
espres119
sopp.interaction.LennardJonesGeneric),
espressopp.interaction.VerletListAdressStillingerWeberPairTermCapped.s
98
(in
module
espresespressopp.interaction.VerletListAdressLennardJonesGeneric2.setPotentialAT()
sopp.interaction.StillingerWeberPairTermCapped),
(in
module
espres119
sopp.interaction.LennardJonesGeneric),
espressopp.interaction.VerletListAdressTabulated() (in
98
module
espressopp.interaction.Tabulated),
espressopp.interaction.VerletListAdressLennardJonesGeneric2.setPotentialCG()
122
(in
module
espres- espressopp.interaction.VerletListAdressTabulated.setPotentialAT()
sopp.interaction.LennardJonesGeneric),
(in module espressopp.interaction.Tabulated),
99
122
espressopp.interaction.VerletListAdressLJcos()
(in espressopp.interaction.VerletListAdressTabulated.setPotentialCG()
module espressopp.interaction.LJcos), 104
(in module espressopp.interaction.Tabulated),
Index
195
ESPResSo++ Documentation, Release latest
122
(in
module
espresespressopp.interaction.VerletListAdressZero() (in modsopp.interaction.LennardJones), 86
ule espressopp.interaction.Zero), 130
espressopp.interaction.VerletListHadressLennardJones2.setPotentialCG()
espressopp.interaction.VerletListAdressZero.setFixedTupleList() (in
module
espres(in module espressopp.interaction.Zero), 130
sopp.interaction.LennardJones), 86
espressopp.interaction.VerletListAdressZero.setPotentialAT()
espressopp.interaction.VerletListHadressLennardJonesAutoBonds()
(in module espressopp.interaction.Zero), 130
(in
module
espresespressopp.interaction.VerletListAdressZero.setPotentialCG()
sopp.interaction.LennardJonesAutoBonds),
(in module espressopp.interaction.Zero), 130
89
espressopp.interaction.VerletListCoulombRSpace()
espressopp.interaction.VerletListHadressLennardJonesAutoBonds.setPote
(in
module
espres(in
module
espressopp.interaction.CoulombRSpace), 71
sopp.interaction.LennardJonesAutoBonds),
espressopp.interaction.VerletListCoulombRSpace.getPotential()
89
(in
module
espres- espressopp.interaction.VerletListHadressLennardJonesCapped()
sopp.interaction.CoulombRSpace), 72
(in
module
espresespressopp.interaction.VerletListCoulombRSpace.getVerletList() sopp.interaction.LennardJonesCapped),
(in
module
espres91
sopp.interaction.CoulombRSpace), 72
espressopp.interaction.VerletListHadressLennardJonesCapped.getPotentia
espressopp.interaction.VerletListCoulombRSpace.setPotential()
(in
module
espres(in
module
espressopp.interaction.LennardJonesCapped),
sopp.interaction.CoulombRSpace), 72
92
espressopp.interaction.VerletListCoulombTruncatedUniqueCharge()
espressopp.interaction.VerletListHadressLennardJonesCapped.getPotentia
(in
module
espres(in
module
espressopp.interaction.CoulombTruncatedUniqueCharge),
sopp.interaction.LennardJonesCapped),
73
92
espressopp.interaction.VerletListCoulombTruncatedUniqueCharge.getPotential()
espressopp.interaction.VerletListHadressLennardJonesCapped.setPotentia
(in
module
espres(in
module
espressopp.interaction.CoulombTruncatedUniqueCharge),
sopp.interaction.LennardJonesCapped),
73
92
espressopp.interaction.VerletListCoulombTruncatedUniqueCharge.setPotential()
espressopp.interaction.VerletListHadressLennardJonesCapped.setPotentia
(in
module
espres(in
module
espressopp.interaction.CoulombTruncatedUniqueCharge),
sopp.interaction.LennardJonesCapped),
74
92
espressopp.interaction.VerletListGravityTruncated()
espressopp.interaction.VerletListHadressLennardJonesEnergyCapped()
(in
module
espres(in
module
espressopp.interaction.GravityTruncated), 81
sopp.interaction.LennardJonesEnergyCapped),
espressopp.interaction.VerletListGravityTruncated.getPotential() 94
(in
module
espres- espressopp.interaction.VerletListHadressLennardJonesEnergyCapped.getP
sopp.interaction.GravityTruncated), 81
(in
module
espresespressopp.interaction.VerletListGravityTruncated.getVerletList() sopp.interaction.LennardJonesEnergyCapped),
(in
module
espres94
sopp.interaction.GravityTruncated), 81
espressopp.interaction.VerletListHadressLennardJonesEnergyCapped.getP
espressopp.interaction.VerletListGravityTruncated.setPotential() (in
module
espres(in
module
espressopp.interaction.LennardJonesEnergyCapped),
sopp.interaction.GravityTruncated), 81
95
espressopp.interaction.VerletListHadressLennardJones() espressopp.interaction.VerletListHadressLennardJonesEnergyCapped.setP
(in
module
espres(in
module
espressopp.interaction.LennardJones), 86
sopp.interaction.LennardJonesEnergyCapped),
espressopp.interaction.VerletListHadressLennardJones.setPotentialAT()
95
(in
module
espres- espressopp.interaction.VerletListHadressLennardJonesEnergyCapped.setP
sopp.interaction.LennardJones), 86
(in
module
espresespressopp.interaction.VerletListHadressLennardJones.setPotentialCG()
sopp.interaction.LennardJonesEnergyCapped),
(in
module
espres95
sopp.interaction.LennardJones), 86
espressopp.interaction.VerletListHadressLennardJonesGeneric()
espressopp.interaction.VerletListHadressLennardJones2()
(in
module
espres(in
module
espressopp.interaction.LennardJonesGeneric),
sopp.interaction.LennardJones), 86
99
espressopp.interaction.VerletListHadressLennardJones2.setPotentialAT()
espressopp.interaction.VerletListHadressLennardJonesGeneric.setPotentia
196
Index
ESPResSo++ Documentation, Release latest
(in
module
espres117
sopp.interaction.LennardJonesGeneric),
espressopp.interaction.VerletListHadressStillingerWeberPairTermCapped
99
(in
module
espresespressopp.interaction.VerletListHadressLennardJonesGeneric.setPotentialCG()
sopp.interaction.StillingerWeberPairTermCapped),
(in
module
espres119
sopp.interaction.LennardJonesGeneric),
espressopp.interaction.VerletListHadressStillingerWeberPairTermCapped
99
(in
module
espresespressopp.interaction.VerletListHadressLennardJonesGeneric2() sopp.interaction.StillingerWeberPairTermCapped),
(in
module
espres119
sopp.interaction.LennardJonesGeneric),
espressopp.interaction.VerletListHadressStillingerWeberPairTermCapped
99
(in
module
espresespressopp.interaction.VerletListHadressLennardJonesGeneric2.setPotentialAT()
sopp.interaction.StillingerWeberPairTermCapped),
(in
module
espres119
sopp.interaction.LennardJonesGeneric),
espressopp.interaction.VerletListHadressTabulated()
99
(in module espressopp.interaction.Tabulated),
espressopp.interaction.VerletListHadressLennardJonesGeneric2.setPotentialCG()
122
(in
module
espres- espressopp.interaction.VerletListHadressTabulated.setPotentialAT()
sopp.interaction.LennardJonesGeneric),
(in module espressopp.interaction.Tabulated),
100
122
espressopp.interaction.VerletListHadressLJcos()
(in espressopp.interaction.VerletListHadressTabulated.setPotentialCG()
module espressopp.interaction.LJcos), 105
(in module espressopp.interaction.Tabulated),
espressopp.interaction.VerletListHadressLJcos.setPotentialAT()
123
(in module espressopp.interaction.LJcos), espressopp.interaction.VerletListHadressZero()
(in
105
module espressopp.interaction.Zero), 130
espressopp.interaction.VerletListHadressLJcos.setPotentialCG()
espressopp.interaction.VerletListHadressZero.setFixedTupleList()
(in module espressopp.interaction.LJcos),
(in module espressopp.interaction.Zero), 130
105
espressopp.interaction.VerletListHadressZero.setPotentialAT()
espressopp.interaction.VerletListHadressMorse() (in
(in module espressopp.interaction.Zero), 130
module espressopp.interaction.Morse), 107
espressopp.interaction.VerletListHadressZero.setPotentialCG()
espressopp.interaction.VerletListHadressMorse.setPotentialAT() (in module espressopp.interaction.Zero), 131
(in module espressopp.interaction.Morse), espressopp.interaction.VerletListLennardJones()
107
(in
module
espresespressopp.interaction.VerletListHadressMorse.setPotentialCG() sopp.interaction.LennardJones), 84
(in module espressopp.interaction.Morse), espressopp.interaction.VerletListLennardJones.getPotential()
107
(in
module
espresespressopp.interaction.VerletListHadressReactionFieldGeneralized()sopp.interaction.LennardJones), 84
(in
module
espres- espressopp.interaction.VerletListLennardJones.getVerletList()
sopp.interaction.ReactionFieldGeneralized),
(in
module
espres111
sopp.interaction.LennardJones), 85
espressopp.interaction.VerletListHadressReactionFieldGeneralized.setPotentialAT()
espressopp.interaction.VerletListLennardJones.setPotential()
(in
module
espres(in
module
espressopp.interaction.ReactionFieldGeneralized),
sopp.interaction.LennardJones), 85
111
espressopp.interaction.VerletListLennardJonesAutoBonds()
espressopp.interaction.VerletListHadressReactionFieldGeneralized.setPotentialCG()
(in
module
espres(in
module
espressopp.interaction.LennardJonesAutoBonds),
sopp.interaction.ReactionFieldGeneralized),
88
112
espressopp.interaction.VerletListLennardJonesAutoBonds.getPotential()
espressopp.interaction.VerletListHadressStillingerWeberPairTerm() (in
module
espres(in
module
espressopp.interaction.LennardJonesAutoBonds),
sopp.interaction.StillingerWeberPairTerm),
88
117
espressopp.interaction.VerletListLennardJonesAutoBonds.getVerletList()
espressopp.interaction.VerletListHadressStillingerWeberPairTerm.setPotentialAT()
(in
module
espres(in
module
espressopp.interaction.LennardJonesAutoBonds),
sopp.interaction.StillingerWeberPairTerm),
89
117
espressopp.interaction.VerletListLennardJonesAutoBonds.setPotential()
espressopp.interaction.VerletListHadressStillingerWeberPairTerm.setPotentialCG()
(in
module
espres(in
module
espressopp.interaction.LennardJonesAutoBonds),
sopp.interaction.StillingerWeberPairTerm),
89
Index
197
ESPResSo++ Documentation, Release latest
espressopp.interaction.VerletListLennardJonesCapped()
sopp.interaction.LennardJonesGromacs),
(in
module
espres101
sopp.interaction.LennardJonesCapped),
espressopp.interaction.VerletListLennardJonesGromacs.setPotential()
90
(in
module
espresespressopp.interaction.VerletListLennardJonesCapped.getPotential()sopp.interaction.LennardJonesGromacs),
(in
module
espres101
sopp.interaction.LennardJonesCapped),
espressopp.interaction.VerletListLJcos() (in module
90
espressopp.interaction.LJcos), 104
espressopp.interaction.VerletListLennardJonesCapped.setPotential()
espressopp.interaction.VerletListLJcos.getPotential()
(in
module
espres(in module espressopp.interaction.LJcos),
sopp.interaction.LennardJonesCapped),
104
90
espressopp.interaction.VerletListLJcos.getVerletList()
espressopp.interaction.VerletListLennardJonesEnergyCapped()
(in module espressopp.interaction.LJcos),
(in
module
espres104
sopp.interaction.LennardJonesEnergyCapped), espressopp.interaction.VerletListLJcos.setPotential()
93
(in module espressopp.interaction.LJcos),
espressopp.interaction.VerletListLennardJonesEnergyCapped.getPotential()
104
(in
module
espres- espressopp.interaction.VerletListMorse() (in module
sopp.interaction.LennardJonesEnergyCapped),
espressopp.interaction.Morse), 106
93
espressopp.interaction.VerletListMorse.getPotential()
espressopp.interaction.VerletListLennardJonesEnergyCapped.setPotential()
(in module espressopp.interaction.Morse),
(in
module
espres106
sopp.interaction.LennardJonesEnergyCapped), espressopp.interaction.VerletListMorse.setPotential()
93
(in module espressopp.interaction.Morse),
espressopp.interaction.VerletListLennardJonesExpand()
107
(in
module
espres- espressopp.interaction.VerletListReactionFieldGeneralized()
sopp.interaction.LennardJonesExpand),
(in
module
espres96
sopp.interaction.ReactionFieldGeneralized),
espressopp.interaction.VerletListLennardJonesExpand.getPotential()110
(in
module
espres- espressopp.interaction.VerletListReactionFieldGeneralized.getPotential()
sopp.interaction.LennardJonesExpand),
(in
module
espres96
sopp.interaction.ReactionFieldGeneralized),
espressopp.interaction.VerletListLennardJonesExpand.setPotential()110
(in
module
espres- espressopp.interaction.VerletListReactionFieldGeneralized.setPotential()
sopp.interaction.LennardJonesExpand),
(in
module
espres96
sopp.interaction.ReactionFieldGeneralized),
espressopp.interaction.VerletListLennardJonesGeneric()
111
(in
module
espres- espressopp.interaction.VerletListSoftCosine() (in modsopp.interaction.LennardJonesGeneric),
ule espressopp.interaction.SoftCosine), 115
97
espressopp.interaction.VerletListSoftCosine.setPotential()
espressopp.interaction.VerletListLennardJonesGeneric.getPotential()(in
module
espres(in
module
espressopp.interaction.SoftCosine), 115
sopp.interaction.LennardJonesGeneric),
espressopp.interaction.VerletListStillingerWeberPairTerm()
97
(in
module
espresespressopp.interaction.VerletListLennardJonesGeneric.getVerletList()
sopp.interaction.StillingerWeberPairTerm),
(in
module
espres116
sopp.interaction.LennardJonesGeneric),
espressopp.interaction.VerletListStillingerWeberPairTerm.getPotential()
98
(in
module
espresespressopp.interaction.VerletListLennardJonesGeneric.setPotential()sopp.interaction.StillingerWeberPairTerm),
(in
module
espres116
sopp.interaction.LennardJonesGeneric),
espressopp.interaction.VerletListStillingerWeberPairTerm.getVerletList()
98
(in
module
espresespressopp.interaction.VerletListLennardJonesGromacs()
sopp.interaction.StillingerWeberPairTerm),
(in
module
espres116
sopp.interaction.LennardJonesGromacs),
espressopp.interaction.VerletListStillingerWeberPairTerm.setPotential()
101
(in
module
espresespressopp.interaction.VerletListLennardJonesGromacs.getPotential()
sopp.interaction.StillingerWeberPairTerm),
(in
module
espres116
198
Index
ESPResSo++ Documentation, Release latest
espressopp.interaction.VerletListStillingerWeberPairTermCapped() sopp.interaction.TersoffTripleTerm), 127
(in
module
espres- espressopp.interaction.VerletListTersoffTripleTerm.getPotential()
sopp.interaction.StillingerWeberPairTermCapped),
(in
module
espres118
sopp.interaction.TersoffTripleTerm), 127
espressopp.interaction.VerletListStillingerWeberPairTermCapped.getCaprad()
espressopp.interaction.VerletListTersoffTripleTerm.getVerletListTriple()
(in
module
espres(in
module
espressopp.interaction.StillingerWeberPairTermCapped),
sopp.interaction.TersoffTripleTerm), 127
118
espressopp.interaction.VerletListTersoffTripleTerm.setPotential()
espressopp.interaction.VerletListStillingerWeberPairTermCapped.getPotential()
(in
module
espres(in
module
espressopp.interaction.TersoffTripleTerm), 127
sopp.interaction.StillingerWeberPairTermCapped),
espressopp.interaction.VerletListVSpherePair()
(in
118
module espressopp.interaction.VSpherePair),
espressopp.interaction.VerletListStillingerWeberPairTermCapped.getVerletList()
128
(in
module
espres- espressopp.interaction.VerletListVSpherePair.getPotential()
sopp.interaction.StillingerWeberPairTermCapped),
(in
module
espres118
sopp.interaction.VSpherePair), 128
espressopp.interaction.VerletListStillingerWeberPairTermCapped.setPotential()
espressopp.interaction.VerletListVSpherePair.getVerletList()
(in
module
espres(in
module
espressopp.interaction.StillingerWeberPairTermCapped),
sopp.interaction.VSpherePair), 128
118
espressopp.interaction.VerletListVSpherePair.setPotential()
espressopp.interaction.VerletListStillingerWeberTripleTerm()
(in
module
espres(in
module
espressopp.interaction.VSpherePair), 129
sopp.interaction.StillingerWeberTripleTerm), espressopp.interaction.VerletListZero() (in module
121
espressopp.interaction.Zero), 129
espressopp.interaction.VerletListStillingerWeberTripleTerm.getPotential()
espressopp.interaction.VerletListZero.getPotential() (in
(in
module
espresmodule espressopp.interaction.Zero), 130
sopp.interaction.StillingerWeberTripleTerm), espressopp.interaction.VerletListZero.setFixedTupleList()
121
(in module espressopp.interaction.Zero), 130
espressopp.interaction.VerletListStillingerWeberTripleTerm.getVerletListTriple()
espressopp.interaction.VerletListZero.setPotential() (in
(in
module
espresmodule espressopp.interaction.Zero), 130
sopp.interaction.StillingerWeberTripleTerm), espressopp.interaction.VSpherePair (module), 128
121
espressopp.interaction.VSpherePair()
(in
module
espressopp.interaction.VerletListStillingerWeberTripleTerm.setPotential()
espressopp.interaction.VSpherePair), 128
(in
module
espres- espressopp.interaction.VSphereSelf (module), 129
sopp.interaction.StillingerWeberTripleTerm), espressopp.interaction.VSphereSelf()
(in
module
121
espressopp.interaction.VSphereSelf), 129
espressopp.interaction.VerletListTabulated() (in mod- espressopp.interaction.Zero (module), 129
ule espressopp.interaction.Tabulated), 123
espressopp.interaction.Zero() (in module espresespressopp.interaction.VerletListTabulated.getPotential()
sopp.interaction.Zero), 129
(in module espressopp.interaction.Tabulated), espressopp.io.DumpGRO (module), 131
123
espressopp.io.DumpGRO() (in module espresespressopp.interaction.VerletListTabulated.setPotential()
sopp.io.DumpGRO), 132
(in module espressopp.interaction.Tabulated), espressopp.io.DumpGRO.dump() (in module espres123
sopp.io.DumpGRO), 132
espressopp.interaction.VerletListTersoffPairTerm()
espressopp.io.DumpGROAdress (module), 132
(in
module
espres- espressopp.io.DumpGROAdress() (in module espressopp.interaction.TersoffPairTerm), 126
sopp.io.DumpGROAdress), 133
espressopp.interaction.VerletListTersoffPairTerm.getPotential()
espressopp.io.DumpGROAdress.dump() (in module
(in
module
espresespressopp.io.DumpGROAdress), 133
sopp.interaction.TersoffPairTerm), 126
espressopp.io.DumpXYZ (module), 133
espressopp.interaction.VerletListTersoffPairTerm.getVerletList()
espressopp.io.DumpXYZ() (in module espres(in
module
espressopp.io.DumpXYZ), 134
sopp.interaction.TersoffPairTerm), 126
espressopp.io.DumpXYZ.dump() (in module espresespressopp.interaction.VerletListTersoffPairTerm.setPotential()
sopp.io.DumpXYZ), 134
(in
module
espres- espressopp.MissingFixedPairList() (in module espressopp.interaction.TersoffPairTerm), 126
sopp.Exceptions), 135
espressopp.interaction.VerletListTersoffTripleTerm()
espressopp.MultiSystem (module), 142
(in
module
espres- espressopp.MultiSystem()
(in
module
espres-
Index
199
ESPResSo++ Documentation, Release latest
sopp.MultiSystem), 142
espressopp.ParticleGroup.has() (in module espresespressopp.MultiSystem.beginSystemDefinition() (in
sopp.ParticleGroup), 144
module espressopp.MultiSystem), 142
espressopp.ParticleGroup.show() (in module espresespressopp.MultiSystem.runAnalysisNPart() (in modsopp.ParticleGroup), 144
ule espressopp.MultiSystem), 142
espressopp.ParticleGroup.size() (in module espresespressopp.MultiSystem.runAnalysisPotential()
(in
sopp.ParticleGroup), 144
module espressopp.MultiSystem), 142
espressopp.pmi (module), 144
espressopp.MultiSystem.runAnalysisTemperature() (in espressopp.Quaternion (module), 148
module espressopp.MultiSystem), 142
espressopp.Real3D (module), 149
espressopp.MultiSystem.runIntegrator() (in module espressopp.RealND (module), 150
espressopp.MultiSystem), 142
espressopp.standard_system.Default (module), 154
espressopp.MultiSystem.setAnalysisNPart() (in module espressopp.standard_system.KGMelt (module), 155
espressopp.MultiSystem), 142
espressopp.standard_system.KGMelt() (in module
espressopp.MultiSystem.setAnalysisPotential()
(in
espressopp.standard_system.KGMelt), 155
module espressopp.MultiSystem), 142
espressopp.standard_system.LennardJones (module),
espressopp.MultiSystem.setAnalysisTemperature() (in
155
module espressopp.MultiSystem), 142
espressopp.standard_system.LennardJones()
espressopp.MultiSystem.setIntegrator() (in module
(in
module
espresespressopp.MultiSystem), 142
sopp.standard_system.LennardJones),
espressopp.ParallelTempering (module), 142
155
espressopp.ParallelTempering() (in module espres- espressopp.standard_system.Minimal (module), 155
sopp.ParallelTempering), 142
espressopp.standard_system.Minimal() (in module
espressopp.ParallelTempering.endDefiningSystem() (in
espressopp.standard_system.Minimal), 155
module espressopp.ParallelTempering), 142
espressopp.standard_system.PolymerMelt (module),
espressopp.ParallelTempering.exchange() (in module
156
espressopp.ParallelTempering), 142
espressopp.standard_system.PolymerMelt() (in module
espressopp.ParallelTempering.getNumberOfCPUsPerSystem()
espressopp.standard_system.PolymerMelt),
(in module espressopp.ParallelTempering),
156
143
espressopp.storage.DomainDecomposition (module),
espressopp.ParallelTempering.getNumberOfSystems()
156
(in module espressopp.ParallelTempering), espressopp.storage.DomainDecomposition()
143
(in
module
espresespressopp.ParallelTempering.run() (in module espressopp.storage.DomainDecomposition),
sopp.ParallelTempering), 143
156
espressopp.ParallelTempering.setAnalysisE() (in mod- espressopp.storage.DomainDecomposition.getCellGrid()
ule espressopp.ParallelTempering), 143
(in
module
espresespressopp.ParallelTempering.setAnalysisNPart() (in
sopp.storage.DomainDecomposition),
module espressopp.ParallelTempering), 143
156
espressopp.ParallelTempering.setAnalysisT() (in mod- espressopp.storage.DomainDecomposition.getNodeGrid()
ule espressopp.ParallelTempering), 143
(in
module
espresespressopp.ParallelTempering.setIntegrator() (in modsopp.storage.DomainDecomposition),
ule espressopp.ParallelTempering), 143
156
espressopp.ParallelTempering.startDefiningSystem()
espressopp.storage.DomainDecompositionAdress
(in module espressopp.ParallelTempering),
(module), 156
143
espressopp.storage.DomainDecompositionAdress()
espressopp.Particle (module), 143
(in
module
espresespressopp.Particle() (in module espressopp.Particle),
sopp.storage.DomainDecompositionAdress),
143
157
espressopp.ParticleAccess (module), 143
espressopp.storage.DomainDecompositionNonBlocking
espressopp.ParticleAccess.perform_action() (in module
(module), 157
espressopp.ParticleAccess), 143
espressopp.storage.DomainDecompositionNonBlocking()
espressopp.ParticleDoesNotExistHere() (in module
(in
module
espresespressopp.Exceptions), 134
sopp.storage.DomainDecompositionNonBlocking),
espressopp.ParticleGroup (module), 143
157
espressopp.ParticleGroup() (in module espres- espressopp.storage.Storage (module), 157
sopp.ParticleGroup), 144
espressopp.storage.Storage.addAdrATParticle()
(in
espressopp.ParticleGroup.add() (in module espresmodule espressopp.storage.Storage), 158
sopp.ParticleGroup), 144
espressopp.storage.Storage.addParticle() (in module
200
Index
ESPResSo++ Documentation, Release latest
espressopp.storage.Storage), 158
espressopp.storage.Storage.addParticles() (in module
espressopp.storage.Storage), 158
espressopp.storage.Storage.clearSavedPositions() (in
module espressopp.storage.Storage), 158
espressopp.storage.Storage.getParticle() (in module
espressopp.storage.Storage), 158
espressopp.storage.Storage.getRealParticleIDs()
(in
module espressopp.storage.Storage), 159
espressopp.storage.Storage.modifyParticle() (in module espressopp.storage.Storage), 159
espressopp.storage.Storage.particleExists() (in module
espressopp.storage.Storage), 159
espressopp.storage.Storage.printRealParticles()
(in
module espressopp.storage.Storage), 159
espressopp.storage.Storage.removeAllParticles()
(in
module espressopp.storage.Storage), 159
espressopp.storage.Storage.removeParticle() (in module espressopp.storage.Storage), 159
espressopp.storage.Storage.restorePositions() (in module espressopp.storage.Storage), 159
espressopp.storage.Storage.savePositions() (in module
espressopp.storage.Storage), 159
espressopp.storage.Storage.setFixedTuplesAdress() (in
module espressopp.storage.Storage), 159
espressopp.System (module), 150
espressopp.System() (in module espressopp.System),
151
espressopp.System.addInteraction() (in module espressopp.System), 151
espressopp.System.getAllInteractions() (in module
espressopp.System), 151
espressopp.System.getInteraction() (in module espressopp.System), 151
espressopp.System.getNumberOfInteractions()
(in
module espressopp.System), 151
espressopp.System.removeInteraction() (in module
espressopp.System), 151
espressopp.System.removeInteractionByName()
(in
module espressopp.System), 151
espressopp.System.scaleVolume() (in module espressopp.System), 151
espressopp.System.setTrace() (in module espressopp.System), 151
espressopp.Tensor (module), 151
espressopp.toInt3D() (in module espressopp.Int3D),
141
espressopp.toInt3DFromVector() (in module espressopp.Int3D), 141
espressopp.tools.analyse (module), 160
espressopp.tools.applyBoreschRestraints()
(in
module
espressopp.tools.prepareComplexMolecules),
169
espressopp.tools.decomp (module), 161
espressopp.tools.DumpConfigurations (module), 163
espressopp.tools.espresso_old (module), 164
espressopp.tools.findConstrainedBonds()
Index
(in
module
espressopp.tools.prepareComplexMolecules),
168
espressopp.tools.getInternalNonbondedInteractions()
(in
module
espressopp.tools.prepareComplexMolecules),
168
espressopp.tools.gromacs (module), 164
espressopp.tools.info (module), 160
espressopp.tools.io_extended (module), 166
espressopp.tools.lammps (module), 166
espressopp.tools.lattice (module), 160
espressopp.tools.pathintegral (module), 167
espressopp.tools.pdb (module), 167
espressopp.tools.pdbread() (in module espressopp.tools.pdb), 167
espressopp.tools.pdbwrite() (in module espressopp.tools.pdb), 167
espressopp.tools.povwrite (module), 168
espressopp.tools.prepareAdress (module), 169
espressopp.tools.prepareComplexMolecules (module),
168
espressopp.tools.psf (module), 169
espressopp.tools.psfread()
(in
module
espressopp.tools.psf), 170
espressopp.tools.psfwrite() (in module espressopp.tools.psf), 170
espressopp.tools.readSimpleSystem()
(in
module
espressopp.tools.prepareComplexMolecules),
168
espressopp.tools.replicate (module), 161
espressopp.tools.tabulated (module), 170
espressopp.tools.timers (module), 160
espressopp.tools.topology (module), 161
espressopp.tools.topology_helper (module), 170
espressopp.tools.units (module), 170
espressopp.tools.velocities (module), 161
espressopp.tools.vmd (module), 160
espressopp.tools.warmup (module), 161
espressopp.toReal3D() (in module espressopp.Real3D),
150
espressopp.toReal3DFromVector() (in module espressopp.Real3D), 150
espressopp.toRealND()
(in
module
espressopp.RealND), 150
espressopp.toRealNDFromVector() (in module espressopp.RealND), 150
espressopp.UnknownParticleProperty() (in module
espressopp.Exceptions), 135
espressopp.VerletList (module), 152
espressopp.VerletList()
(in
module
espressopp.VerletList), 152
espressopp.VerletList.exclude() (in module espressopp.VerletList), 152
espressopp.VerletList.getAllPairs() (in module espressopp.VerletList), 152
espressopp.VerletList.localSize() (in module espres-
201
ESPResSo++ Documentation, Release latest
sopp.VerletList), 152
(in
module
espresespressopp.VerletList.totalSize() (in module espressopp.interaction.LennardJonesSoftcoreTI),
sopp.VerletList), 152
103
espressopp.VerletListAdress (module), 152
espressopppp.interaction.VerletListAdressLennardJones.setPotentialAT()
espressopp.VerletListAdress() (in module espres(in
module
espressopp.VerletListAdress), 153
sopp.interaction.LennardJonesSoftcoreTI),
espressopp.VerletListAdress.addAdrParticles()
(in
103
module espressopp.VerletListAdress), 153
espressopppp.interaction.VerletListAdressLennardJones.setPotentialCG()
espressopp.VerletListAdress.exclude() (in module
(in
module
espresespressopp.VerletListAdress), 153
sopp.interaction.LennardJonesSoftcoreTI),
espressopp.VerletListAdress.rebuild() (in module
103
espressopp.VerletListAdress), 153
espressopppp.interaction.VerletListAdressReactionFieldGeneralized()
espressopp.VerletListAdress.totalSize() (in module
(in
module
espresespressopp.VerletListAdress), 153
sopp.interaction.ReactionFieldGeneralizedTI),
espressopp.VerletListTriple (module), 154
113
espressopp.VerletListTriple() (in module espres- espressopppp.interaction.VerletListAdressReactionFieldGeneralized.setPo
sopp.VerletListTriple), 154
(in
module
espresespressopp.VerletListTriple.exclude()
(in
module
sopp.interaction.ReactionFieldGeneralizedTI),
espressopp.VerletListTriple), 154
114
espressopp.VerletListTriple.getAllTriples() (in module espressopppp.interaction.VerletListAdressReactionFieldGeneralized.setPo
espressopp.VerletListTriple), 154
(in
module
espresespressopp.VerletListTriple.localSize() (in module
sopp.interaction.ReactionFieldGeneralizedTI),
espressopp.VerletListTriple), 154
114
espressopp.VerletListTriple.totalSize() (in module espressopppp.interaction.VerletListCoulombTruncated()
espressopp.VerletListTriple), 154
(in
module
espresespressopp.Version (module), 154
sopp.interaction.CoulombTruncated), 72
espressopp.Version() (in module espressopp.Version), espressopppp.interaction.VerletListCoulombTruncated.getPotential()
154
(in
module
espresespressopppp.integrator.Rattle() (in module espressopp.interaction.CoulombTruncated), 72
sopp.integrator.Rattle), 63
espressopppp.interaction.VerletListCoulombTruncated.setPotential()
espressopppp.integrator.Rattle.addConstrainedBonds()
(in
module
espres(in module espressopp.integrator.Rattle), 63
sopp.interaction.CoulombTruncated), 72
espressopppp.interaction.CoulombTruncated()
exec_() (in module espressopp.pmi), 145
(in
module
espresF
sopp.interaction.CoulombTruncated), 72
espressopppp.interaction.FixedPairListTypesCoulombTruncated()
f_max
(in
module
espres(in
module
espressopp.integrator.MinimizeEnergy), 61
sopp.interaction.CoulombTruncated), 73
fastreadxyz()
(in
module
espresespressopppp.interaction.FixedPairListTypesCoulombTruncated.setPotential()
sopp.tools.DumpConfigurations), 163
(in
module
espres- fastwritexyz()
(in
module
espressopp.interaction.CoulombTruncated), 73
sopp.tools.DumpConfigurations), 163
espressopppp.interaction.LennardJonesSoftcoreTI()
fastwritexyz_standard()
(in
module
espres(in
module
espressopp.tools.DumpConfigurations), 163
sopp.interaction.LennardJonesSoftcoreTI),
FENECapped
(class
in
espres103
sopp.interaction.FENECapped), 81
espressopppp.interaction.LennardJonesSoftcoreTI.addPids()
final_info() (in module espressopp.tools.analyse), 160
(in
module
espres- finalizeWorkers() (in module espressopp.pmi), 147
sopp.interaction.LennardJonesSoftcoreTI),
FixedQuadrupleListDihedralHarmonicLocal (class in
103
espressopp.interaction.DihedralHarmonic),
espressopppp.interaction.ReactionFieldGeneralizedTI()
76
(in
module
espres- FixedQuadrupleListDihedralHarmonicNCosLocal
sopp.interaction.ReactionFieldGeneralizedTI),
(class
in
espres113
sopp.interaction.DihedralHarmonicNCos),
espressopppp.interaction.ReactionFieldGeneralizedTI.addPids()
77
(in
module
espressopp.interaction.ReactionFieldGeneralizedTI), G
113
gaussian() (in module espressopp.tools.velocities), 161
espressopppp.interaction.VerletListAdressLennardJones() getAllBonds() (in module espressopp.tools.info), 160
202
Index
ESPResSo++ Documentation, Release latest
getAllParticles() (in module espressopp.tools.info), 160 LennardJonesSoftcoreTI
(class
in
espresgetFoldedPosition()
(espressopp.interaction.LennardJonesSoftcoreTI),
sopp.bc.BC.espressopp.bc.BC
method),
104
42
LJcos (class in espressopp.interaction.LJcos), 105
getLBMom()
(espres- locateItem() (espressopp.esutil.Collectives.espressopp.esutil
sopp.integrator.LatticeBoltzmann.espressopp.integrator.LatticeBoltzmann
method), 44
method), 56
getMinimumImageVector()
(espres- M
sopp.bc.BC.espressopp.bc.BC
method), MirrorLennardJones
(class
in
espres42
sopp.interaction.MirrorLennardJones),
getRandomPos() (espressopp.bc.BC.espressopp.bc.BC
106
method), 42
Morse (class in espressopp.interaction.Morse), 108
getUnfoldedPosition()
(espres- MultiSystem (class in espressopp.MultiSystem), 142
sopp.bc.BC.espressopp.bc.BC
method), MultiSystemLocal (class in espressopp.MultiSystem),
42
142
H
O
Harmonic (class in espressopp.interaction.Harmonic),
83
HarmonicTrap
(class
in
espressopp.interaction.HarmonicTrap), 83
HarmonicUnique
(class
in
espressopp.interaction.HarmonicUnique), 84
OPLS (class in espressopp.interaction.OPLS), 109
OrthorhombicBC()
(espressopp.bc.OrthorhombicBC.espressopp.bc
method), 43
I
ParticleLocal (class in espressopp.Particle), 143
polymerRW() (in module espressopp.tools.topology),
161
Proxy (class in espressopp.pmi), 147
import_() (in module espressopp.pmi), 146
info() (in module espressopp.tools.analyse), 160
invoke() (in module espressopp.pmi), 146
K
P
Q
Quartic (class in espressopp.interaction.Quartic), 110
keepLBDump()
(espressopp.integrator.LatticeBoltzmann.espressopp.integrator.LatticeBoltzmann
R
method), 56
ReactionFieldGeneralized
(class
in
espres-
sopp.interaction.ReactionFieldGeneralized),
112
LennardJones
(class
in
espres- ReactionFieldGeneralizedTI
(class
in
espressopp.interaction.LennardJones), 87
sopp.interaction.ReactionFieldGeneralizedTI),
LennardJones93Wall
(class
in
espres114
sopp.interaction.LennardJones93Wall),
read() (in module espressopp.tools.espresso_old), 164
88
read() (in module espressopp.tools.gromacs), 166
LennardJonesAutoBonds
(class
in
espres- readxyz()
(in
module
espressopp.interaction.LennardJonesAutoBonds),
sopp.tools.DumpConfigurations), 163
90
readxyzr()
(in
module
espresLennardJonesCapped
(class
in
espressopp.tools.DumpConfigurations), 163
sopp.interaction.LennardJonesCapped),
receive() (in module espressopp.pmi), 147
93
reduce() (in module espressopp.pmi), 147
LennardJonesEnergyCapped
(class
in
espres- registerAtExit() (in module espressopp.pmi), 147
sopp.interaction.LennardJonesEnergyCapped), replicate() (in module espressopp.tools.replicate), 161
96
LennardJonesExpand
(class
in
espres- S
sopp.interaction.LennardJonesExpand),
saveLBConf()
(espres97
sopp.integrator.LatticeBoltzmann.espressopp.integrator.LatticeB
LennardJonesGeneric
(class
in
espresmethod), 56
sopp.interaction.LennardJonesGeneric),
setBoxL() (espressopp.bc.OrthorhombicBC.espressopp.bc.OrthorhombicB
100
method), 43
LennardJonesGromacs
(class
in
espressetBoxL() (espressopp.bc.SlabBC.espressopp.bc.SlabBC
sopp.interaction.LennardJonesGromacs),
method), 43
102
L
Index
203
ESPResSo++ Documentation, Release latest
setForce() (espressopp.integrator.LBInit.espressopp.integrator.LBInit
U
method), 58
UserError, 148
setLBMom()
(espressopp.integrator.LatticeBoltzmann.espressopp.integrator.LatticeBoltzmann
V
method), 56
VSpherePair
(class
in
espressetLennardJones14Interactions() (in module espressopp.interaction.VSpherePair), 129
sopp.tools.gromacs), 166
VSphereSelf
(class
in
espressetLennardJonesInteractions() (in module espressopp.interaction.VSphereSelf), 129
sopp.tools.gromacs), 166
setLennardJonesInteractionsTI() (in module espres- W
sopp.tools.gromacs), 166
warmup() (in module espressopp.tools.warmup), 161
setTabulatedInteractions()
(in
module
espreswriteTabFile() (in module espressopp.tools.tabulated),
sopp.tools.gromacs), 166
170
show() (in module espressopp.tools.timers), 160
writexyz()
(in
module
espresSlabBC()
(espressopp.bc.SlabBC.espressopp.bc
sopp.tools.DumpConfigurations), 163
method), 43
SoftCosine
(class
in
espresX
sopp.interaction.SoftCosine), 115
xyzfilewrite()
(in
module
espresstartWorkerLoop() (in module espressopp.pmi), 147
sopp.tools.DumpConfigurations),
163
step
(in
module
espressopp.integrator.MinimizeEnergy), 61
StillingerWeberPairTerm
(class
in
espres- Z
Zero (class in espressopp.interaction.Zero), 131
sopp.interaction.StillingerWeberPairTerm),
118
StillingerWeberPairTermCapped (class in espressopp.interaction.StillingerWeberPairTermCapped),
120
StillingerWeberTripleTerm
(class
in
espressopp.interaction.StillingerWeberTripleTerm),
122
stopWorkerLoop() (in module espressopp.pmi), 147
sync() (in module espressopp.pmi), 147
T
Tabulated (class in espressopp.interaction.Tabulated),
124
TabulatedAngular
(class
in
espressopp.interaction.TabulatedAngular), 125
TabulatedDihedral
(class
in
espressopp.interaction.TabulatedDihedral), 126
TersoffPairTerm
(class
in
espressopp.interaction.TersoffPairTerm), 127
toInt3D() (in module espressopp.Int3D), 142
toInt3DFromVector() (in module espressopp.Int3D),
142
toQuaternion() (in module espressopp.Quaternion), 149
toQuaternionFromVector() (in module espressopp.Quaternion), 149
toReal3D() (in module espressopp.Real3D), 150
toReal3DFromVector()
(in
module
espressopp.Real3D), 150
toRealND() (in module espressopp.RealND), 150
toRealNDFromVector()
(in
module
espressopp.RealND), 150
toTensor() (in module espressopp.Tensor), 152
toTensorFromVector() (in module espressopp.Tensor),
152
204
Index
Download PDF
Similar pages