def fundamental_sector(self):
from orix.vector.neo_euler import AxAngle
from orix.vector.spherical_region import SphericalRegion
symmetry = self.antipodal
symmetry = symmetry[symmetry.angle > 0]
axes, order = symmetry.get_highest_order_axis()
if order > 6:
return Vector3d.empty()
axis = Vector3d.zvector().get_nearest(axes, inclusive=True)
r = Rotation.from_neo_euler(
AxAngle.from_axes_angles(axis, 2 * np.pi / order))
diads = symmetry.diads
nearest_diad = axis.get_nearest(diads)
if nearest_diad.size == 0:
nearest_diad = axis.perpendicular
n1 = axis.cross(nearest_diad).unit
n2 = -(r * n1)
next_diad = r * nearest_diad
n = Vector3d.stack((n1, n2)).flatten()
sr = SphericalRegion(n.unique())
inside = symmetry[symmetry.axis < sr]
if inside.size == 0:
return sr
axes, order = inside.get_highest_order_axis()
axis = axis.get_nearest(axes)
r = Rotation.from_neo_euler(
AxAngle.from_axes_angles(axis, 2 * np.pi / order))
nearest_diad = next_diad
n1 = axis.cross(nearest_diad).unit
n2 = -(r * n1)
n = Vector3d(np.concatenate((n.data, n1.data, n2.data)))
sr = SphericalRegion(n.unique())
return sr
def get_plot_data(self):
"""
Produces suitable Rotations for the construction of a wireframe for self
"""
from orix.vector import Vector3d
# gets a grid of vector directions
theta = np.linspace(0, 2 * np.pi - EPSILON, 361)
rho = np.linspace(0, np.pi - EPSILON, 181)
theta, rho = np.meshgrid(theta, rho)
g = Vector3d.from_polar(rho, theta)
# get the cell vector normal norms
n = Rodrigues.from_rotation(self).norm.data[:, np.newaxis, np.newaxis]
if n.size == 0:
return Rotation.from_neo_euler(AxAngle.from_axes_angles(g, np.pi))
d = (-self.axis).dot_outer(g.unit).data
x = n * d
omega = 2 * np.arctan(np.where(x != 0, x**-1, np.pi))
# keeps the smallest allowed angle
omega[omega < 0] = np.pi
omega = np.min(omega, axis=0)
r = Rotation.from_neo_euler(AxAngle.from_axes_angles(g.unit, omega))
return r
def from_symmetry(cls, s1, s2=C1):
"""The set of unique (mis)orientations of a symmetrical object.
Parameters
----------
s1, s2 : Symmetry
"""
s1, s2 = get_proper_groups(s1, s2)
large_cell_normals = _get_large_cell_normals(s1, s2)
disjoint = s1 & s2
# if s1._tuples == s2._tuples:
# disjoint = disjoint.laue
fundamental_sector = disjoint.fundamental_sector()
fundamental_sector_normals = Rotation.from_neo_euler(
AxAngle.from_axes_angles(fundamental_sector, np.pi)
)
normals = Rotation(
np.concatenate([large_cell_normals.data, fundamental_sector_normals.data])
)
orientation_region = cls(normals)
vertices = orientation_region.vertices()
if vertices.size:
orientation_region = orientation_region[
np.any(
np.isclose(orientation_region.dot_outer(vertices).data, 0), axis=1
)
]
return orientation_region
def get_plot_data(self):
from orix.vector import Vector3d
theta = np.linspace(0, 2 * np.pi + 1e-9, 361)
rho = np.linspace(0, np.pi, 181)
theta, rho = np.meshgrid(theta, rho)
g = Vector3d.from_polar(rho, theta)
n = Rodrigues.from_rotation(self).norm.data[:, np.newaxis, np.newaxis]
if n.size == 0:
return Rotation.from_neo_euler(AxAngle.from_axes_angles(g, np.pi))
d = (-self.axis).dot_outer(g.unit).data
x = n * d
x = 2 * np.arctan(x**-1)
x[x < 0] = np.pi
x = np.min(x, axis=0)
r = Rotation.from_neo_euler(AxAngle.from_axes_angles(g.unit, x))
return r
def rotate(self, axis=None, angle=0):
"""Convenience function for rotating this vector.
Shapes of 'axis' and 'angle' must be compatible with shape of this
vector for broadcasting.
Parameters
----------
axis : Vector3d or array_like, optional
The axis of rotation. Defaults to the z-vector.
angle : array_like, optional
The angle of rotation, in radians.
Returns
-------
Vector3d
A new vector with entries rotated.
Examples
--------
>>> from math import pi
>>> v = Vector3d((0, 1, 0))
>>> axis = Vector3d((0, 0, 1))
>>> angles = [0, pi/4, pi/2, 3*pi/4, pi]
>>> v.rotate(axis=axis, angle=angles)
"""
from orix.quaternion.rotation import Rotation
from orix.vector.neo_euler import AxAngle
axis = Vector3d.zvector() if axis is None else axis
angle = 0 if angle is None else angle
q = Rotation.from_neo_euler(AxAngle.from_axes_angles(axis, angle))
return q * self
def get_grid_around_beam_direction(beam_rotation,
resolution,
angular_range=(0, 360)):
"""
Creates a rotation list of rotations for which the rotation is about given beam direction
Parameters
----------
beam_rotation : tuple
A desired beam direction as a rotation (rzxz eulers), usually found via get_rotation_from_z_to_direction
resolution : float
The resolution of the grid (degrees)
angular_range : tuple
The minimum (included) and maximum (excluded) rotation around the beam direction to be included
Returns
-------
rotation_list : list of tuples
Example
-------
>>> from diffsims.generators.zap_map_generator import get_rotation_from_z_to_direction
>>> beam_rotation = get_rotation_from_z_to_direction(structure,[1,1,1])
>>> grid = get_grid_around_beam_direction(beam_rotation,1)
"""
z = np.deg2rad(np.asarray(beam_rotation))
beam_rotation = Rotation.from_euler(z,
convention="bunge",
direction="crystal2lab")
angles = np.deg2rad(
np.arange(start=angular_range[0],
stop=angular_range[1],
step=resolution))
axes = np.repeat([[0, 0, 1]], angles.shape[0], axis=0)
in_plane_rotation = Rotation.from_neo_euler(
AxAngle.from_axes_angles(axes, angles))
orix_grid = beam_rotation * in_plane_rotation
rotation_list = get_list_from_orix(orix_grid, rounding=2)
return rotation_list
def _get_large_cell_normals(s1, s2):
dp = get_distinguished_points(s1, s2)
normals = Rodrigues.zero(dp.shape + (2, ))
planes1 = dp.axis * np.tan(dp.angle.data / 4)
planes2 = -dp.axis * np.tan(dp.angle.data / 4)**-1
planes2.data[np.isnan(planes2.data)] = 0
normals[:, 0] = planes1
normals[:, 1] = planes2
normals: Rotation = Rotation.from_neo_euler(normals).flatten().unique(
antipodal=False)
if not normals.size:
return normals
_, inv = normals.axis.unique(return_inverse=True)
axes_unique = []
angles_unique = []
for i in np.unique(inv):
n = normals[inv == i]
axes_unique.append(n.axis.data[0])
angles_unique.append(n.angle.data.max())
normals = Rotation.from_neo_euler(
AxAngle.from_axes_angles(np.array(axes_unique), angles_unique))
return normals
def test_from_rotation(rotation, expected):
axangle = AxAngle.from_rotation(rotation)
assert np.allclose(axangle.data, expected)
def test_from_axes_angles(axis, angle, expected_axis):
ax = AxAngle.from_axes_angles(axis, angle)
assert np.allclose(ax.axis.data, expected_axis)
assert np.allclose(ax.angle.data, abs(angle))
def axangle(request):
return AxAngle(request.param.data)