relentless.model.ObliqueArea#

class relentless.model.ObliqueArea(Lx, Ly, xy, convention='LAMMPS')#

Oblique area.

An ObliqueArea is defined by two edge vectors a and b that form a right-hand basis. These vectors are defined by deformation of a rectangle oriented along the Cartesian axes and having two edge lengths \(L_x\) and \(L_y\), respectively. The box is then tilted by a factor \(xy\), which is the upper off-diagonal element of the matrix of box vectors. As a result, the a vector is always aligned along the \(x\) axis, while the other vector may be tilted.

Parameters:

Lx (float) – Length along the \(x\) axis.
Ly (float) – Length along the \(y\) axis.
xy (float) – Tilt factor.
convention ({'LAMMPS','HOOMD'}) – Convention for the tilt factor.

Notes

Convention

The tilt factors can be defined using one of two conventions. In the LAMMPS convention, the basis vectors are:

\[\mathbf{a} = (L_x,0,0) \quad \mathbf{b} = (xy,L_y,0)\]

In the HOOMD simulation convention, the basis vectors are:

\[\mathbf{a} = (L_x,0,0) \quad \mathbf{b} = (xy \cdot L_y,L_y,0)\]

Methods

`as_array`([convention])	Convert to array of lengths and tilt factor.
`coordinate_to_fraction`(r)	Make fractional coordinates from Cartesian coordinates.
`fraction_to_coordinate`(x)	Make Cartesian coordinates from fractional coordinates.
`from_json`(data)	Deserialize from a dictionary.
`to_json`()	Serialize as a dictionary.
`wrap`(positions)	Wrap positions subject to periodic boundary conditions.

Attributes

`extent`	Extent of the region.
`high`
`low`

as_array(convention=None)#

Convert to array of lengths and tilt factor.

Parameters:: convention ({'LAMMPS','HOOMD'}, optional) – Convention to use for the tilt factors. Default of None will use the convention for the box.
Returns:: An array containing (Lx,Ly,xy) according to the convention.
Return type:: numpy.ndarray

coordinate_to_fraction(r)#

Make fractional coordinates from Cartesian coordinates.

The Cartesian coordinates r are projected onto the two (potentially nonorthogonal) basis vectors defining the box to yield fractional coordinates x such that:

\[\mathbf{r} = \mathbf{r}_{\rm low} + (\mathbf{a}\quad\mathbf{b}) \cdot \mathbf{x}\]

where \(\mathbf{r}_{\rm low}\) is the lower bound of the box, i.e., low.

Parameters:: r (array_like) – Cartesian coordinates (or array of).
Returns:: Fractional coordinates x corresponding to r.
Return type:: numpy.ndarray

property extent#

Extent of the region.

Type:: float

fraction_to_coordinate(x)#

Make Cartesian coordinates from fractional coordinates.

The fractional coordinates x are converted to Cartesian coordinates r using the basis vectors of the box. See coordinate_to_fraction() for the definition of these coordinates.

Parameters:: r (array_like) – Fractional coordinates (or array of).
Returns:: Cartesian coordinates r corresponding to x.
Return type:: numpy.ndarray

classmethod from_json(data)#

Deserialize from a dictionary.

Parameters:: data (dict) – The serialized equivalent of the ObliqueArea object. The keys of data should be ('Lx','Ly','xy','convention'). The lengths and tilt factor should be floats, and the convention should be a string.
Returns:: A new ObliqueArea object constructed from the data.
Return type:: ObliqueArea

to_json()#

Serialize as a dictionary.

The dictionary contains the two box lengths Lx and Ly, the tilt factor xy, and the convention for the tilt factors.

Returns:: The serialized ObliqueArea.
Return type:: dict

wrap(positions)#

Wrap positions subject to periodic boundary conditions.

Two-dimensional periodic boundary conditions are applied to ensure the positions lie within the box. This is achieved by converting to fractional coordinates, bounding the fractional coordinates within \([0,1)\), then converting back to Cartesian coordinates.

Parameters:: positions (array_like) – Position vector(s).
Returns:: Wrapped position(s).
Return type:: numpy.ndarray