elasticipy 2.9.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

Elasticipy/Plasticity.py

@@ -1,6 +1,7 @@
 import numpy as np
 from Elasticipy.StressStrainTensors import StrainTensor, StressTensor
 
+
 class IsotropicHardening:
     """
     Template class for isotropic hardening plasticity models
@@ -11,15 +12,19 @@ class IsotropicHardening:
 
         Parameters
         ----------
-        criterion : str, optional
+        criterion : str or PlasticityCriterion
             Plasticity criterion to use. Can be 'von Mises', 'Tresca' or 'J2'. J2 is the same as von Mises.
         """
-        criterion = criterion.lower()
-        if criterion in ('von mises', 'mises', 'vonmises', 'j2'):
-            criterion = 'j2'
-        elif criterion != 'tresca':
-            raise ValueError('The criterion can be "Tresca", "von Mises" or "J2".')
-        self.criterion = criterion.lower()
+        if isinstance(criterion, str):
+            criterion = criterion.lower()
+            if criterion in ('von mises', 'mises', 'vonmises', 'j2'):
+                self.criterion = VonMisesPlasticity
+            elif criterion == 'tresca':
+                self.criterion = TrescaPlasticity
+            else:
+                raise ValueError('The criterion can be "Tresca", "von Mises" or "J2".')
+        else:
+            self.criterion = criterion
         self.plastic_strain = 0.0
 
     def flow_stress(self, strain, **kwargs):
@@ -60,12 +65,6 @@ class IsotropicHardening:
     def reset_strain(self):
         self.plastic_strain = 0.0
 
-    def eq_stress(self, stress):
-        if self.criterion == 'j2':
-            return stress.vonMises()
-        else:
-            return stress.Tresca()
-
 
 class JohnsonCook(IsotropicHardening):
     def __init__(self, A, B, n, C=None, eps_dot_ref=1.0, m=None, T0=25, Tm=None, criterion='von Mises'):
@@ -93,7 +92,7 @@ class JohnsonCook(IsotropicHardening):
             Reference temperature
         Tm : float, optional
             Melting temperature (at which the flow stress is zero)
-        criterion : str, optional
+        criterion : str or PlasticityCriterion, optional
             Plasticity criterion to use. It can be 'von Mises' or 'Tresca'.
 
         Notes
@@ -194,7 +193,7 @@ class JohnsonCook(IsotropicHardening):
         apply_strain : apply strain to the JC model and updates its hardening value
         """
         if isinstance(stress, StressTensor):
-            eq_stress = self.eq_stress(stress)
+            eq_stress = self.criterion.eq_stress(stress)
         else:
             eq_stress = stress
         if T is None:
@@ -223,7 +222,7 @@ class JohnsonCook(IsotropicHardening):
             self.apply_strain(strain_increment)
 
         if isinstance(stress, StressTensor):
-            n = normality_rule(stress, criterion=criterion)
+            n = self.criterion.normal(stress)
             return n * strain_increment
         else:
             return strain_increment
@@ -235,48 +234,99 @@ class JohnsonCook(IsotropicHardening):
         self.plastic_strain = 0.0
 
 
-def normality_rule(stress, criterion='von Mises'):
-    """
-    Apply the normality rule for plastic flow, given a yield criterion.
-
-    The stress can be a single tensor, or an array of tensors.
-
-    Parameters
-    ----------
-    stress : StressTensor
-        Stress tensor to apply the normality rule from
-    criterion : str, optional
-        Name of the criterion to use. Can be either 'von Mises' or 'Tresca'
-
-    Returns
-    -------
-    StrainTensor
-        If a single stress tensor is passed, the returned array will be of shape
-
-    Notes
-    -----
-    The singular points for the Tresca criterion are treated as the von Mises criterion, which is equivalent to the
-    average of the two adjacent normals of the domain.
-    """
-    if criterion.lower()=='von mises':
+class PlasticityCriterion:
+    @staticmethod
+    def eq_stress(stress, **kwargs):
+        """
+        Return the equivalent stress, with respect to the plasticity criterion.
+
+        Parameters
+        ----------
+        stress : StressTensor
+            Stress to compute the equivalent stress from
+        kwargs : dict
+            keyword arguments passed to the function
+        Returns
+        -------
+        float or numpy.ndarray
+        """
+        pass
+
+    def normal(self, stress, **kwargs):
+        """
+        Apply the normality rule
+
+        Parameters
+        ----------
+        stress : StressTensor
+            Stress tensor to apply the normality rule
+        kwargs : dict
+            Keyword arguments passed to the function
+
+        Returns
+        -------
+        StrainTensor
+            Normalized direction of plastic flow
+        """
+        pass
+
+class VonMisesPlasticity(PlasticityCriterion):
+    @staticmethod
+    def eq_stress(stress, **kwargs):
+        return stress.vonMises()
+
+    @staticmethod
+    def normal(stress, **kwargs):
         eq_stress = stress.vonMises()
-        dev_stress= stress.deviatoric_part()
+        dev_stress = stress.deviatoric_part()
         gradient_tensor = dev_stress / eq_stress
-        return StrainTensor(3/2 * gradient_tensor.matrix)
-    elif criterion.lower()=='tresca':
+        return StrainTensor(3 / 2 * gradient_tensor.matrix)
+
+class TrescaPlasticity(PlasticityCriterion):
+    @staticmethod
+    def eq_stress(stress, **kwargs):
+        return stress.Tresca()
+
+    @staticmethod
+    def normal(stress, **kwargs):
         vals, dirs = stress.eig()
-        u1 = dirs[...,0]
-        u3 = dirs[...,2]
-        s1 = vals[...,0]
+        u1 = dirs[..., 0]
+        u3 = dirs[..., 2]
+        s1 = vals[..., 0]
         s2 = vals[..., 1]
-        s3 = vals[...,2]
-        A = np.einsum('...i,...j->...ij',u1, u1)
-        B = np.einsum('...i,...j->...ij',u3, u3)
-        normal = A - B
-        singular_points = np.logical_or(s2==s1, s2==s3)
-        normal[singular_points] = normality_rule(stress[singular_points], criterion='von Mises').matrix
-        normal[np.logical_and(s2==s1, s2==s3)] = 0.0
+        s3 = vals[..., 2]
+        a = np.einsum('...i,...j->...ij', u1, u1)
+        b = np.einsum('...i,...j->...ij', u3, u3)
+        normal = a - b
+        singular_points = np.logical_or(s2 == s1, s2 == s3)
+        normal[singular_points] = VonMisesPlasticity().normal(stress[singular_points]).matrix
+        normal[np.logical_and(s2 == s1, s2 == s3)] = 0.0
         strain = StrainTensor(normal)
         return strain / strain.eq_strain()
-    else:
-        raise NotImplementedError('The normality rule is only implemented for von Mises (J2) and Tresca criteria.')
+
+class DruckerPrager(PlasticityCriterion):
+    def __init__(self, alpha):
+        """
+        Create a Drucker-Prager (DG) plasticity criterion.
+
+        Parameters
+        ----------
+        alpha : float
+            Pressure dependence parameters (see notes for details)
+
+        Notes
+        -----
+        The pressure-dependent DG plasticity criterion assumes that the equivalent stress is defined as:
+
+
+        """
+        self.alpha = alpha
+
+    def eq_stress(self, stress, **kwargs):
+        return (stress.J2**0.5 + self.alpha * stress.I1) / (1/3**0.5 + self.alpha)
+
+    def normal(self, stress, **kwargs):
+        J2 = stress.J2
+        gradient = stress.deviatoric_part() / (2 * J2**0.5) + self.alpha * StressTensor.eye(stress.shape)
+        strain = StrainTensor(gradient.matrix)
+        return strain / strain.eq_strain()

Elasticipy/SecondOrderTensor.py

@@ -1,7 +1,9 @@
+import warnings
+
 import numpy as np
 import pandas as pd
 from scipy.spatial.transform import Rotation
-
+ALPHABET = 'abcdefghijklmnopqrstuv'
 
 class _MatrixProxy:
     def __init__(self, matrix):
@@ -36,6 +38,45 @@ def _transpose_matrix(matrix):
 def _symmetric_part(matrix):
     return 0.5 * (matrix + _transpose_matrix(matrix))
 
+def _orientation_shape(g):
+    if is_orix_rotation(g):
+        return g.shape
+    else:
+        return (len(g),)
+
+def _is_single_rotation(rotation):
+    if isinstance(rotation, Rotation):
+        return rotation.single
+    elif is_orix_rotation(rotation):
+        return rotation.size == 1
+    else:
+        raise TypeError('The input argument must be of class scipy.transform.Rotation or '
+                        'orix.quaternion.rotation.Rotation')
+
+_voigt_numbering = [[0, 0], [1, 1], [2, 2], [1, 2], [0, 2], [0, 1]]
+
+def _unmap(array, mapping_convention):
+    array = np.asarray(array)
+    shape = array.shape
+    if shape and (shape[-1] == 6):
+        new_shape = shape[:-1] + (3, 3)
+        unmapped_matrix = np.zeros(new_shape)
+        for i in range(6):
+            unmapped_matrix[..., _voigt_numbering[i][0], _voigt_numbering[i][1]] = array[..., i] / mapping_convention[i]
+        return unmapped_matrix
+    else:
+        raise ValueError("array must be of shape (6,) or (...,6) with Voigt vector")
+
+def _map(matrix, mapping_convention):
+    shape = matrix.shape[:-2] + (6,)
+    array = np.zeros(shape)
+    for i in range(6):
+        j, k = _voigt_numbering[i]
+        array[...,i] = matrix[...,j,k]
+    return array * mapping_convention
+
+kelvin_mapping = [1, 1, 1, np.sqrt(2), np.sqrt(2), np.sqrt(2)]
+
 class SecondOrderTensor:
     """
     Template class for manipulation of second order tensors or arrays of second order tensors
@@ -251,7 +292,7 @@ class SecondOrderTensor:
         I3 : Third invariant of the tensors (det)
         """
         a = self.I1**2
-        b = np.matmul(self.matrix, self._transposeTensor()).trace(axis1=-1, axis2=-2)
+        b = np.matmul(self.matrix, self._transpose_tensor()).trace(axis1=-1, axis2=-2)
         return 0.5 * (a - b)
 
     @property
@@ -391,13 +432,9 @@ class SecondOrderTensor:
         matmul : matrix-like multiplication of tensor arrays
         """
         if isinstance(B, SecondOrderTensor):
-            new_mat = np.matmul(self.matrix, B.matrix)
-            return SecondOrderTensor(new_mat)
+            return self.dot(B, mode='pair')
         elif isinstance(B, Rotation) or is_orix_rotation(B):
-            rotation_matrices, transpose_matrices = rotation_to_matrix(B, return_transpose=True)
-            new_matrix = np.matmul(np.matmul(transpose_matrices, self.matrix), rotation_matrices)
-            # In case of rotation, the property of the transformed tensor is kept
-            return self.__class__(new_matrix)
+            return self.rotate(B, mode='pair')
         elif isinstance(B, (float, int)):
             return self.__class__(self.matrix * B)
         elif isinstance(B, np.ndarray):
@@ -413,6 +450,44 @@ class SecondOrderTensor:
         else:
             raise ValueError('The input argument must be a tensor, an ndarray, a rotation or a scalar value.')
 
+    def rotate(self, rotation, mode='pair'):
+        """
+        Apply rotation(s) to the tensor(s).
+
+        The rotations can be applied element-wise, or on each cross-combination (see below).
+
+        Parameters
+        ----------
+        rotation : scipy.spatial.Rotation or orix.quaternion.Rotation
+        mode : str, optional
+            If 'pair', the rotations are applied element wise. Broadcasting rule applies.
+            If 'cross', all the possible combinations are considered. If ``C=A.rotate(rot)``, then
+            ``C.shape==A.shape + rot.shape``.
+
+        Returns
+        -------
+        SecondOrderTensor
+        """
+        if self.shape == ():
+            ein_str = '...li,...kj,lk->...ij'
+        elif _is_single_rotation(rotation):
+            ein_str = 'li,kj,...lk->...ij'
+        else:
+            if mode=='pair':
+                ein_str = '...li,...kj,...lk->...ij'
+            elif mode=='cross':
+                ndim_0 = self.ndim
+                ndim_1 = len(_orientation_shape(rotation))
+                indices_self = ALPHABET[:ndim_0]
+                indices_g = ALPHABET[:ndim_1].upper()
+                indices_res = indices_self + indices_g
+                ein_str = indices_g + 'zw,' + indices_g + 'yx,' + indices_self + 'zy->' + indices_res + 'wx'
+            else:
+                raise ValueError('Invalid mode. It can be "cross" or "pair".')
+        g_mat = rotation_to_matrix(rotation)
+        matrix = np.einsum(ein_str, g_mat, g_mat, self.matrix)
+        return self.__class__(matrix)
+
     def __rmul__(self, other):
         if isinstance(other, (float, int)):
             return self.__mul__(other)
@@ -431,7 +506,7 @@ class SecondOrderTensor:
             raise NotImplementedError('Tensors can only be divided by scalar values or by arrays of the same shape.')
         return self.__class__(new_mat)
 
-    def __eq__(self, other) -> np.ndarray:
+    def __eq__(self, other):
         """
         Check whether the tensors in the tensor array are equal
 
@@ -442,7 +517,7 @@ class SecondOrderTensor:
 
         Returns
         -------
-        np.array of bool
+        numpy.ndarray
             True element is True if the corresponding tensors are equal.
         """
         if isinstance(other, SecondOrderTensor):
@@ -453,6 +528,73 @@ class SecondOrderTensor:
             else:
                 raise ValueError('The value to compare must be an array of shape {} or {}'.format(self.shape, self.shape + (3,3)))
 
+    def dot(self, other, mode='pair'):
+        """
+        Perform contraction product ("dot product") between tensor.
+
+        On tensor arrays, the product contraction can be performed element-wise, or considering all cross-combinations
+        (see below).
+
+        Parameters
+        ----------
+        other : SecondOrderTensor
+            tensor or tensor array to compute the product from
+        mode : str, optional
+            If 'pair' (default), the contraction products of tensor arrays are applied element-wise. Broadcasting rule
+             applies.
+
+            If 'cross', all combinations of contraction product are considered. If ``C=A.dot(B,mode='cross')``, then
+            ``C.shape==A.shape + B.shape``
+
+        Returns
+        -------
+        SecondOrderTensor
+
+        Examples
+        --------
+        >>> from Elasticipy.SecondOrderTensor import SecondOrderTensor
+        >>> A=SecondOrderTensor.rand(10)
+        >>> B=SecondOrderTensor.rand(10)
+        >>> AB_pair = A.dot(B)
+        >>> AB_pair.shape
+        (10,)
+
+        >>> AB_cross = A.dot(B, mode='cross')
+        >>> AB_cross.shape
+        (10, 10)
+
+        We can for instance check that:
+
+        >>> AB_pair[5] == A[5].dot(B[5])
+        True
+
+        and:
+
+        >>> AB_cross[0,1] == A[0].dot(B[1])
+        True
+
+        See Also
+        --------
+        ddot : Double-contraction product
+        """
+        if self.shape == ():
+            ein_str = 'ik,...kj->...ij'
+        else:
+            if mode=='pair':
+                ein_str = '...ik,...kj->...ij'
+            elif mode=='cross':
+                ndim_0 = self.ndim
+                ndim_1 = other.ndim
+                indices_0 = ALPHABET[:ndim_0]
+                indices_1 = ALPHABET[:ndim_1].upper()
+                indices_2 = indices_0 + indices_1
+                ein_str = indices_0 + 'ik,' + indices_1 + 'kj->' + indices_2 + 'ij'
+            else:
+                raise ValueError('Invalid mode. Use "pair" or "cross".')
+        matrix = np.einsum(ein_str, self.matrix, other.matrix)
+        return SecondOrderTensor(matrix)
+
+
     def matmul(self, other):
         """
         Perform matrix-like product between tensor arrays. Each "product" is a matrix product between
@@ -481,28 +623,19 @@ class SecondOrderTensor:
         --------
         __mul__ : Element-wise matrix product
         """
+        warnings.warn(
+            'matmul() is deprecated and will be removed in a future version. Use dot(tensor,mode="cross") or '
+            'rotate(rotation,mode="cross") instead.',
+            DeprecationWarning,
+            stacklevel=2)
         if isinstance(other, SecondOrderTensor):
-            other_matrix = other.matrix
+            return self.dot(other, mode='cross')
         elif isinstance(other, Rotation) or is_orix_rotation(Rotation):
-            other_matrix = rotation_to_matrix(other)
-        else:
-            other_matrix = other
-        matrix = self.matrix
-        shape_matrix = matrix.shape[:-2]
-        shape_other = other_matrix.shape[:-2]
-        extra_dim_matrix = len(shape_other)
-        extra_dim_other = len(shape_matrix)
-        matrix_expanded = matrix.reshape(shape_matrix + (1,) * extra_dim_other + (3, 3))
-        other_expanded = other_matrix.reshape((1,) * extra_dim_matrix + shape_other + (3, 3))
-        if isinstance(other, Rotation):
-            other_expanded_t = _transpose_matrix(other_expanded)
-            new_mat = np.matmul(np.matmul(other_expanded_t, matrix_expanded), other_expanded)
-            return self.__class__(np.squeeze(new_mat))
+            return self.rotate(other, mode='cross')
         else:
-            new_mat = np.matmul(matrix_expanded, other_expanded)
-            return SecondOrderTensor(np.squeeze(new_mat))
+            raise ValueError('The input argument must be either a rotation or a SecondOrderTensor')
 
-    def transposeArray(self):
+    def transpose_array(self):
         """
         Transpose the array of tensors
 
@@ -531,19 +664,19 @@ class SecondOrderTensor:
         """
         Transpose the array of tensors.
 
-        It is actually an alias for transposeArray()
+        It is actually an alias for transpose_array()
 
         Returns
         -------
         SecondOrderTensor
             Transposed array
         """
-        return self.transposeArray()
+        return self.transpose_array()
 
-    def _transposeTensor(self):
+    def _transpose_tensor(self):
         return _transpose_matrix(self.matrix)
 
-    def transposeTensor(self):
+    def transpose_tensor(self):
         """
         Transpose of tensors of the tensor array
 
@@ -554,11 +687,11 @@ class SecondOrderTensor:
 
         See Also
         --------
-        Transpose : transpose the array (not the components)
+        transpose_array : transpose the array (not the components)
         """
-        return self.__class__(self._transposeTensor())
+        return self.__class__(self._transpose_tensor())
 
-    def ddot(self, other):
+    def ddot(self, other, mode='pair'):
         """
         Double dot product (contraction of tensor product, usually denoted ":") of two tensors.
 
@@ -570,6 +703,11 @@ class SecondOrderTensor:
         ----------
         other : SecondOrderTensor or np.ndarray
             Tensor or tensor array to multiply by before contraction.
+        mode : str, optional
+            If "pair", the dot products are performed element-wise before contraction. Broadcasting rule applies.
+            If "cross", all the cross-combinations are computed, increasing the dimensionality.
+            If ``C=A.ddot(B, mode='cross')``, then ``C.shape = A.shape + B.shape``.
+
 
         Returns
         -------
@@ -578,10 +716,10 @@ class SecondOrderTensor:
 
         See Also
         --------
-        matmul : matrix-like product between two tensor arrays.
+        dot : contraction product ("dot product") between tensor.
 
         """
-        tensor_prod = self.transposeTensor()*other
+        tensor_prod = self.transpose_tensor().dot(other, mode=mode)
         return tensor_prod.trace()
 
     def _flatten(self):
@@ -750,7 +888,7 @@ class SecondOrderTensor:
             return self
 
     def _symmetric_part(self):
-        return 0.5 * (self.matrix + self._transposeTensor())
+        return 0.5 * (self.matrix + self._transpose_tensor())
 
     def symmetric_part(self):
         """
@@ -776,7 +914,7 @@ class SecondOrderTensor:
         SkewSymmetricSecondOrderTensor
             Skew-symmetric tensor
         """
-        new_mat = 0.5 * (self.matrix - self._transposeTensor())
+        new_mat = 0.5 * (self.matrix - self._transpose_tensor())
         return SkewSymmetricSecondOrderTensor(new_mat)
 
     def spherical_part(self):
@@ -922,7 +1060,7 @@ class SecondOrderTensor:
 
         Parameters
         ----------
-        shape : tuple, optional
+        shape : int or tuple, optional
             Shape of the tensor array. If not provided, a single tensor is returned
         seed : int, optional
             Sets the seed for random generation. Useful to ensure reproducibility
@@ -954,6 +1092,8 @@ class SecondOrderTensor:
         """
         if shape is None:
             shape = (3,3)
+        elif isinstance(shape, int):
+            shape = (shape, 3, 3)
         else:
             shape = shape + (3,3)
         rng = np.random.default_rng(seed)
@@ -1281,7 +1421,10 @@ class SymmetricSecondOrderTensor(SecondOrderTensor):
         >>> a==b
         True
         """
-        mat = np.asarray(mat, dtype=float)
+        if isinstance(mat, SecondOrderTensor):
+            mat = mat.matrix
+        else:
+            mat = np.asarray(mat, dtype=float)
         mat_transposed = _transpose_matrix(mat)
         if np.all(np.isclose(mat, mat_transposed)) or force_symmetry:
             # The input matrix is symmetric
@@ -1308,10 +1451,15 @@ class SymmetricSecondOrderTensor(SecondOrderTensor):
         ----------
         array : np.ndarray or list
             array to build the SymmetricSecondOrderTensor from. We must have array.ndim>0 and array.shape[-1]==6.
+
         Returns
         -------
         SymmetricSecondOrderTensor
 
+        See Also
+        --------
+        from_Kelvin : Construct a tensor from vector(s) following the Kelvin notation
+
         Examples
         --------
         >>> from Elasticipy.SecondOrderTensor import SymmetricSecondOrderTensor
@@ -1320,23 +1468,62 @@ class SymmetricSecondOrderTensor(SecondOrderTensor):
         [[11. 12. 13.]
          [12. 22. 23.]
          [13. 23. 33.]]
+        """
+        matrix = _unmap(array, cls.voigt_map)
+        return cls(matrix)
 
+    def to_Voigt(self):
         """
-        array = np.asarray(array)
-        shape = array.shape
-        if shape and (shape[-1] == 6):
-            new_shape = shape[:-1] + (3, 3)
-            unvoigted_matrix = np.zeros(new_shape)
-            voigt = [[0, 0], [1, 1], [2, 2], [1, 2], [0, 2], [0, 1]]
-            for i in range(6):
-                unvoigted_matrix[..., voigt[i][0], voigt[i][1]] = array[..., i] / cls.voigt_map[i]
-            return cls(unvoigted_matrix)
-        else:
-            raise ValueError("array must be of shape (6,) or (...,6) with Voigt vector")
+        Convert the tensor to vector, or slices of vector, following the Voigt convention.
+        
+        If the tensor array has shape (m,n,...), the result will be of shape (m,n,...,6).
+        
+        Returns
+        -------
+        numpy.ndarray
+            Voigt vector summarizing the components
+        """
+        return _map(self.matrix, self.voigt_map)
+    
+    @classmethod
+    def from_Kelvin(cls, array):
+        """
+        Build a tensor from the Kelvin vector, or slices of Kelvin vectors
+
+        Parameters
+        ----------
+        array : np.ndarray or list
+            Vectors, or slices of vectors, consisting in components following the Kelvin convention
+        Returns
+        -------
+        SymmetricSecondOrderTensor
+
+        See Also
+        --------
+        from_Voigt : construct a tensor from vector(s) following the Voigt notation
+        to_Kelvin : convert the tensor to vector(s) following the Kelvin convention
+        """
+        matrix = _unmap(array, kelvin_mapping)
+        return cls(matrix)
+    
+    def to_Kelvin(self):
+        """
+        Convert the tensor to vector, or slices of vector, following the Kelvin(-Mandel) convention.
+
+        Returns
+        -------
+        numpy.ndarray
+
+        See Also
+        --------
+        from_Kelvin : Construct a tensor from vector(s) following the Kelvin convention
+        to_Voigt : Convert the tensor to vector(s) following the Voigt convention
+        """
+        return _map(self.matrix, kelvin_mapping)
 
     def eig(self):
         """
-        Compute the principal values (eigenvaleues) and principal direction (eigenvectors) of the tensor, sorted in
+        Compute the principal values (eigenvalues) and principal direction (eigenvectors) of the tensor, sorted in
         descending order of principal values
 
         Returns
@@ -1351,7 +1538,7 @@ class SymmetricSecondOrderTensor(SecondOrderTensor):
         eigvals : compute the principal values only
         """
         eigvals, eigdir = np.linalg.eigh(self.matrix)
-        return np.flip(eigvals,axis=-1), np.flip(eigdir,axis=-1)
+        return eigvals[..., ::-1], eigdir[..., :, ::-1]
 
     def eigvals(self):
         """
@@ -1437,6 +1624,8 @@ def rotation_to_matrix(rotation, return_transpose=False):
     elif is_orix_rotation(rotation):
         inv_rotation = ~rotation
         matrix = inv_rotation.to_matrix()
+        if matrix.shape == (1,3,3):
+            matrix = matrix[0]
     else:
         raise TypeError('The input argument must be of class scipy.transform.Rotation or '
                         'orix.quaternion.rotation.Rotation')