hoomd.data

Overview

LocalSnapshot

Provides context manager access to HOOMD-blue CPU data buffers.

LocalSnapshotGPU

Provides context manager access to HOOMD-blue GPU data buffers.

AngleLocalAccessBase

Class for directly accessing HOOMD-blue angle data.

BondLocalAccessBase

Class for directly accessing HOOMD-blue bond data.

ConstraintLocalAccessBase

Class for directly accessing HOOMD-blue constraint data.

DihedralLocalAccessBase

Class for directly accessing HOOMD-blue dihedral data.

ImproperLocalAccessBase

Class for directly accessing HOOMD-blue improper data.

PairLocalAccessBase

Class for directly accessing HOOMD-blue special pair data.

ParticleLocalAccessBase

Class for directly accessing HOOMD-blue particle data.

hoomd.data.typeparam.TypeParameter

Details

class hoomd.data.LocalSnapshot(state)

Provides context manager access to HOOMD-blue CPU data buffers.

The interface of a LocalSnapshot is similar to that of the hoomd.Snapshot. Data is MPI rank local so for MPI parallel simulations only the data possessed by a rank is exposed. This means that users must handle the domain decomposition directly. One consequence of this is that access to ghost particle data is provided. A ghost particle is a particle that is not owned by a rank, but nevertheless is required for operations that use particle neighbors. Also, changing the global or local box within a LocalSnapshot context manager is not allowed.

For every property (e.g. data.particles.position), only grabs the data for the regular (non-ghost) particles. The property can be prefixed with ghost_ to grab the ghost particles in a read only manner. Likewise, suffixing with _with_ghost will grab all data on the rank (regular and ghost particles) in a read only array.

All array-like properties return a hoomd.array.HOOMDArray object which prevents invalid memory accesses.

Note

For the LocalAccess classes the affixed attributes mentioned above are not shown. Also of interest, ghost data always come immediately after the regular data.

property angles

Local angle data.

Type

hoomd.data.AngleLocalAccessBase

property bonds

Local bond data.

Type

hoomd.data.BondLocalAccessBase

property constraints

Local constraint data.

Type

hoomd.data.ConstraintLocalAccessBase

property dihedrals

Local dihedral data.

Type

hoomd.data.DihedralLocalAccessBase

property global_box

The global simulation box.

Type

hoomd.Box

property impropers

Local improper data.

Type

hoomd.data.ImproperLocalAccessBase

property local_box

The local box according to the domain decomposition.

Type

hoomd.Box

property pairs

Local special pair data.

Type

hoomd.data.PairLocalAccessBase

property particles

Local particle data.

Type

hoomd.data.ParticleLocalAccessBase

class hoomd.data.LocalSnapshotGPU(*args, **kwargs)

Provides context manager access to HOOMD-blue GPU data buffers.

The interface of a LocalSnapshot is similar to that of the hoomd.Snapshot. Data is MPI rank local so for MPI parallel simulations only the data possessed by a rank is exposed. This means that users must handle the domain decomposition directly. One consequence of this is that access to ghost particle data is provided. A ghost particle is a particle that is not owned by a rank, but nevertheless is required for operations that use particle neighbors. Also, changing the global or local box within a LocalSnapshot context manager is not allowed.

For every property (e.g. data.particles.position), only grabs the data for the regular (non-ghost) particles. The property can be prefixed with ghost_ to grab the ghost particles in a read only manner. Likewise, suffixing with _with_ghost will grab all data on the rank (regular and ghost particles) in a read only array.

All array-like properties return a hoomd.array.HOOMDGPUArray object which prevents invalid memory accesses.

property angles

Local angle data.

Type

hoomd.data.AngleLocalAccessBase

property bonds

Local bond data.

Type

hoomd.data.BondLocalAccessBase

property constraints

Local constraint data.

Type

hoomd.data.ConstraintLocalAccessBase

property dihedrals

Local dihedral data.

Type

hoomd.data.DihedralLocalAccessBase

property global_box

The global simulation box.

Type

hoomd.Box

property impropers

Local improper data.

Type

hoomd.data.ImproperLocalAccessBase

property local_box

The local box according to the domain decomposition.

Type

hoomd.Box

property pairs

Local special pair data.

Type

hoomd.data.PairLocalAccessBase

property particles

Local particle data.

Type

hoomd.data.ParticleLocalAccessBase

class hoomd.data.typeparam.TypeParameter(name, type_kind, param_dict)
property default
keys()
class hoomd.data.AngleLocalAccessBase(state)

Class for directly accessing HOOMD-blue angle data.

typeid

The integer type of a angle.

Type

(N_angles) hoomd.data.array object of int

members

The tags of particles in a angle.

Type

(N_angles, 3) hoomd.data.array object of int

tag

The tag of the angle. HOOMD-blue uses spacial sorting to improve cache efficiency in angle look-ups. This means the ordering of the array changes. However, angle tags remain constant. This means that if angle.tag[0] is 1, then later whatever angle has a tag of 1 later in the simulation is the same angle.

Type

(N_angles) hoomd.data.array object of int

rtag

The reverse tag of a angle. This means that the value angle.rtag[0] represents the current index for accessing data for the angle with tag 0.

Type

(N_angles_global) hoomd.data.array object of int

class hoomd.data.BondLocalAccessBase(state)

Class for directly accessing HOOMD-blue bond data.

typeid

The integer type of a bond.

Type

(N_bonds) hoomd.data.array object of int

members

The tags of particles in a bond.

Type

(N_bonds, 2) hoomd.data.array object of int

tag

The tag of the bond. HOOMD-blue uses spacial sorting to improve cache efficiency in bond look-ups. This means the ordering of the array changes. However, bond tags remain constant. This means that if bond.tag[0] is 1, then later whatever bond has a tag of 1 later in the simulation is the same bond.

Type

(N_bonds) hoomd.data.array object of int

rtag

the reverse tag of a bond. This means that the value bond.rtag[0] represents the current index to access data for the bond with tag 0.

Type

(N_bonds_global) hoomd.data.array object of int

class hoomd.data.ConstraintLocalAccessBase(state)

Class for directly accessing HOOMD-blue constraint data.

value

The constaint value.

Type

(N_constraints) hoomd.data.array object of float

members

the tags of particles in a constraint.

Type

(N_constraints, 3) hoomd.data.array object of int

tag

The tag of the constraint. HOOMD-blue uses spacial sorting to improve cache efficiency in constraint look-ups. This means the ordering of the array changes. However, constraint tags remain constant. This means that if constraint.tag[0] is 1, then later whatever constraint has a tag of 1 later in the simulation is the same constraint.

Type

(N_constraints) hoomd.data.array object of int

rtag

The reverse tag of a constraint. This means that the value constraint.rtag[0] represents the current index for accessing data for the constraint with tag 0.

Type

(N_constraints_global) hoomd.data.array object of int

class hoomd.data.DihedralLocalAccessBase(state)

Class for directly accessing HOOMD-blue dihedral data.

typeid

The integer type of a dihedral.

Type

(N_dihedrals) hoomd.data.array object of int

members

the tags of particles in a dihedral.

Type

(N_dihedrals, 3) hoomd.data.array object of int

tag

The tag of the dihedral. HOOMD-blue uses spacial sorting to improve cache efficiency in dihedral look-ups. This means the ordering of the array changes. However, dihedral tags remain constant. This means that if dihedral.tag[0] is 1, then later whatever dihedral has a tag of 1 later in the simulation is the same dihedral.

Type

(N_dihedrals) hoomd.data.array object of int

rtag

The reverse tag of a dihedral. This means that the value dihedral.rtag[0] represents the current index for accessing data for the dihedral with tag 0.

Type

(N_dihedrals_global) hoomd.data.array object of int

class hoomd.data.ImproperLocalAccessBase(state)

Class for directly accessing HOOMD-blue improper data.

typeid

The integer type of a improper.

Type

(N_impropers) hoomd.data.array object of int

members

The tags of particles in a improper.

Type

(N_impropers, 3) hoomd.data.array object of int

tag

The tag of the improper. HOOMD-blue uses spacial sorting to improve cache efficiency in improper look-ups. This means the ordering of the array changes. However, improper tags remain constant. This means that if improper.tag[0] is 1, then later whatever improper has a tag of 1 later in the simulation is the same improper.

Type

(N_impropers) hoomd.data.array object of int

rtag

The reverse tag of a improper. This means that the value improper.rtag[0] represents the current index for accessing data for the improper with tag 0.

Type

(N_impropers_global) hoomd.data.array object of int

class hoomd.data.PairLocalAccessBase(state)

Class for directly accessing HOOMD-blue special pair data.

typeid

The type of special pair.

Type

(N_pairs) hoomd.data.array object of float

members

the tags of particles in a special pair.

Type

(N_pairs, 3) hoomd.data.array object of int

tag

The tag of the special pair. HOOMD-blue uses spacial sorting to improve cache efficiency in special pair look-ups. This means the ordering of the array changes. However, special pair tags remain constant. This means that if special pair.tag[0] is 1, then later whatever special pair has a tag of 1 later in the simulation is the same special pair.

Type

(N_special_pairs) hoomd.data.array object of int

rtag

The reverse tag of a special pair. This means that the value special pair.rtag[0] represents the current index for accessing data for the special pair with tag 0.

Type

(N_special_pairs_global) hoomd.data.array object of int

class hoomd.data.ParticleLocalAccessBase(state)

Class for directly accessing HOOMD-blue particle data.

typeid

The integer type of a particle

Type

(N_particles) hoomd.data.array object of float

tag

The tag of a particle. HOOMD-blue uses spacial sorting to improve cache efficiency in particle look-ups. This means the ordering of the array changes. However, particle tags remain constant. This means that if particles.tag[0] is 1, then later whatever particle has a tag of 1 later in the simulation is the same particle.

Type

(N_particles) hoomd.data.array object of int

rtag

The reverse tag of a particle. This means that the value particles.rtag[0] represents the current index accessing data for the particle with tag 0.

Type

(N_particles_global) hoomd.data.array object of int

position

particle positions

Type

(N_particles, 3) hoomd.data.array object of float

image

The periodic image a particle occupies

Type

(N_particles, 3) hoomd.data.array object of int

velocity

particle velocities

Type

(N_particles, 3) hoomd.data.array object of float

acceleration

particle accelerations

Type

(N_particles, 3) hoomd.data.array object of float

mass

particles’ masses

Type

(N_particles) hoomd.data.array object of float

orientation

particle orientations expressed as quaternions

Type

(N_particles, 4) hoomd.data.array object of float

angular_momentum

particle angular momenta expressed as quaternions

Type

(N_particles, 4) hoomd.data.array object of float

moment_of_inertia

particle principal moments of inertia

Type

(N_particles, 3) hoomd.data.array object of float

charge

particle electrical charges

Type

(N_particles) hoomd.data.array object of float

diameter

particle diameters

Type

(N_particles) hoomd.data.array object of float

rigid_body_id

The id of the rigid body the particle is in.

Type

(N_particles) hoomd.data.array object of int

net_force

net force on particle

Type

(N_particles, 3) hoomd.data.array object of float

net_torque

net torque on particle

Type

(N_particles, 3) hoomd.data.array object of float

net_virial

net virial on particle

Type

(N_particles, 3) hoomd.data.array object of float

Note

That changing some attributes like (velocity or acceleration) may not change the trajectory of the system. Integration of the equations of motion do not necessarily use velocity or accleration directly. This is also true in HOOMD-blue’s MD integration methods (see hoomd.md.methods)

Modules