# AngularSeparation¶

The `freud.environment`

module analyzes the local environments of particles. The `freud.environment.AngularSeparation`

class enables direct measurement of the relative orientations of particles.

```
[1]:
```

```
import freud
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams['axes.titlepad'] = 20
from mpl_toolkits.mplot3d import Axes3D
import util
```

In order to work with orientations in freud, we need to do some math with quaternions. If you are unfamiliar with quaternions, you can read more about their definition and how they can be used to represent rotations. For the purpose of this tutorial, just consider them as 4D vectors, and know that the set of normalized (*i.e.* unit norm) 4D vectors can be used to represent
rotations in 3D. In fact, there is a 1-1 mapping between normalized quaternions and 3x3 rotation matrices. Quaternions are more computationally convenient, however, because they only require storing 4 numbers rather than 9, and they can be much more easily chained together. For our purposes, you can largely ignore the contents of the next cell, other than to note that this is how we perform rotations of vectors using quaternions instead of matrices.

```
[2]:
```

```
# These functions are adapted from the rowan quaternion library.
# See rowan.readthedocs.io for more information.
def quat_multiply(qi, qj):
"""Multiply two sets of quaternions."""
output = np.empty(np.broadcast(qi, qj).shape)
output[..., 0] = qi[..., 0] * qj[..., 0] - \
np.sum(qi[..., 1:] * qj[..., 1:], axis=-1)
output[..., 1:] = (qi[..., 0, np.newaxis] * qj[..., 1:] +
qj[..., 0, np.newaxis] * qi[..., 1:] +
np.cross(qi[..., 1:], qj[..., 1:]))
return output
def quat_rotate(q, v):
"""Rotate a vector by a quaternion."""
v = np.array([0, *v])
q_conj = q.copy()
q_conj[..., 1:] *= -1
return quat_multiply(q, quat_multiply(v, q_conj))[..., 1:]
def quat_to_angle(q):
"""Get rotation angles of quaternions."""
norms = np.linalg.norm(q[..., 1:], axis=-1)
return 2.0 * np.arctan2(norms, q[..., 0])
```

## Neighbor Angles¶

One usage of the AngularSeparation class is to compute angles between neighboring particles. To show how this works, we generate a simple configuration of particles with random orientations associated with each point.

```
[3]:
```

```
box, positions = util.make_sc(5, 5, 5)
v = 0.05
# Quaternions can be simply sampled as 4-vectors.
# Note that these samples are not uniformly distributed rotations,
# but that is not important for our current applications.
np.random.seed(0)
ref_orientations = np.random.multivariate_normal(mean=[1, 0, 0, 0], cov=v*np.eye(4), size=positions.shape[0])
orientations = np.random.multivariate_normal(mean=[1, 0, 0, 0], cov=v*np.eye(4), size=positions.shape[0])
# However, they must be normalized: only unit quaternions represent rotations.
ref_orientations /= np.linalg.norm(ref_orientations, axis=1)[:, np.newaxis]
orientations /= np.linalg.norm(orientations, axis=1)[:, np.newaxis]
```

```
[4]:
```

```
# To show orientations, we use arrows rotated by the quaternions.
ref_arrowheads = quat_rotate(ref_orientations, np.array([1, 0, 0]))
arrowheads = quat_rotate(orientations, np.array([1, 0, 0]))
fig = plt.figure(figsize=(12, 6))
ref_ax = fig.add_subplot(121, projection='3d')
ax = fig.add_subplot(122, projection='3d')
ref_ax.quiver3D(positions[:, 0], positions[:, 1], positions[:, 2],
ref_arrowheads[:, 0], ref_arrowheads[:, 1], ref_arrowheads[:, 2])
ax.quiver3D(positions[:, 0], positions[:, 1], positions[:, 2],
arrowheads[:, 0], arrowheads[:, 1], arrowheads[:, 2])
ref_ax.set_title("Reference orientations", fontsize=16);
ax.set_title("Orientations", fontsize=16);
plt.show()
```

We can now use the AngularSeparation class to compare the orientations in these two systems.

```
[5]:
```

```
num_neighbors=12
r_max = 1.8
# For simplicity, we'll assume that our "particles" are completely
# asymmetric, i.e. there are no rotations that map the particle
# back onto itself. If we had a regular polyhedron, then we would
# want to specify all the quaternions that rotate that polyhedron
# onto itself.
equiv_ors = np.array([[1, 0, 0, 0]])
ang_sep = freud.environment.AngularSeparation(r_max, num_neighbors)
ang_sep.computeNeighbor(box, ref_orientations, orientations,
positions, positions, equiv_ors)
#convert angles from radians to degrees
neighbor_angles = np.rad2deg(ang_sep.neighbor_angles)
neighbor_angles
```

```
[5]:
```

```
array([100.32801 , 90.07115 , 60.706676, ..., 42.66844 , 61.745235,
52.767185], dtype=float32)
```

## Global Angles¶

Alternatively, the AngularSeparation class can also be used to compute the orientation of all points in the system relative to some global set of orientations. In this case, we simply provide a set of global quaternions that we want to consider. For simplicity, let’s consider \(180^\circ\) rotations about each of the coordinate axes, which have very simple quaternion representations.

```
[6]:
```

```
global_orientations = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
ang_sep.computeGlobal(ref_orientations, global_orientations, equiv_ors)
global_angles = np.rad2deg(ang_sep.global_angles)
```

As a simple check, we can ensure that for the identity quaternion \((1, 0, 0, 0)\), which performs a \(0^\circ\) rotation, the angles between the reference orientations and that quaternion are equal to the original angles of rotation of those quaternions (*i.e.* how much those orientations were already rotated relative to the identity).

```
[7]:
```

```
np.allclose(global_angles[0, :], np.rad2deg(quat_to_angle(ref_orientations)))
```

```
[7]:
```

```
True
```