elasticipy 4.0.0__py3-none-any.whl → 4.1.0__py3-none-any.whl

Elasticipy/tensors/fourth_order.py

@@ -3,14 +3,7 @@ from Elasticipy.tensors.second_order import SymmetricSecondOrderTensor, rotation
     SecondOrderTensor, ALPHABET
 from scipy.spatial.transform import Rotation
 from copy import deepcopy
-
-a = np.sqrt(2)
-KELVIN_MAPPING_MATRIX = np.array([[1, 1, 1, a, a, a],
-                                  [1, 1, 1, a, a, a],
-                                  [1, 1, 1, a, a, a],
-                                  [a, a, a, 2, 2, 2],
-                                  [a, a, a, 2, 2, 2],
-                                  [a, a, a, 2, 2, 2], ])
+from Elasticipy.tensors.mapping import KelvinMapping, VoigtMapping
 
 
 def voigt_indices(i, j):
@@ -77,12 +70,12 @@ class FourthOrderTensor:
 
     Attributes
     ----------
-    matrix : np.ndarray
+    _matrix : np.ndarray
         (6,6) matrix gathering all the components of the tensor, using the Voigt notation.
     """
     tensor_name = '4th-order'
 
-    def __init__(self, M, mapping='Kelvin', check_minor_symmetry=True, force_minor_symmetry=False):
+    def __init__(self, M, mapping=KelvinMapping(), check_minor_symmetry=True, force_minor_symmetry=False):
         """
         Construct of Fourth-order tensor with minor symmetry.
 
@@ -91,7 +84,7 @@ class FourthOrderTensor:
         M : np.ndarray
             (6,6) matrix corresponding to the stiffness tensor, written using the Voigt notation, or array of shape
             (3,3,3,3).
-        mapping : str or list of list, or numpy/ndarray, optional
+        mapping : MappingConvention, optional
             Mapping convention to translate the (3,3,3,3) array to (6,6) matrix
         check_minor_symmetry : bool, optional
             If true (default), check that the input array have minor symmetries (see Notes). Only used if an array of
@@ -108,19 +101,7 @@ class FourthOrderTensor:
             M_{ijkl}=M_{jikl}=M_{jilk}=M_{ijlk}
 
         """
-        if isinstance(mapping, (list, tuple, np.ndarray)):
-            self.mapping_matrix = mapping
-            self.mapping_name = 'custom'
-        else:
-            mapping = mapping.capitalize()
-            self.mapping_name = mapping
-            if mapping == 'Kelvin':
-                self.mapping_matrix = KELVIN_MAPPING_MATRIX
-            elif mapping == 'Voigt':
-                self.mapping_matrix = np.ones((6,6))
-            else:
-                raise ValueError('The mapping to use can be either "Kelvin", "Voigt", or a (6,6) matrix.')
-
+        self.mapping=mapping
         M = np.asarray(M)
         if M.shape[-2:] == (6, 6):
             matrix = M
@@ -137,11 +118,11 @@ class FourthOrderTensor:
             matrix = self._full_to_matrix(M)
         else:
             raise ValueError('The input matrix must of shape (...,6,6) or (...,3,3,3,3)')
-        self.matrix = matrix
+        self._matrix = matrix
         for i in range(0, 6):
             for j in range(0, 6):
                 def getter(obj, I=i, J=j):
-                    return obj.matrix[...,I, J]
+                    return obj._matrix[...,I, J]
 
                 getter.__doc__ = f"Returns the ({i + 1},{j + 1}) component of the {self.tensor_name} matrix."
                 component_name = 'C{}{}'.format(i + 1, j + 1)
@@ -149,8 +130,8 @@ class FourthOrderTensor:
 
     def __repr__(self):
         if (self.ndim == 0) or ((self.ndim==1) and self.shape[0]<5):
-            msg = '{} tensor (in {} mapping):\n'.format(self.tensor_name, self.mapping_name)
-            msg += self.matrix.__str__()
+            msg = '{} tensor (in {} mapping):\n'.format(self.tensor_name, self.mapping.name)
+            msg += self._matrix.__str__()
         else:
             msg = '{} tensor array of shape {}'.format(self.tensor_name, self.shape)
         return msg
@@ -164,7 +145,7 @@ class FourthOrderTensor:
         tuple
             Shape of the tensor array
         """
-        *shape, _, _ = self.matrix.shape
+        *shape, _, _ = self._matrix.shape
         return tuple(shape)
 
     def full_tensor(self):
@@ -179,7 +160,7 @@ class FourthOrderTensor:
         i, j, k, ell = np.indices((3, 3, 3, 3))
         ij = voigt_indices(i, j)
         kl = voigt_indices(k, ell)
-        m = self.matrix[..., ij, kl] / self.mapping_matrix[ij, kl]
+        m = self._matrix[..., ij, kl] / self.mapping.matrix[ij, kl]
         return m
 
     def flatten(self):
@@ -197,7 +178,7 @@ class FourthOrderTensor:
         if shape:
             t2 = deepcopy(self)
             p = (np.prod(self.shape), 6, 6)
-            t2.matrix = self.matrix.reshape(p)
+            t2._matrix = self._matrix.reshape(p)
             return t2
         else:
             return self
@@ -206,7 +187,7 @@ class FourthOrderTensor:
         kl, ij = np.indices((6, 6))
         i, j = unvoigt_index(ij).T
         k, ell = unvoigt_index(kl).T
-        return full_tensor[..., i, j, k, ell] * self.mapping_matrix[ij, kl]
+        return full_tensor[..., i, j, k, ell] * self.mapping.matrix[ij, kl]
 
     def rotate(self, rotation):
         """
@@ -224,7 +205,7 @@ class FourthOrderTensor:
         """
         t2 = deepcopy(self)
         rotated_tensor = rotate_tensor(self.full_tensor(), rotation)
-        t2.matrix = self._full_to_matrix(rotated_tensor)
+        t2._matrix = self._full_to_matrix(rotated_tensor)
         return t2
 
     @property
@@ -261,13 +242,13 @@ class FourthOrderTensor:
         t2 = deepcopy(self)
         if axis is None:
             axis = tuple([i for i in range(0,self.ndim)])
-        t2.matrix = np.mean(self.matrix, axis=axis)
+        t2._matrix = np.mean(self._matrix, axis=axis)
         return t2
 
     def __add__(self, other):
         if isinstance(other, np.ndarray):
             if other.shape == (6, 6):
-                mat = self.matrix + other
+                mat = self._matrix + other
             elif other.shape == (3, 3, 3, 3):
                 mat = self._full_to_matrix(self.full_tensor() + other)
             else:
@@ -279,17 +260,17 @@ class FourthOrderTensor:
                 raise ValueError('The two tensors to add must be of the same class.')
         else:
             raise ValueError('I don''t know how to add {} with {}.'.format(type(self), type(other)))
-        return self.__class__(mat, mapping=self.mapping_matrix)
+        return self.__class__(mat, mapping=self.mapping)
 
     def __sub__(self, other):
         if isinstance(other, FourthOrderTensor):
-            return self.__add__(-other.matrix)
+            return self.__add__(-other._matrix)
         else:
             return self.__add__(-other)
 
     def __neg__(self):
         t = deepcopy(self)
-        t.matrix = -t.matrix
+        t._matrix = -t._matrix
         return t
 
     def ddot(self, other, mode='pair'):
@@ -348,14 +329,14 @@ class FourthOrderTensor:
         elif isinstance(other, np.ndarray):
             shape = other.shape
             if other.shape == self.shape[-len(shape):]:
-                matrix = self.matrix * other[...,np.newaxis, np.newaxis]
+                matrix = self._matrix * other[...,np.newaxis, np.newaxis]
                 return self.__class__(matrix)
             else:
                 raise ValueError('The arrays to multiply could not be broadcasted with shapes {} and {}'.format(self.shape, other.shape[:-2]))
         elif isinstance(other, Rotation) or is_orix_rotation(other):
             return self.rotate(other)
         else:
-            return self.__class__(self.matrix * other)
+            return self.__class__(self._matrix * other)
 
     def __truediv__(self, other):
         if isinstance(other, (SecondOrderTensor, FourthOrderTensor)):
@@ -378,7 +359,7 @@ class FourthOrderTensor:
             return self
         else:
             new_axes = tuple(range(ndim))[::-1] + (ndim, ndim + 1)
-            transposed_matrix = self.matrix.transpose(new_axes)
+            transposed_matrix = self._matrix.transpose(new_axes)
             return self.__class__(transposed_matrix)
 
     def __rmul__(self, other):
@@ -389,16 +370,16 @@ class FourthOrderTensor:
 
     def __eq__(self, other):
         if isinstance(other, FourthOrderTensor):
-            return np.all(self.matrix == other.matrix, axis=(-1,-2))
+            return np.all(self._matrix == other._matrix, axis=(-1, -2))
         elif isinstance(other, (float, int)) or (isinstance(other, np.ndarray) and other.shape[-2:] == (6, 6)):
-            return np.all(self.matrix == other, axis=(-1,-2))
+            return np.all(self._matrix == other, axis=(-1, -2))
         else:
             raise NotImplementedError('The element to compare with must be a fourth-order tensor '
                                       'or an array of shape (6,6).')
 
     def __getitem__(self, item):
         if self.ndim:
-            sub_mat= self.matrix[item]
+            sub_mat= self._matrix[item]
             if sub_mat.shape[-2:] != (6,6):
                 raise IndexError('Too many indices for tensor array: array is {}-dimensional, but {} were provided'.format(self.ndim, len(item)))
             else:
@@ -409,19 +390,19 @@ class FourthOrderTensor:
     def __setitem__(self, index, value):
         if isinstance(value, np.ndarray):
             if value.shape[-2:] == (6,6):
-                self.matrix[index] = value
+                self._matrix[index] = value
             elif value.shape[-4:] == (3,3,3,3):
                 submatrix = self._full_to_matrix(value)
-                self.matrix[index] = submatrix
+                self._matrix[index] = submatrix
             else:
                 return ValueError('The R.h.s must be either of shape (...,6,6) or (...,3,3,3,3)')
         elif isinstance(value, FourthOrderTensor):
-            self.matrix[index] = value.matrix / value.mapping_matrix * self.mapping_matrix
+            self._matrix[index] = value._matrix / value.mapping.matrix * self.mapping.matrix
         else:
             raise NotImplementedError('The r.h.s must be either an ndarray or an object of class {}'.format(self.__class__))
 
     @classmethod
-    def identity(cls, shape=(), return_full_tensor=False, mapping='Kelvin'):
+    def identity(cls, shape=(), return_full_tensor=False, mapping=KelvinMapping()):
         """
         Create a 4th-order identity tensor
 
@@ -432,6 +413,8 @@ class FourthOrderTensor:
         return_full_tensor : bool, optional
             If True, return the full tensor as a (3,3,3,3) or a (...,3,3,3,3) array. Otherwise, the tensor is returned
             as a SymmetricTensor object.
+        mapping : str, optional
+            Mapping convention to use. Must be either Kelvin or Voigt.
 
         Returns
         -------
@@ -452,6 +435,82 @@ class FourthOrderTensor:
         else:
             return cls(full, mapping=mapping)
 
+    @classmethod
+    def identity_spherical_part(cls, shape=(), return_full_tensor=False, mapping=KelvinMapping()):
+        """
+        Return the spherical part of the identity tensor
+
+        Parameters
+        ----------
+        shape : tuple of int, optional
+            Shape of the tensor to create
+        return_full_tensor : bool, optional
+            if true, the full tensor is returned as a (3,3,3,3) or a (...,3,3,3,3) array
+        mapping : str, optional
+            Mapping convention to use. Must be either Kelvin or Voigt.
+
+        Returns
+        -------
+        FourthOrderTensor or SymmetricTensor
+        """
+        eye = np.eye(3)
+        if isinstance(shape, int):
+            shape = (shape,)
+        if len(shape):
+            for n in np.flip(shape):
+                eye = np.repeat(eye[np.newaxis,...], n, axis=0)
+        J = np.einsum('...ij,...kl->...ijkl',eye, eye)/3
+        if return_full_tensor:
+            return J
+        else:
+            return FourthOrderTensor(J, mapping=mapping)
+
+    @classmethod
+    def identity_deviatoric_part(cls, shape=(), return_full_tensor=False, mapping=KelvinMapping()):
+        """
+        Return the deviatoric part of the identity tensor
+
+        Parameters
+        ----------
+        shape : tuple of int, optional
+            Shape of the tensor to create
+        return_full_tensor : bool, optional
+            if true, the full tensor is returned as a (3,3,3,3) or a (...,3,3,3,3) array
+        mapping : str, optional
+            Mapping convention to use. Must be either Kelvin or Voigt.
+
+        Returns
+        -------
+        FourthOrderTensor or SymmetricTensor
+        """
+        I = FourthOrderTensor.identity(shape, return_full_tensor, mapping)
+        J = FourthOrderTensor.identity_spherical_part(shape, return_full_tensor, mapping)
+        return I-J
+
+    def spherical_part(self):
+        """
+        Return the spherical part of the tensor
+
+        Returns
+        -------
+        FourthOrderTensor
+            Spherical part of the tensor
+        """
+        I = self.identity_spherical_part(shape=self.shape)
+        return I.ddot(self)
+
+    def deviatoric_part(self):
+        """
+        Return the deviatoric part of the tensor
+
+        Returns
+        -------
+        FourthOrderTensor
+            Deviatoric part of the tensor
+        """
+        K = self.identity_deviatoric_part(shape=self.shape)
+        return K.ddot(self)
+
     def inv(self):
         """
         Invert the tensor. The inverted tensors inherits the properties (if any)
@@ -461,10 +520,8 @@ class FourthOrderTensor:
         FourthOrderTensor
             Inverse tensor
         """
-        t2 = deepcopy(self)
-        new_matrix = np.linalg.inv(self.matrix)
-        t2.matrix = new_matrix
-        return t2
+        matrix_inv = np.linalg.inv(self._matrix)
+        return self.__class__(matrix_inv, mapping=self.mapping.mapping_inverse)
 
     @classmethod
     def zeros(cls, shape=()):
@@ -486,6 +543,20 @@ class FourthOrderTensor:
         zeros = np.zeros(shape)
         return cls(zeros)
 
+    def matrix(self, mapping_convention=None):
+        matrix = self._matrix
+        if mapping_convention is None:
+            return matrix
+        else:
+            if isinstance(mapping_convention, str):
+                if mapping_convention.lower() == 'voigt':
+                    mapping_convention = VoigtMapping()
+                elif mapping_convention.lower() == 'kelvin':
+                    mapping_convention = KelvinMapping()
+                else:
+                    raise ValueError('Mapping convention must be either Kelvin or Voigt')
+            return matrix / self.mapping._matrix * mapping_convention.matrix
+
 class SymmetricFourthOrderTensor(FourthOrderTensor):
     tensor_name = 'Symmetric 4th-order'
 
@@ -521,8 +592,8 @@ class SymmetricFourthOrderTensor(FourthOrderTensor):
         """
         super().__init__(M, check_minor_symmetry=check_symmetries, force_minor_symmetry=force_symmetries, **kwargs)
         if force_symmetries:
-            self.matrix = 0.5*(self.matrix + self.matrix.swapaxes(-1,-2))
-        elif check_symmetries and not np.all(np.isclose(self.matrix, self.matrix.swapaxes(-1, -2))):
+            self._matrix = 0.5 * (self._matrix + self._matrix.swapaxes(-1, -2))
+        elif check_symmetries and not np.all(np.isclose(self._matrix, self._matrix.swapaxes(-1, -2))):
             raise ValueError('The input matrix must be symmetric')
 
     def invariants(self, order='all'):
@@ -535,7 +606,7 @@ class SymmetricFourthOrderTensor(FourthOrderTensor):
         ----------
         order : str, optional
             If 'linear', only A1 and A2 are returned
-            If 'quadratic', A1², A2², B1, B2, B3, B4 and B5 are returned
+            If 'quadratic', A1², A2², A1*A2, B1, B2, B3, B4 and B5 are returned
             If 'all' (default), A1, A2, A1², A2², B1, B2, B3, B4 and B5 are returned
 
         Returns

Elasticipy/tensors/mapping.py

@@ -0,0 +1,44 @@
+import numpy as np
+
+a = np.sqrt(2)
+KELVIN_MAPPING_MATRIX = np.array([[1, 1, 1, a, a, a],
+                                  [1, 1, 1, a, a, a],
+                                  [1, 1, 1, a, a, a],
+                                  [a, a, a, 2, 2, 2],
+                                  [a, a, a, 2, 2, 2],
+                                  [a, a, a, 2, 2, 2], ])
+
+VOIGT_MAPPING_MATRIX_COMPLIANCE = [[1, 1, 1, 2, 2, 2],
+                                  [1, 1, 1, 2, 2, 2],
+                                  [1, 1, 1, 2, 2, 2],
+                                  [2, 2, 2, 4, 4, 4],
+                                  [2, 2, 2, 4, 4, 4],
+                                  [2, 2, 2, 4, 4, 4]]
+
+class MappingConvention:
+    matrix = np.array(KELVIN_MAPPING_MATRIX)
+
+    @property
+    def mapping_inverse(self):
+        return self
+
+class KelvinMapping(MappingConvention):
+    name = 'Kelvin'
+
+class VoigtMapping(MappingConvention):
+    name = 'Voigt'
+
+    def __init__(self, tensor='Stiffness'):
+        if tensor == 'Stiffness':
+            self.matrix = np.ones((6,6))
+            self.tensor_type = 'Stiffness'
+        else:
+            self.matrix = np.array(VOIGT_MAPPING_MATRIX_COMPLIANCE)
+            self.tensor_type = 'Compliance'
+
+    @property
+    def mapping_inverse(self):
+        if self.tensor_type == 'Stiffness':
+            return VoigtMapping(tensor='Compliance')
+        else:
+            return VoigtMapping(tensor='Stiffness')

Elasticipy/tensors/second_order.py

@@ -1,5 +1,5 @@
 import warnings
-
+import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 from scipy.spatial.transform import Rotation
@@ -75,6 +75,15 @@ def _map(matrix, mapping_convention):
         array[...,i] = matrix[...,j,k]
     return array * mapping_convention
 
+def filldraw_circle(ax, center, radius, color, fill=False, alpha=1.):
+    theta = np.linspace(0, 2 * np.pi, 500)
+    x = center[0] + radius * np.cos(theta)
+    y = center[1] + radius * np.sin(theta)
+    if fill:
+        ax.fill(x, y, color=color, alpha=alpha)
+    else:
+        ax.plot(x, y, color=color)
+
 kelvin_mapping = [1, 1, 1, np.sqrt(2), np.sqrt(2), np.sqrt(2)]
 
 class SecondOrderTensor:
@@ -1380,6 +1389,53 @@ class SecondOrderTensor:
         else:
             return Constructor(self.matrix)
 
+    @classmethod
+    def stack(cls, arrays, axis=0):
+        """
+        Stack tensor arrays along the specified axis.
+
+        Parameters
+        ----------
+        arrays : list of SecondOrderTensor or tuple of SecondOrderTensor
+            List of tensor to stack together
+        axis : int, optional
+            Axis along which to stack
+
+        Returns
+        -------
+        SecondOrderTensor
+            Stacked tensor array
+
+        Examples
+        --------
+        >>> from Elasticipy.tensors.second_order import SecondOrderTensor
+        >>> import numpy as np
+        >>> a = SecondOrderTensor.rand(shape=3)
+        >>> b = SecondOrderTensor.rand(shape=3)
+        >>> c = SecondOrderTensor.stack((a, b))
+        >>> c.shape
+        (2, 3)
+        >>> np.all(c[0] == a)
+        True
+        >>> np.all(c[1] == b)
+        True
+
+        >>> a = SecondOrderTensor.rand(shape=(3, 4))
+        >>> b = SecondOrderTensor.rand(shape=(3, 4))
+        >>> c = SecondOrderTensor.stack((a, b), axis=1)
+        >>> c.shape
+        (3, 2, 4)
+        >>> np.all(c[:,0,:] == a)
+        True
+        >>> np.all(c[:,1,:] == b)
+        True
+        """
+        mat_array = [a.matrix for a in arrays]
+        if axis<0:
+            axis = axis - 2
+        mat_stacked = np.stack(mat_array, axis=axis)
+        return cls(mat_stacked)
+
 
 class SymmetricSecondOrderTensor(SecondOrderTensor):
     voigt_map = [1, 1, 1, 1, 1, 1]
@@ -1440,7 +1496,7 @@ class SymmetricSecondOrderTensor(SecondOrderTensor):
                              'matrices.')
 
     @classmethod
-    def from_Voigt(cls, array):
+    def from_Voigt(cls, array, voigt_map=None):
         """
         Construct a SymmetricSecondOrderTensor from a Voigt vector, or slices of Voigt vectors.
 
@@ -1452,6 +1508,10 @@ 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.
 
+        voigt_map : list or tuple, optional
+            6-lenght list of factors to use for mapping. If None (default), the default Voigt map of the constructor is
+            used.
+
         Returns
         -------
         SymmetricSecondOrderTensor
@@ -1469,7 +1529,9 @@ class SymmetricSecondOrderTensor(SecondOrderTensor):
          [12. 22. 23.]
          [13. 23. 33.]]
         """
-        matrix = _unmap(array, cls.voigt_map)
+        if voigt_map is None:
+            voigt_map = cls.voigt_map
+        matrix = _unmap(array, voigt_map)
         return cls(matrix)
 
     def to_Voigt(self):
@@ -1556,6 +1618,48 @@ class SymmetricSecondOrderTensor(SecondOrderTensor):
         eigvals = np.linalg.eigvalsh(self.matrix)
         return np.flip(eigvals,axis=-1)
 
+    def draw_Mohr_circles(self):
+        """
+        Draw the Mohr circles of the symmetric second-order tensor
+
+        Given a tensor, the Mohr circles are meant to visually illustrate the possible shear components one can find
+        when randomly rotating the tensor. See `here <https://en.wikipedia.org/wiki/Mohr%27s_circle>`_ for details.
+
+        Returns
+        -------
+        fig : matplotlib.figure.Figure
+            The Matplotlib figure containing the plot.
+        ax : matplotlib.axes._axes.Axes
+            The Matplotlib axes of the plot.
+        """
+        c,b,a = self.eigvals()
+
+        # Sizes and locations of circles
+        r1 = (c - b) / 2
+        r2 = (b - a) / 2
+        r3 = (c - a) / 2
+        center1 = ((b + c) /2, 0)
+        center2 = ((a + b) /2, 0)
+        center3 = ((a + c) /2, 0)
+
+        fig, ax = plt.subplots()
+        filldraw_circle(ax, center1, r1, 'skyblue')
+        filldraw_circle(ax, center2, r2, 'lightgreen')
+        filldraw_circle(ax, center3, r3, 'red')
+        filldraw_circle(ax, center3, r3, 'red', fill=True, alpha=0.2)
+        filldraw_circle(ax, center1, r1, 'white', fill=True)
+        filldraw_circle(ax, center2, r2, 'white', fill=True)
+        ax.set_aspect('equal')
+        ax.set_xlabel(f"Normal")
+        ax.set_ylabel(f"Shear")
+        ax.grid(True)
+        xticks = (a,b,c, center1[0], center2[0])
+        ax.set_xticks(np.unique(xticks))
+        yticks = (-r3, -r2, -r1, 0, r1, r2, r3)
+        ax.set_yticks(np.unique(yticks))
+
+        return fig, ax
+
 
 class SkewSymmetricSecondOrderTensor(SecondOrderTensor):
     name = 'Skew-symmetric second-order tensor'

Elasticipy/tensors/stress_strain.py

@@ -38,7 +38,7 @@ class StrainTensor(SymmetricSecondOrderTensor):
         """von Mises equivalent strain"""
         return np.sqrt(2/3 * self.ddot(self))
 
-    def elastic_energy(self, stress):
+    def elastic_energy(self, stress, mode='pair'):
         """
         Compute the elastic energy.
 
@@ -46,12 +46,22 @@ class StrainTensor(SymmetricSecondOrderTensor):
         ----------
         stress : StressTensor
             Corresponding stress tensor
+        mode : str, optional
+            If 'pair' (default), the elastic energies are computed element-wise. Broadcasting rule applies.
+            If 'cross', each cross-combination of stress and strain are considered.
 
         Returns
         -------
-        Volumetric elastic energy
+        float or numpy.ndarray
+            Volumetric elastic energy
         """
-        return 0.5 * self.ddot(stress)
+        return 0.5 * self.ddot(stress, mode=mode)
+
+    def draw_Mohr_circles(self):
+        fig, ax = super().draw_Mohr_circles()
+        ax.set_xlabel(ax.get_xlabel() + ' strain')
+        ax.set_ylabel(ax.get_ylabel() + ' strain')
+        return fig, ax
 
 
 class StressTensor(SymmetricSecondOrderTensor):
@@ -135,4 +145,10 @@ class StressTensor(SymmetricSecondOrderTensor):
         numpy.ndarray
             Volumetric elastic energy
         """
-        return 0.5 * self.ddot(strain, mode=mode)
+        return 0.5 * self.ddot(strain, mode=mode)
+
+    def draw_Mohr_circles(self):
+        fig, ax = super().draw_Mohr_circles()
+        ax.set_xlabel(ax.get_xlabel() + ' stress')
+        ax.set_ylabel(ax.get_ylabel() + ' stress')
+        return fig, ax

{elasticipy-4.0.0.dist-info → elasticipy-4.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elasticipy
-Version: 4.0.0
+Version: 4.1.0
 Summary: A Python library for elasticity tensor computations
 Author-email: Dorian Depriester <dorian.dep@gmail.com>
 License: MIT
@@ -15,18 +15,20 @@ Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: matplotlib
+Requires-Dist: qtpy
+Requires-Dist: pandas
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pymatgen; extra == "dev"
 Requires-Dist: orix; extra == "dev"
-Requires-Dist: mp_api; extra == "dev"
+Requires-Dist: mp_api==0.45.9; extra == "dev"
 Dynamic: license-file
 
 [![PyPI - Version](https://img.shields.io/pypi/v/Elasticipy?link=https%3A%2F%2Fpypi.org%2Fproject%2FElasticipy%2F)](https://pypi.org/project/elasticipy/)
@@ -48,7 +50,7 @@ Among other features, this package implements:
 
 - Computation of elasticity tensors,
 - Analysis of elastic anisotropy and wave propagation,
-- Working with multidimensional arrays of strain and stress tensors,
+- Working with multidimensional arrays of tensors,
 - Thermal expansion tensors,
 - Rotation of tensors,
 - Integration with crystal symmetry groups,
@@ -79,3 +81,19 @@ Certain parts of the code, particularly those related to graphical user interfac
 **excluded from code coverage analysis**. This includes the following file:
 
 - **`src/Elasticipy/gui.py`**
+
+## Cite this package
+If you use Elasticipy, please cite [![DOI](https://zenodo.org/badge/876162900.svg)](https://doi.org/10.5281/zenodo.14501849)
+
+You can use the following BibTeX entry:
+````bibtex
+@software{Elasticipy,
+author = {Depriester, Dorian},
+doi = {10.5281/zenodo.15188346},
+month = apr,
+title = {{Elasticipy}},
+url = {https://github.com/DorianDepriester/Elasticipy},
+version = {4.0.0},
+year = {2025}
+}
+````