mpcd

Overview

hoomd.mpcd.integrator MPCD integrator

Details

Multiparticle collision dynamics.

Simulating complex fluids and soft matter using conventional molecular dynamics methods (hoomd.md) can be computationally demanding due to large disparities in the relevant length and time scales between molecular-scale solvents and mesoscale solutes such as polymers, colloids, and deformable materials like cells. One way to overcome this challenge is to simplify the model for the solvent while retaining its most important interactions with the solute. MPCD is a particle-based simulation method for resolving solvent-mediated fluctuating hydrodynamic interactions with a microscopically detailed solute model. This method has been successfully applied to a simulate a broad class of problems, including polymer solutions and colloidal suspensions both in and out of equilibrium.

Algorithm

In MPCD, the solvent is represented by point particles having continuous positions and velocities. The solvent particles propagate in alternating streaming and collision steps. During the streaming step, particles evolve according to Newton’s equations of motion. Typically, no external forces are applied to the solvent, and streaming is straightforward with a large time step. Particles are then binned into local cells and undergo a stochastic multiparticle collision within the cell. Collisions lead to the build up of hydrodynamic interactions, and the frequency and nature of the collisions, along with the solvent properties, determine the transport coefficients. All standard collision rules conserve linear momentum within the cell and can optionally be made to enforce angular-momentum conservation. Currently, we have implemented the following collision rules with linear-momentum conservation only:

  • srd – Stochastic rotation dynamics
  • at – Andersen thermostat

Solute particles can be coupled to the solvent during the collision step. This is particularly useful for soft materials like polymers. Standard molecular dynamics integration can be applied to the solute. Coupling to the MPCD solvent introduces both hydrodynamic interactions and a heat bath that acts as a thermostat. In the future, fluid-solid coupling will also be introduced during the streaming step to couple hard particles and boundaries.

Details of this implementation of the MPCD algorithm for HOOMD-blue can be found in M. P. Howard et al. (2018).

Getting started

MPCD is intended to be used as an add-on to the standard MD methods in hoomd.md. To get started, take the following steps:

  1. Initialize any solute particles using standard methods (hoomd.init).
  2. Initialize the MPCD solvent particles using one of the methods in mpcd.init. Additional details on how to manipulate the solvent particle data can be found in mpcd.data.
  3. Create an MPCD integrator.
  4. Choose the appropriate streaming method from mpcd.stream.
  5. Choose the appropriate collision rule from mpcd.collide, and set the collision rule parameters.
  6. Setup an MD integrator and any interactions between solute particles.
  7. Optionally, configure the sorting frequency to improve performance (see update.sort).
  8. Run your simulation!

Example script for a pure bulk SRD fluid:

import hoomd
hoomd.context.initialize()
from hoomd import mpcd

# Initialize (empty) solute in box.
box = hoomd.data.boxdim(L=100.)
hoomd.init.read_snapshot(hoomd.data.make_snapshot(N=0, box=box))

# Initialize MPCD particles and set sorting period.
s = mpcd.init.make_random(N=int(10*box.get_volume()), kT=1.0, seed=7)
s.sorter.set_period(period=25)

# Create MPCD integrator with streaming and collision methods.
mpcd.integrator(dt=0.1)
mpcd.stream.bulk(period=1)
mpcd.collide.srd(seed=42, period=1, angle=130., kT=1.0)

hoomd.run(2000)

Stability

hoomd.mpcd is currently stable, but remains under development. When upgrading versions, existing job scripts may need to be need to be updated. Such modifications will be noted in the change log.

Maintainer: Michael P. Howard, Princeton University.

class hoomd.mpcd.integrator(dt, aniso=None)

MPCD integrator

Parameters:
  • dt (float) – Each time step of the simulation hoomd.run() will advance the real time of the system forward by dt (in time units).
  • aniso (bool) – Whether to integrate rotational degrees of freedom (bool), default None (autodetect).

The MPCD integrator enables the MPCD algorithm concurrently with standard MD integrate methods. An integrator must be created in order for stream and collide methods to take effect. Embedded MD particles require the creation of an appropriate integration method. Typically, this will just be nve.

In MPCD simulations, dt defines the amount of time that the system is advanced forward every time step. MPCD streaming and collision steps can be defined to occur in multiples of dt. In these cases, any MD particle data will be updated every dt, while the MPCD particle data is updated asynchronously for performance. For example, if MPCD streaming happens every 5 steps, then the particle data will be updated as follows:

        0     1     2     3     4     5
MD:     |---->|---->|---->|---->|---->|
MPCD:   |---------------------------->|

If the MPCD particle data is accessed via the snapshot interface at time step 3, it will actually contain the MPCD particle data for time step 5. The MD particles can be read at any time step because their positions are updated every step.

Examples:

mpcd.integrator(dt=0.1)
mpcd.integrator(dt=0.01, aniso=True)
restore_state()

Resore the state information from the file used to initialize the simulations

set_params(dt=None, aniso=None)

Changes parameters of an existing integration mode.

Parameters:
  • dt (float) – New time step delta (if set) (in time units).
  • aniso (bool) – Anisotropic integration mode (bool), default None (autodetect).

Examples:

integrator.set_params(dt=0.007)
integrator.set_params(dt=0.005, aniso=False)

Modules