Struct mori::orientations::rmat::RMat

pub struct RMat { /* fields omitted */ }

A structure that holds an array of rotation/orientation matrices

Methods

impl RMat

pub fn new(size: usize) -> RMat

Creates a series of identity matrices for the initial rotation matrix when the data is not fed into it

pub fn new_init(ori: Array3<f64>) -> RMat

Creates a rotation matrix type with the supplied data as long as the supplied data is in the following format shape (3, 3, nelems), memory order = fortran/column major. If it doesn't fit those standards it will fail. The data is also being assummed to be orthogonal, but it's currently not checked to see if that is the case.

pub fn ori_view(&self) -> ArrayView3<f64>

Return a ndarray view of the orientation data

pub fn ori_view_mut(&mut self) -> ArrayViewMut3<f64>

Return a ndarray mutable view of the orientation data

pub fn transpose(&self) -> RMat

Returns the transpose of the rotation matrix.

pub fn transpose_inplace(&mut self)

Trait Implementations

impl Clone for RMat

fn clone(&self) -> RMat

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RMat

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl OriConv for RMat

The orientation conversions of a series of rotation matrices to a number of varying different orientation representations commonly used in material orientation processing.

fn to_bunge(&self) -> Bunge

Converts the rotation matrices to the equivalent bunge angles which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_rmat(&self) -> RMat

Returns a copy of the initial rotation matrix data structure

fn to_ang_axis(&self) -> AngAxis

Converts the rotation matrix over to an angle-axis representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_ang_axis_comp(&self) -> AngAxisComp

Converts the rotation matrix over to a compact angle-axis representation which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_rod_vec(&self) -> RodVec

Converts the rotation matrix over to a Rodrigues vector representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_rod_vec_comp(&self) -> RodVecComp

Converts the rotation matrix over to a compact Rodrigues vector representation which has the following properties shape (3, nelems), memory order = fortran/column major.

fn to_quat(&self) -> Quat

Converts the rotation matrix over to a unit quaternion representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_homochoric(&self) -> Homochoric

Converts the rotation matrix representation over to a homochoric representation which has the following properties shape (4, nelems), memory order = fortran/column major.

fn to_bunge_inplace(&self, bunge: &mut Bunge)

Converts the rotation matrices to the equivalent bunge angles which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rmat_inplace(&self, rmat: &mut RMat)

Returns a copy of the initial rotation matrix data structure This operation is done inplace and does not create a new structure

fn to_ang_axis_inplace(&self, ang_axis: &mut AngAxis)

Converts the rotation matrix over to an angle-axis representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_ang_axis_comp_inplace(&self, ang_axis_comp: &mut AngAxisComp)

Converts the rotation matrix over to a compact angle-axis representation which has the following properties shape (3, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rod_vec_inplace(&self, rod_vec: &mut RodVec)

Converts the rotation matrix over to a Rodrigues vector representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_rod_vec_comp_inplace(&self, rod_vec_comp: &mut RodVecComp)

Converts the rotation matrix over to a compact Rodrigues vector representation which has the following properties shape (4, nelems), memory order = fortran/column major. This operation is done inplace and does not create a new structure

fn to_quat_inplace(&self, quat: &mut Quat)

This operation is done inplace and does not create a new structure

fn to_homochoric_inplace(&self, homochoric: &mut Homochoric)

This operation is done inplace and does not create a new structure

impl RotVector for RMat

A series of commonly used operations to rotate vector data by a given rotation

fn rot_vector(&self, vec: ArrayView2<f64>) -> Array2<f64>

rot_vector takes in a 2D array view of a series of vectors. It then rotates these vectors using the given rotation matrices. The newly rotated vectors are then returned. This function requires the number of elements in the rotation matrix to be either 1 or nelems. It also requires that the number of elements in the unrotated vector be 1 or nelems. If this condition is not met the function will error out. vec - the vector to be rotated must have dimensions 3xnelems or 3x1. Output - the rotated vector and has dimensions 3xnelems.

fn rot_vector_mut(&self, vec: ArrayView2<f64>, rvec: ArrayViewMut2<f64>)

rot_vector_mut takes in a 2D array view of a series of vectors and a mutable 2D ArrayView of the rotated vector. It then rotates these vectors using the given rotation matrices. The newly rotated vectors are assigned to the supplied rotated vector, rvec. This function requires the number of elements in the rotation matrix to be either 1 or nelems where rvec has nelems in it. It also requires that the number of elements in the unrotated vector be 1 or nelems. If these conditions are not met the function will error out. vec - the vector to be rotated must have dimensions 3xnelems or 3x1. rvec - the rotated vector and has dimensions 3xnelems.

fn rot_vector_inplace(&self, vec: ArrayViewMut2<f64>)

rot_vector_inplace takes in a mutable 2D array view of a series of vectors. It then rotates these vectors using the given rotation matrices. The newly rotated vectors are assigned to original vector. This function requires the number of elements in the rotation matrix to be either 1 or nelems where vec has nelems in it. If this condition is not met the function will error out. vec - the vector to be rotated must have dimensions 3xnelems.

impl RotTensor for RMat

A series of commonly used operations to rotate 2nd order 3x3 tensor data by a given rotation

fn rot_tensor(&self, tensor: ArrayView3<f64>) -> Array3<f64>

rot_tensor takes in a 3D array view of a series of tensors. It then rotates these tensors using the given rotation matrices. The newly rotated tensors are then returned. This function requires the number of elements in the rotation matrix to be either 1 or nelems where tensor has nelems in it. If this condition is not met the function will error out. tensor - the tensors to be rotated must have dimensions 3x3xnelems. Output - the rotated tensors and has dimensions 3x3xnelems.

fn rot_tensor_mut(&self, tensor: ArrayView3<f64>, rtensor: ArrayViewMut3<f64>)

rot_tensor_mut takes in a 3D array view of a series of tensors and a mutable 3D ArrayView of the rotated tensors. It then rotates these tensors using the given rotation matrices. The newly rotated tensors are assigned to the supplied rotated tensors, rtensor. This function requires the number of elements in the rotation matrix to be either 1 or nelems where tensor has nelems in it. It also requires the number of elements in rtensor and tensor to be equal. tensor - the tensors to be rotated must have dimensions 3x3xnelems. rtensor - the rotated tensors and has dimensions 3x3xnelems.

fn rot_tensor_inplace(&self, tensor: ArrayViewMut3<f64>)

rot_tensor_inplace takes in a mutable 3D array view of a series of tensors. It then rotates these tensors using the given rotation matrices. The newly rotated tensors are assigned in place of the supplied variable tensor. This function requires the number of elements in the rotation matrix to be either 1 or nelems where tensor has nelems in it. tensor - the tensors to be rotated must have dimensions 3x3xnelems.