Submit an article to the COMMAT special issue on HOOMD-BLUE, THE FIRST DECADE.

HOOMD-blue is a *general-purpose* particle simulation toolkit. It scales from a single CPU core to **thousands of GPUs**.

You define particle initial conditions and interactions in a high-level python script. Then tell HOOMD-blue how you want to execute the job and it takes care of the rest. Python job scripts give you unlimited flexibility to create custom initialization routines, control simulation parameters, and perform in situ analysis.

Download and get started using HOOMD-blue today. Please cite HOOMD-blue if you use it published work.

```
import hoomd, hoomd.md
hoomd.context.initialize()
unitcell=hoomd.lattice.sc(a=2.0, type_name='A')
hoomd.init.create_lattice(unitcell=unitcell, n=10)
nl = hoomd.md.nlist.cell()
lj = hoomd.md.pair.lj(r_cut=3.0, nlist=nl)
lj.pair_coeff.set('A', 'A', epsilon=1.0, sigma=1.0)
all = hoomd.group.all();
hoomd.md.integrate.mode_standard(dt=0.005)
hoomd.md.integrate.langevin(group=all, kT=1.2, seed=4)
hoomd.run(10e3)
```

```
$ hoomd run.py --mode=cpu
$ hoomd run.py --mode=gpu
$ mpirun -n 256 hoomd run.py --mode=cpu
$ mpirun -n 64 hoomd run.py --mode=gpu
```

### Fast GPU performance

On a single NVIDIA GPU, HOOMD-blue performs an order of magnitude faster than a multi-core CPU in typical benchmarks. Obtain faster time to solution, execute larger simulations than were previously possible, or increase job throughput through a cluster given a fixed monetary budget.

### Scalable

HOOMD-blue scales up to thousands of GPUs on Titan and Blue Waters, two of the largest GPU accelerated supercomputers in the world. It runs just as efficiently from one to dozens of GPUs on smaller clusters like Comet (XSEDE), Maverick (XSEDE), your local GPU cluster, and the workstation at your desk.

### Flexible

Want to run a Molecular Dynamics simulation using a custom force field? Or maybe you are simulating granular dynamics, dissipative particle dynamics, hard particle Monte Carlo, or active particles? HOOMD-blue is the right tool for you, with a variety of potentials and integration modes.

## Hard particle Monte Carlo capabilities

### Execution

- Canonical hard particle MC on a single CPU core
- Parallel update scheme on a single GPU
- Parallel updates on many CPU cores / GPUs using MPI
- Frenkel-Ladd free energy determination
- Wall constraints (sphere, cylinder, plane)
- Geometric cluster moves

### Energy evaluation

- Evaluate user-defined pairwise energy functions with runtime compiled code
- Evaluate user-defined external energy functions with runtime compiled code

### Shape classes

- Spheres / disks
- Union of spheres
- Convex polygons
- Convex spheropolygons
- Simple polygons
- Ellipsoids / ellipses
- Convex polyhedra
- Union of convex polyhedra
- Convex spheropolyhedra
- Faceted spheres
- General polyhedra

### Ensembles

- NVT
- NPT
- Implicit depletants
- Grand canonical ensemble
- Gibbs ensemble

### Analysis

- Pressure sampling in NVT
- Free volume

## Molecular dynamics capabilities

### Integrators

Apply many independent integrators to separate particle groups. HOOMD-blue has integrators built in for many different thermodynamic ensembles and energy minimization. Many of them support integration of orientational degrees of freedom.

- NVE, NVT, NPH, NPT
- Langevin dynamics
- Brownian dynamics
- Berendsen thermostat
- Dissipative Particle Dynamics (DPD)
- FIRE energy minimization

### Pair potentials

- Buckingham
- CGCMM
- DLVO
- DPD
- Lennard-Jones
- Gaussian
- Mie
- Moliere
- Morse
- Reaction field
- Yukawa
- ZBL
- User-defined (table)

### Bond potentials

- Harmonic
- FENE
- User-defined (table)
- Special pair lj
- Special pair coulomb 1-4

### Angle potentials

- Harmonic
- CGCMM
- cosine squared
- User-defined (table)

### Rigid bodies

Combine particles together to form rigid bodies. Potentials still evaluate particle to particle, but the integrator keeps particles in rigid bodies together. Most of the standard integrators work in conjunction with the rigid body constraint.

### Advanced neighbor list algorithms

Efficiently handle large cutoff radius disparities using a BVH tree, and/or stenciled cell list to compute the neighbor list. These algorithms make possible large colloid and explicit solvent simulations with.

### Other forces

- Active force
- Multi-particle collision dynamics

### Anisotropic potentials

- Gay-berne
- Dipole
- DEM (faceted shapes)

### Wall potentials

- Sums of planar, cylindrical, and spherical half-spaces
- lj, gauss, slj, yukawa, morse, force_shifted_lj, and mie interactions

### Long-ranged potentials

- PPPM electrostatics
- PPPM with Debye screening

### Constraints

- Sphere
- Ellipsoid
- Distance
- Rigid body
- One dimensional motion

### Dihedral potentials

- Harmonic
- OPLS
- User-defined (table)

### Improper potentials

- Harmonic

### External potentials

- Periodic
- Constant force
- Electric field

### Many-body potentials

- EAM
- Tersoff
- square density

## General features

### Simulation box

Simulations in HOOMD-blue can be 2D or 3D. The box is a parallelepiped with arbitrary lengths and angles allowing for generic triclinic symmetry with periodic boundary conditions in all directions.

### Initializers

### Extend HOOMD-blue

Need a capability not listed here? Fork the project and modify the code. HOOMD-blue is written in well documented C++ and its design is modular. Extensions that just add a new pair or bond potential don't even require CUDA code.

If your work is useful to a wide audience of users, submit it to the HOOMD-blue developers as a pull request for inclusion into the main code.

### Update properties

- Resize box over time
- Temperature rescale
- Zero system momentum
- Arbitrary manipulation of system and particle properties from python
- Add/remove particles while the simulation progresses
- Access particle properties via numpy arrays
- Introduce flow with the Mueller/Plathe method

### Analysis

- Realtime visualization in VMD using IMD.
- Mean-squared displacement
- Log thermodynamic properties to text or HDF5
- Query logged values from python
- Arbitrary analysis in python
- Execute inside Jupyter notebooks