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.

type¶

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

hoomd.data.array