# Compute Classes#

Calculations in **freud** are built around the concept of `Compute classes`

, Python objects that encode a given method and expose it through a `compute`

method.
In general, these methods operate on a system composed of a triclinic box and a NumPy array of particle positions.
The box can be provided as any object that can be interpreted as a **freud** box (as demonstrated in the examples above).
We can look at the `freud.order.Hexatic`

order parameter calculator as an example:

```
import freud
positions = ... # Read positions from trajectory file.
op = freud.order.Hexatic(k=6)
op.compute(
system=({'Lx': 5, 'Ly': 5, 'dimensions': 2}, positions),
neighbors=dict(r_max=3)
)
# Plot the value of the order parameter.
from matplotlib import pyplot as plt
plt.hist(np.absolute(op.particle_order))
```

Here, we are calculating the hexatic order parameter, then using Matplotlib to plot.
The `freud.order.Hexatic`

class constructor accepts a single argument `k`

, which represents the periodicity of the calculation.
If you’re unfamiliar with this order parameter, the most important piece of information here is that many compute methods in **freud** require parameters that are provided when the `Compute class`

is constructed.

To calculate the order parameter we call `compute`

, which takes two arguments, a `tuple`

(box, points) and a `dict`

.
We first focus on the first argument.
The `box`

is any object that can be coerced into a `freud.box.Box`

as described in the previous section; in this case, we use a dictionary to specify a square (2-dimensional) box.
The `points`

must be anything that can be coerced into a 2-dimensional NumPy array of shape `(N, 3)`

In general, the points may be provided as anything that can be interpreted as an \(N\times 3\) list of positions; for more details on valid inputs here, see `numpy.asarray()`

.
Note that because the hexatic order parameter is designed for two-dimensional systems, the points must be provided of the form [x, y, 0] (i.e. the z-component must be 0).
We’ll go into more detail about the `(box, points)`

tuple soon, but for now, it’s sufficient to just think of it as specifying the system of points we want to work with.

Now let’s return to the `neighbors`

argument to `compute`

, which is a dictionary is used to determine which particle neighbors to use.
Many computations in **freud** (such as the hexatic order parameter) involve the bonds in the system (for example, the average length of bonds or the average number of bonds a given point has).
However, the concept of a bond is sufficiently variable between different calculations; for instance, should points be considered bonded if they are within a certain distance of each other?
Should every point be considered bonded to a fixed number of other points?

To accommodate this variability, **freud** offers a very general framework by which bonds can be specified, and we’ll go into more details in the next section.
In the example above, we’ve simply informed the `Hexatic`

class that we want it to define bonds as pairs of particles that are less than 3 distance units apart.
We then access the computed order parameter as `op.particle_order`

(we use `np.absolute()`

because the output is a complex number and we just want to see its magnitude).

## Accessing Computed Properties#

In general, `Compute classes`

expose their calculations using properties.
Any parameters to the `Compute`

object (e.g. `k`

in the above example) can typically be accessed as soon as the object is constructed:

```
op = freud.order.Hexatic(k=6)
op.k
```

Computed quantities can also be accessed in a similar manner, but only after the `compute`

method is called.
For example:

```
op = freud.order.Hexatic(k=6)
# This will raise an exception.
op.particle_order
op.compute(
system=({'Lx': 5, 'Ly': 5, 'dimensions': 2}, positions),
neighbors=dict(r_max=3)
)
# Now you can access this.
op.particle_order
```

Note

Most (but not all) of **freud**’s `Compute classes`

are Python wrappers
around high-performance implementations in C++. As a result, none of the
data or the computations is actually stored in the Python object. Instead,
the Python object just stores an instance of the C++ object that actually
owns all its data, performs calculations, and returns computed quantities
to the user. Python properties provide a nice way to hide this logic so
that the Python code involves just a few lines.

Compute objects is that they can be used many times to calculate quantities, and the most recently calculated output can be accessed through the property. If you need to perform a series of calculations and save all the data, you can also easily do that:

```
# Recall that lists of length 2 automatically convert to 2D freud boxes.
box = [5, 5]
op = freud.order.Hexatic(k=6)
# Assuming that we have a list of Nx3 NumPy arrays that represents a
# simulation trajectory, we can loop over it and calculate the order
# parameter values in sequence.
trajectory = ... # Read trajectory file into a list of positions by frame.
hexatic_values = []
for points in trajectory:
op.compute(system=(box, points), neighbors=dict(r_max=3))
hexatic_values.append(op.particle_order)
```

To make using **freud** as simple as possible, all `Compute classes`

are designed to return `self`

when compute is called.
This feature enables a very concise *method-chaining* idiom in **freud** where computed properties are accessed immediately:

```
particle_order = freud.order.Hexatic(k=6).compute(
system=(box, points)).particle_order
```