elasticipy 4.1.1__py3-none-any.whl → 5.0.0__py3-none-any.whl

Elasticipy/tensors/elasticity.py

@@ -1,10 +1,25 @@
-from Elasticipy.tensors.fourth_order import SymmetricFourthOrderTensor
+from Elasticipy.tensors.fourth_order import SymmetricFourthOrderTensor, kelvin_mapping, _isotropic_matrix
 from Elasticipy.spherical_function import SphericalFunction, HyperSphericalFunction
 from Elasticipy.crystal_symmetries import SYMMETRIES
+from Elasticipy.tensors.second_order import SymmetricSecondOrderTensor
 from Elasticipy.tensors.stress_strain import StrainTensor, StressTensor
-from Elasticipy.tensors.mapping import VoigtMapping, KelvinMapping
+from Elasticipy.tensors.mapping import VoigtMapping
+from functools import wraps
 import numpy as np
 import re
+from warnings import warn
+
+def _elementwise_property(func):
+    @property
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        if getattr(self, "ndim", 0) != 0:
+            flat = self.flatten()
+            result = [getattr(e, func.__name__) for e in flat]
+            return np.array(result).reshape(self.shape)
+        return func(self, *args, **kwargs)
+    return wrapper
+
 
 def _parse_tensor_components(prefix, **kwargs):
     pattern = r'^{}(\d{{2}})$'.format(prefix)
@@ -18,15 +33,6 @@ def _parse_tensor_components(prefix, **kwargs):
 def _indices2str(ij):
     return f'{ij[0] + 1}{ij[1] + 1}'
 
-def _isotropic_matrix(C11, C12, C44):
-    return np.array([[C11, C12, C12, 0, 0, 0],
-                     [C12, C11, C12, 0, 0, 0],
-                     [C12, C12, C11, 0, 0, 0],
-                     [0, 0, 0, C44, 0, 0],
-                     [0, 0, 0, 0, C44, 0],
-                     [0, 0, 0, 0, 0, C44]])
-
-
 def _check_definite_positive(mat):
     try:
         np.linalg.cholesky(mat)
@@ -46,30 +52,33 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
     """
     Class for manipulating fourth-order stiffness tensors.
     """
-    tensor_name = 'Stiffness'
-    C11_C12_factor = 0.5
-    C46_C56_factor = 1.0
-    component_prefix = 'C'
+    _tensor_name = 'Stiffness'
+    _C11_C12_factor = 0.5
+    _C46_C56_factor = 1.0
+    _component_prefix = 'C'
 
-    def __init__(self, M, symmetry='Triclinic', check_positive_definite=True, phase_name= None, mapping=VoigtMapping(), **kwargs):
+    def __init__(self, M, check_positive_definite=True, phase_name= None, mapping=VoigtMapping(), **kwargs):
         """
-        Construct of stiffness tensor from a (6,6) matrix.
+        Construct a stiffness tensor or an array of stiffness tensors.
 
-        The input matrix must be symmetric, otherwise an error is thrown (except if check_symmetry==False, see below)
+        The stiffness tensor can be constructed from a (6,6) matrix or slices of (6,6) matrices. These matrices must be
+        symmetric. An error is thrown if this matrix in not definite positive (except if
+        ``check_positive_definite==False``, see below). The input argument can also be the full tensor (array of shape
+        (...,3,3,3,3)).
 
         Parameters
         ----------
-        M : np.ndarray
-            (6,6) matrix corresponding to the stiffness tensor, written using the Voigt notation, or array of shape
-            (3,3,3,3).
-        phase_name : str, default None
-            Name to display
-        symmetry : str, default Triclinic
-            Name of the crystal's symmetry
+        M : list or np.ndarray
+            (...,6,6) matrix corresponding to the stiffness tensor, written using the Voigt notation, or array of shape
+            (...,3,3,3,3).
+        phase_name : str, optional
+            Phase name to display
+        check_positive_definite : bool, optional
+            Whether to check if the input matrix is positive definite or not. True by default.
         check_symmetry : bool, optional
             Whether to check or not that the input matrix is symmetric.
         force_symmetry : bool, optional
-            If true, the major symmetry of the tensor is forces
+            If true, the major symmetry of the tensor is forced
         mapping : str or MappingConvention
             mapping convention to use. Default is VoigtMapping.
 
@@ -79,11 +88,94 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         results you will get when performing operations (Young's modulus, "product" with strain tensor etc.) will be
         consistent with these units. For instance, if the stiffness tensor is defined in GPa, the computed stress will
         be given in GPa as well.
+
+        Examples
+        --------
+        Create a stiffness tensor for cubic symmetry:
+
+        >>> matrix = [[200, 40,  40,  0,  0,  0 ],
+        ...           [40,  200, 40,  0,  0,  0 ],
+        ...           [40,  40,  200, 0,  0,  0 ],
+        ...           [0,   0,   0,   20, 0,  0 ],
+        ...           [0,   0,   0,   0,  20, 0 ],
+        ...           [0,   0,   0,   0,   0, 20]]
+        >>> from Elasticipy.tensors.elasticity import StiffnessTensor
+        >>> C = StiffnessTensor(matrix)
+        >>> print(C)
+        Stiffness tensor (in Voigt mapping):
+        [[200.  40.  40.   0.   0.   0.]
+         [ 40. 200.  40.   0.   0.   0.]
+         [ 40.  40. 200.   0.   0.   0.]
+         [  0.   0.   0.  20.   0.   0.]
+         [  0.   0.   0.   0.  20.   0.]
+         [  0.   0.   0.   0.   0.  20.]]
+
+        Create a stiffness tensor from full (3,3,3,3) array:
+
+        >>> C_full = C.full_tensor # (3,3,3,3) numpy array
+        >>> print((type(C_full), C_full.shape))
+        (<class 'numpy.ndarray'>, (3, 3, 3, 3))
+
+        >>> StiffnessTensor(C_full)
+        Stiffness tensor (in Voigt mapping):
+        [[200.  40.  40.   0.   0.   0.]
+         [ 40. 200.  40.   0.   0.   0.]
+         [ 40.  40. 200.   0.   0.   0.]
+         [  0.   0.   0.  20.   0.   0.]
+         [  0.   0.   0.   0.  20.   0.]
+         [  0.   0.   0.   0.   0.  20.]]
+
+        Create an array of stiffness tensors:
+
+        First, we create two slices of (6,6) matrices, corresponding to two stiffness values:
+
+        >>> slices = [[[200, 40,  40,  0,  0,  0 ],
+        ...            [40,  200, 40,  0,  0,  0 ],
+        ...            [40,  40,  200, 0,  0,  0 ],
+        ...            [0,   0,   0,   20, 0,  0 ],
+        ...            [0,   0,   0,   0,  20, 0 ],
+        ...            [0,   0,   0,   0,   0, 20]],
+        ...           [[250, 80,  80,  0,  0,  0 ],
+        ...            [80,  250, 80,  0,  0,  0 ],
+        ...            [80,  80,  250, 0,  0,  0 ],
+        ...            [0,   0,   0,   40, 0,  0 ],
+        ...            [0,   0,   0,   0,  40, 0 ],
+        ...            [0,   0,   0,   0,   0, 40]]]
+
+        Then, one can create an array of stiffness tensors:
+
+        >>> C_array=StiffnessTensor(slices)
+        >>> print(C_array)
+        Stiffness tensor (in Voigt mapping):
+        [[[200.  40.  40.   0.   0.   0.]
+          [ 40. 200.  40.   0.   0.   0.]
+          [ 40.  40. 200.   0.   0.   0.]
+          [  0.   0.   0.  20.   0.   0.]
+          [  0.   0.   0.   0.  20.   0.]
+          [  0.   0.   0.   0.   0.  20.]]
+        <BLANKLINE>
+         [[250.  80.  80.   0.   0.   0.]
+          [ 80. 250.  80.   0.   0.   0.]
+          [ 80.  80. 250.   0.   0.   0.]
+          [  0.   0.   0.  40.   0.   0.]
+          [  0.   0.   0.   0.  40.   0.]
+          [  0.   0.   0.   0.   0.  40.]]]
+
+
+        This array can be subindexed. E.g.:
+
+        >>> C_array[0]
+        Stiffness tensor (in Voigt mapping):
+        [[200.  40.  40.   0.   0.   0.]
+         [ 40. 200.  40.   0.   0.   0.]
+         [ 40.  40. 200.   0.   0.   0.]
+         [  0.   0.   0.  20.   0.   0.]
+         [  0.   0.   0.   0.  20.   0.]
+         [  0.   0.   0.   0.   0.  20.]]
         """
         super().__init__(M, mapping=mapping, **kwargs)
         if check_positive_definite:
             _check_definite_positive(self._matrix)
-        self.symmetry = symmetry
         self.phase_name = phase_name
 
     def __mul__(self, other):
@@ -99,7 +191,6 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         string = super().__repr__()
         if self.phase_name is not None:
             string += '\nPhase: {}'.format(self.phase_name)
-        string += '\nSymmetry: {}'.format(self.symmetry)
         return string
 
     def inv(self):
@@ -110,9 +201,82 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         -------
         ComplianceTensor
             Reciprocal tensor
+
+        Examples
+        --------
+        Create a stiffness tensor for cubic symmetry:
+
+        >>> C = StiffnessTensor.cubic(C11=186, C12=134, C44=77)
+        >>> print(C)
+        Stiffness tensor (in Voigt mapping):
+        [[186. 134. 134.   0.   0.   0.]
+         [134. 186. 134.   0.   0.   0.]
+         [134. 134. 186.   0.   0.   0.]
+         [  0.   0.   0.  77.   0.   0.]
+         [  0.   0.   0.   0.  77.   0.]
+         [  0.   0.   0.   0.   0.  77.]]
+
+        The reciprocal (compliance) tensor is given by:
+
+        >>> S = C.inv()
+        >>> print(S)
+        Compliance tensor (in Voigt mapping):
+        [[ 0.01355473 -0.00567604 -0.00567604  0.          0.          0.        ]
+         [-0.00567604  0.01355473 -0.00567604  0.          0.          0.        ]
+         [-0.00567604 -0.00567604  0.01355473  0.          0.          0.        ]
+         [ 0.          0.          0.          0.01298701  0.          0.        ]
+         [ 0.          0.          0.          0.          0.01298701  0.        ]
+         [ 0.          0.          0.          0.          0.          0.01298701]]
+
+        This also works for tensor arrays. In this case, the returned value will be a compliance tensor array of the
+        same shape as the tensor array. For instance:
+
+        >>> slices = [[[200, 40,  40,  0,  0,  0 ],
+        ...            [40,  200, 40,  0,  0,  0 ],
+        ...            [40,  40,  200, 0,  0,  0 ],
+        ...            [0,   0,   0,   20, 0,  0 ],
+        ...            [0,   0,   0,   0,  20, 0 ],
+        ...            [0,   0,   0,   0,   0, 20]],
+        ...           [[250, 80,  80,  0,  0,  0 ],
+        ...            [80,  250, 80,  0,  0,  0 ],
+        ...            [80,  80,  250, 0,  0,  0 ],
+        ...            [0,   0,   0,   40, 0,  0 ],
+        ...            [0,   0,   0,   0,  40, 0 ],
+        ...            [0,   0,   0,   0,   0, 40]]]
+        >>> C = StiffnessTensor(slices)
+        >>> S = C.inv()
+        >>> print(S)
+        Compliance tensor (in Voigt mapping):
+        [[[ 0.00535714 -0.00089286 -0.00089286  0.          0.
+            0.        ]
+          [-0.00089286  0.00535714 -0.00089286  0.          0.
+            0.        ]
+          [-0.00089286 -0.00089286  0.00535714  0.          0.
+            0.        ]
+          [ 0.          0.          0.          0.05        0.
+            0.        ]
+          [ 0.          0.          0.          0.          0.05
+            0.        ]
+          [ 0.          0.          0.          0.          0.
+            0.05      ]]
+        <BLANKLINE>
+         [[ 0.00473458 -0.00114778 -0.00114778  0.          0.
+            0.        ]
+          [-0.00114778  0.00473458 -0.00114778  0.          0.
+            0.        ]
+          [-0.00114778 -0.00114778  0.00473458  0.          0.
+            0.        ]
+          [ 0.          0.          0.          0.025       0.
+            0.        ]
+          [ 0.          0.          0.          0.          0.025
+            0.        ]
+          [ 0.          0.          0.          0.          0.
+            0.025     ]]]
         """
         C = np.linalg.inv(self._matrix)
-        return ComplianceTensor(C, symmetry=self.symmetry, phase_name=self.phase_name)
+        t2 = ComplianceTensor(C, mapping=kelvin_mapping, phase_name=self.phase_name)
+        t2.mapping = self.mapping.mapping_inverse
+        return t2
 
     @classmethod
     def from_txt_file(cls, filename):
@@ -149,16 +313,11 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
             phase_name = lines[0].split(": ", 1)[1].strip()
             matrix_start_index += 1
 
-        # Parse symmetry if available
-        if len(lines) > matrix_start_index and lines[matrix_start_index].startswith("Symmetry:"):
-            symmetry = lines[matrix_start_index].split(": ", 1)[1].strip()
-            matrix_start_index += 1
-
         # Parse matrix
         matrix = np.loadtxt(lines[matrix_start_index:])
 
         # Return the reconstructed object
-        return cls(matrix, phase_name=phase_name, symmetry=symmetry)
+        return cls(matrix, phase_name=phase_name)
 
     def save_to_txt(self, filename, matrix_only=False):
         """
@@ -169,7 +328,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         filename : str
             Filename to save the tensor to.
         matrix_only : bool, False
-            If true, only the components of tje stiffness tensor is saved (no data about phase nor symmetry)
+            If true, only the components of the stiffness tensor is saved (no data about phase nor symmetry)
 
         See Also
         --------
@@ -180,14 +339,13 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
             if not matrix_only:
                 if self.phase_name is not None:
                     f.write(f"Phase Name: {self.phase_name}\n")
-                f.write(f"Symmetry: {self.symmetry}\n")
-            for row in self._matrix:
+            for row in self.matrix():
                 f.write("  " + "  ".join(f"{value:8.2f}" for value in row) + "\n")
 
     @classmethod
     def _matrixFromCrystalSymmetry(cls, symmetry='Triclinic', point_group=None, diad='y', prefix=None, **kwargs):
         if prefix is None:
-            prefix = cls.component_prefix
+            prefix = cls._component_prefix
         values = _parse_tensor_components(prefix, **kwargs)
         C = np.zeros((6, 6))
         symmetry = symmetry.capitalize()
@@ -228,17 +386,17 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         C11_C12 = symmetry_description.C11_C12
         if C11_C12:
             for index in C11_C12:
-                C[index] = (C[0, 0] - C[0, 1]) * cls.C11_C12_factor
+                C[index] = (C[0, 0] - C[0, 1]) * cls._C11_C12_factor
 
         if symmetry == 'Trigonal':
-            C[3, 5] = cls.C46_C56_factor * C[3, 5]
-            C[4, 5] = cls.C46_C56_factor * C[4, 5]
+            C[3, 5] = cls._C46_C56_factor * C[3, 5]
+            C[4, 5] = cls._C46_C56_factor * C[4, 5]
 
         return C + np.tril(C.T, -1)
 
     @classmethod
     def fromCrystalSymmetry(cls, symmetry='Triclinic', point_group=None, diad='y', phase_name=None, prefix=None,
-                            **kwargs):
+                             **kwargs):
         """
         Create a fourth-order tensor from limited number of components, taking advantage of crystallographic symmetries
 
@@ -271,11 +429,11 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
 
         Notes
         -----
-        The relationships between the tensor's components depend on the crystallogrpahic symmetry [1]_.
+        The relationships between the tensor's components depend on the crystallogrpahic symmetry [Nye]_.
 
         References
         ----------
-        .. [1] Nye, J. F. Physical Properties of Crystals. London: Oxford University Press, 1959.
+        .. [Nye] Nye, J. F. Physical Properties of Crystals. London: Oxford University Press, 1959.
 
         Examples
         --------
@@ -293,7 +451,6 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
          [-18.   1.  -3.   0.  11.   0.]
          [  0.   0.   0.   3.   0.  85.]]
         Phase: TiNi
-        Symmetry: monoclinic
 
         >>> from Elasticipy.tensors.elasticity import ComplianceTensor\n
         >>> ComplianceTensor.fromCrystalSymmetry(symmetry='monoclinic', diad='y', phase_name='TiNi',
@@ -309,11 +466,15 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
          [ 14.  -8.   0.   0. 116.   0.]
          [  0.   0.   0.   0.   0.  12.]]
         Phase: TiNi
-        Symmetry: monoclinic
         """
-        matrix = cls._matrixFromCrystalSymmetry(point_group=point_group, diad=diad, symmetry=symmetry, prefix=prefix,
-                                                **kwargs)
-        return cls(matrix, phase_name=phase_name, symmetry=symmetry)
+        warn('This function will be removed in a future release. Use {}.{}() instead'.format(cls.__name__,symmetry), DeprecationWarning, stacklevel=2)
+        return cls._fromCrystalSymmetry(symmetry=symmetry, point_group=point_group, diad=diad, phase_name=phase_name,
+                                       prefix=prefix, **kwargs)
+
+    @classmethod
+    def _fromCrystalSymmetry(cls, symmetry, phase_name, **kwargs):
+        matrix = cls._matrixFromCrystalSymmetry(symmetry=symmetry, **kwargs)
+        return cls(matrix, phase_name=phase_name)
 
 
     @classmethod
@@ -337,7 +498,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         cubic : create a tensor from cubic symmetry
         tetragonal : create a tensor from tetragonal symmetry
         """
-        return cls.fromCrystalSymmetry(symmetry='hexagonal', C11=C11, C12=C12, C13=C13, C33=C33, C44=C44,
+        return cls._fromCrystalSymmetry(symmetry='hexagonal', C11=C11, C12=C12, C13=C13, C33=C33, C44=C44,
                                        phase_name=phase_name, prefix='C')
 
     @classmethod
@@ -362,8 +523,9 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         tetragonal : create a tensor from tetragonal symmetry
         orthorhombic : create a tensor from orthorhombic symmetry
         """
-        return cls.fromCrystalSymmetry(point_group='3', C11=C11, C12=C12, C13=C13, C14=C14, C15=C15,
-                                       C33=C33, C44=C44, phase_name=phase_name, prefix='C')
+        return cls._fromCrystalSymmetry(symmetry='trigonal', point_group='3',
+                                        C11=C11, C12=C12, C13=C13, C14=C14, C15=C15,
+                                        C33=C33, C44=C44, phase_name=phase_name, prefix='C')
 
     @classmethod
     def tetragonal(cls, *, C11=0., C12=0., C13=0., C33=0., C44=0., C16=0., C66=0., phase_name=None):
@@ -388,8 +550,9 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         trigonal : create a tensor from trigonal symmetry
         orthorhombic : create a tensor from orthorhombic symmetry
         """
-        return cls.fromCrystalSymmetry(point_group='4', C11=C11, C12=C12, C13=C13, C16=C16,
-                                       C33=C33, C44=C44, C66=C66, phase_name=phase_name, prefix='C')
+        return cls._fromCrystalSymmetry(symmetry='tetragonal', point_group='4',
+                                        C11=C11, C12=C12, C13=C13, C16=C16,
+                                        C33=C33, C44=C44, C66=C66, phase_name=phase_name, prefix='C')
 
     @classmethod
     def cubic(cls, *, C11=0., C12=0., C44=0., phase_name=None):
@@ -411,7 +574,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         hexagonal : create a tensor from hexagonal symmetry
         orthorhombic : create a tensor from orthorhombic symmetry
         """
-        return cls.fromCrystalSymmetry(symmetry='cubic', C11=C11, C12=C12, C44=C44, phase_name=phase_name, prefix='C')
+        return cls._fromCrystalSymmetry(symmetry='cubic', C11=C11, C12=C12, C44=C44, phase_name=phase_name, prefix='C')
 
     @classmethod
     def orthorhombic(cls, *, C11=0., C12=0., C13=0., C22=0., C23=0., C33=0., C44=0., C55=0., C66=0., phase_name=None):
@@ -434,7 +597,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         monoclinic : create a tensor from monoclinic symmetry
         orthorhombic : create a tensor from orthorhombic symmetry
         """
-        return cls.fromCrystalSymmetry(symmetry='orthorhombic',
+        return cls._fromCrystalSymmetry(symmetry='orthorhombic',
                                        C11=C11, C12=C12, C13=C13, C22=C22, C23=C23, C33=C33, C44=C44, C55=C55, C66=C66,
                                        phase_name=phase_name, prefix='C')
 
@@ -487,12 +650,12 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         if diad_y and diad_z:
             raise KeyError('Ambiguous diad. Provide either C15, C25, C35 and C46; or C16, C26, C36 and C45')
         elif diad_y:
-            return cls.fromCrystalSymmetry(symmetry='monoclinic', diad='y',
+            return cls._fromCrystalSymmetry(symmetry='monoclinic', diad='y',
                                            C11=C11, C12=C12, C13=C13, C22=C22, C23=C23, C33=C33, C44=C44, C55=C55,
                                            C66=C66,
                                            C15=C15, C25=C25, C35=C35, C46=C46, phase_name=phase_name, prefix='C')
         elif diad_z:
-            return cls.fromCrystalSymmetry(symmetry='monoclinic', diad='z',
+            return cls._fromCrystalSymmetry(symmetry='monoclinic', diad='z',
                                            C11=C11, C12=C12, C13=C13, C22=C22, C23=C23, C33=C33, C44=C44, C55=C55,
                                            C66=C66,
                                            C16=C16, C26=C26, C36=C36, C45=C45, phase_name=phase_name, prefix='C')
@@ -533,12 +696,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
                            [C16, C26, C36, C46, C56, C66]])
         return cls(matrix, phase_name=phase_name)
 
-    def _single_tensor_only(self, fun_name=''):
-        if self.ndim:
-            err_msg = fun_name + ' is not suitable for tensor array. Consider subscripting (e.g. C[0].{}).'.format(fun_name)
-            raise ValueError(err_msg)
-
-    @property
+    @_elementwise_property
     def Young_modulus(self):
         """
         Directional Young's modulus
@@ -548,18 +706,17 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         SphericalFunction
             Young's modulus
         """
-        self._single_tensor_only('Young_modulus')
         if isinstance(self, ComplianceTensor):
             S = self
         else:
             S = self.inv()
         def compute_young_modulus(u):
-            a = np.einsum('ijkl,...i,...j,...k,...l->...', S.full_tensor(), u, u, u, u)
+            a = np.einsum('ijkl,...i,...j,...k,...l->...', S.full_tensor, u, u, u, u)
             return 1 / a
 
         return SphericalFunction(compute_young_modulus)
 
-    @property
+    @_elementwise_property
     def shear_modulus(self):
         """
         Directional shear modulus
@@ -569,18 +726,17 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         HyperSphericalFunction
             Shear modulus
         """
-        self._single_tensor_only('shear_modulus')
         if isinstance(self, ComplianceTensor):
             S = self
         else:
             S = self.inv()
         def compute_shear_modulus(u, v):
-            G =  0.25/np.einsum('ijkl,...i,...j,...k,...l->...',S.full_tensor(),u,v,u,v)
+            G =  0.25/np.einsum('ijkl,...i,...j,...k,...l->...',S.full_tensor,u,v,u,v)
             return G
 
         return HyperSphericalFunction(compute_shear_modulus)
 
-    @property
+    @_elementwise_property
     def Poisson_ratio(self):
         """
         Directional Poisson's ratio
@@ -601,11 +757,10 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
 
         where :math:`\\varepsilon_{jj}` denotes the (compressive) longitudinal strain along the j-th direction.
         """
-        self._single_tensor_only('Poisson_ratio')
         if isinstance(self, ComplianceTensor):
-            Sfull = self.full_tensor()
+            Sfull = self.full_tensor
         else:
-            Sfull = self.inv().full_tensor()
+            Sfull = self.inv().full_tensor
         def compute_PoissonRatio(u, v):
             numer = np.einsum('ijkl,...i,...j,...k,...l->...',Sfull,v,v,u,u)
             denom = np.einsum('ijkl,...i,...j,...k,...l->...',Sfull,u,u,u,u)
@@ -613,7 +768,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
 
         return HyperSphericalFunction(compute_PoissonRatio)
 
-    @property
+    @_elementwise_property
     def linear_compressibility(self):
         """
         Compute the directional linear compressibility.
@@ -627,13 +782,12 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         --------
         bulk_modulus : bulk modulus of the material
         """
-        self._single_tensor_only('linear_compressibility')
         if isinstance(self, ComplianceTensor):
             S = self
         else:
             S = self.inv()
         def compute_linear_compressibility(u):
-            return np.einsum('ijkk,...i,...j->...',S.full_tensor(),u,u)
+            return np.einsum('ijkk,...i,...j->...',S.full_tensor,u,u)
 
         return SphericalFunction(compute_linear_compressibility)
 
@@ -653,12 +807,55 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         """
         return self.inv().bulk_modulus
 
+    @_elementwise_property
+    def lame1(self):
+        """
+        Compute the first Lamé's parameter (only for isotropic materials).
+
+        If the stiffness/compliance tensor is not isotropic, NaN is returned.
+
+        Returns
+        -------
+        float
+            First Lamé's parameter
+
+        See Also
+        --------
+        lame2 : second Lamé's parameter
+        """
+        if self.is_isotropic():
+            C11 = (self.C11 + self.C22 + self.C33) / 3
+            return C11 - 2 * self.lame2
+        else:
+            return np.nan
+
+    @_elementwise_property
+    def lame2(self):
+        """
+        Compute the second Lamé's parameter (only for isotropic materials).
+
+        If the stiffness/compliance tensor is not isotropic, NaN is returned.
+
+        Returns
+        -------
+        float
+            Second Lamé's parameter
+
+        See Also
+        --------
+        lame1 : first Lamé's parameter
+        """
+        if self.is_isotropic():
+            return (self.C44 + self.C55 + self.C66) / 3
+        else:
+            return np.nan
+
     def Voigt_average(self, axis=None):
         """
-        Compute the Voigt average of the stiffness tensor.
+        Compute the Voigt average (from the mean of stiffness tensors).
 
-        If the tensor is a tensor array, all its values are considered. Otherwise (i.e. if single), the corresponding
-        isotropic tensor is returned.
+        If the object is a single tensor, the returned tensor corresponds to the average over an infinite set of random
+        rotations, resulting in an isotropic behavior. Otherwise, the mean is computed over the given axis.
 
         Parameters
         ----------
@@ -675,24 +872,67 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         Reuss_average : compute the Reuss average
         Hill_average : compute the Voigt-Reuss-Hill average
         average : generic function for calling either the Voigt, Reuss or Hill average
+
+        Examples
+        --------
+        Let us consider the stiffness of pure copper:
+
+        >>> from Elasticipy.tensors.elasticity import StiffnessTensor
+        >>> C = StiffnessTensor.cubic(C11=186, C12=134, C44=77)
+
+        If we assume that an aggregate is composed of an infinite set grains whose orientations are uniformly
+        distributed, the Voigt average is:
+
+        >>> C.Voigt_average()
+        Stiffness tensor (in Voigt mapping):
+        [[226.8 113.6 113.6   0.    0.    0. ]
+         [113.6 226.8 113.6   0.    0.    0. ]
+         [113.6 113.6 226.8   0.    0.    0. ]
+         [  0.    0.    0.   56.6   0.    0. ]
+         [  0.    0.    0.    0.   56.6   0. ]
+         [  0.    0.    0.    0.    0.   56.6]]
+
+        Now, we consider an aggregate of grains whose orientations follow a pure fibre texture along the X axis. First,
+        generate a (large) random set of rotation corresponding to this texture:
+
+        >>> from scipy.spatial.transform import Rotation
+        >>> import numpy as np
+        >>> g = Rotation.from_euler('X', np.linspace(0, 90, 1000), degrees=True)    # 1000 rotations around X
+
+        Now apply rotations to compute the array of stiffness tensors:
+
+        >>> C_rotated = C * g
+        >>> C_rotated
+        Stiffness tensor array of shape (1000,)
+
+        Finally, one can check that the Voigt average, computed from the rotated stiffness tensors is:
+
+        >>> C_rotated.Voigt_average()
+        Stiffness tensor (in Voigt mapping):
+        [[ 1.86000000e+02  1.34000000e+02  1.34000000e+02 -4.39648318e-17
+           0.00000000e+00  0.00000000e+00]
+         [ 1.34000000e+02  2.11474500e+02  1.08525500e+02  0.00000000e+00
+           0.00000000e+00  0.00000000e+00]
+         [ 1.34000000e+02  1.08525500e+02  2.11474500e+02  0.00000000e+00
+           0.00000000e+00  0.00000000e+00]
+         [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  5.15255000e+01
+           0.00000000e+00  0.00000000e+00]
+         [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
+           7.70000000e+01 -7.54674101e-17]
+         [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
+           7.54674101e-17  7.70000000e+01]]
         """
         if self.ndim:
             return self.mean(axis=axis)
         else:
-            c = self._matrix
-            A = c[0, 0] + c[1, 1] + c[2, 2]
-            B = c[0, 1] + c[0, 2] + c[1, 2]
-            C = c[3, 3] + c[4, 4] + c[5, 5]
-            C11 = 1 / 5 *  A  + 2 / 15 * B + 4 / 15 * C
-            C12 = 1 / 15 * A  + 4 / 15 * B - 2 / 15 * C
-            C44 = (A - B) / 15 + C / 5
-            mat = _isotropic_matrix(C11, C12, C44)
-            return StiffnessTensor(mat, symmetry='isotropic', phase_name=self.phase_name)
+            return self.infinite_random_average()
 
     def Reuss_average(self, axis=None):
         """
-        Compute the Reuss average of the stiffness tensor. If the tensor contains no orientation, we assume isotropic
-        behaviour. Otherwise, the mean is computed over all orientations.
+        Compute the Reuss average (from the mean of compliance tensors).
+
+        If the object is a single tensor, the returned tensor corresponds to the average over an infinite set of random
+        rotations, resulting in an isotropic behavior. Otherwise, the mean is computed over the given axis.
 
         Parameters
         ----------
@@ -709,13 +949,70 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         Voigt_average : compute the Voigt average
         Hill_average : compute the Voigt-Reuss-Hill average
         average : generic function for calling either the Voigt, Reuss or Hill average
+
+        Examples
+        --------
+        Let us consider the stiffness of pure copper:
+
+        >>> from Elasticipy.tensors.elasticity import StiffnessTensor
+        >>> C = StiffnessTensor.cubic(C11=186, C12=134, C44=77)
+
+        If we assume that an aggregate is composed of an infinite set grains whose orientations are uniformly
+        distributed, the Voigt average is:
+
+        >>> C.Reuss_average()
+        Stiffness tensor (in Voigt mapping):
+        [[208.86206897 122.56896552 122.56896552   0.           0.
+            0.        ]
+         [122.56896552 208.86206897 122.56896552   0.           0.
+            0.        ]
+         [122.56896552 122.56896552 208.86206897   0.           0.
+            0.        ]
+         [  0.           0.           0.          43.14655172   0.
+            0.        ]
+         [  0.           0.           0.           0.          43.14655172
+            0.        ]
+         [  0.           0.           0.           0.           0.
+           43.14655172]]
+
+        Now, we consider an aggregate of grains whose orientations follow a pure fibre texture along the X axis. First,
+        generate a (large) random set of rotation corresponding to this texture:
+
+        >>> from scipy.spatial.transform import Rotation
+        >>> import numpy as np
+        >>> g = Rotation.from_euler('X', np.linspace(0, 90, 1000), degrees=True)    # 1000 rotations around X
+
+        Now apply rotations to compute the array of stiffness tensors:
+
+        >>> C_rotated = C * g
+        >>> C_rotated
+        Stiffness tensor array of shape (1000,)
+
+        Finally, one can check that the Voigt average, computed from the rotated stiffness tensors is:
+
+        >>> C_rotated.Reuss_average()
+        Stiffness tensor (in Voigt mapping):
+        [[ 1.86000000e+02  1.34000000e+02  1.34000000e+02 -1.68008952e-15
+           0.00000000e+00  0.00000000e+00]
+         [ 1.34000000e+02  1.98854548e+02  1.21145452e+02 -1.09777845e-15
+           0.00000000e+00  0.00000000e+00]
+         [ 1.34000000e+02  1.21145452e+02  1.98854548e+02 -2.89552069e-15
+           0.00000000e+00  0.00000000e+00]
+         [-1.61936693e-16  1.69241946e-16 -7.96730255e-16  3.88930441e+01
+           0.00000000e+00  0.00000000e+00]
+         [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
+           7.70000000e+01 -7.54674101e-17]
+         [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
+           7.54674101e-17  7.70000000e+01]]
         """
         return self.inv().Reuss_average(axis=axis).inv()
 
     def Hill_average(self, axis=None):
         """
-        Compute the (Voigt-Reuss-)Hill average of the stiffness tensor. If the tensor contains no orientation, we assume
-        isotropic behaviour. Otherwise, the mean is computed over all orientations.
+        Compute the Voigt-Reuss-Hill average (mean of Voigt and Reuss averages for stiffness tensors).
+
+        If the object is a single tensor, the returned tensor corresponds to the average over an infinite set of random
+        rotations, resulting in an isotropic behavior. Otherwise, the mean is computed over the given axis.
 
         Parameters
         ----------
@@ -732,6 +1029,61 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         Voigt_average : compute the Voigt average
         Reuss_average : compute the Reuss average
         average : generic function for calling either the Voigt, Reuss or Hill average
+
+        Examples
+        --------
+        Let us consider the stiffness of pure copper:
+
+        >>> from Elasticipy.tensors.elasticity import StiffnessTensor
+        >>> C = StiffnessTensor.cubic(C11=186, C12=134, C44=77)
+
+        If we assume that an aggregate is composed of an infinite set grains whose orientations are uniformly
+        distributed, the Voigt average is:
+
+        >>> C.Hill_average()
+        Stiffness tensor (in Voigt mapping):
+        [[217.83103448 118.08448276 118.08448276   0.           0.
+            0.        ]
+         [118.08448276 217.83103448 118.08448276   0.           0.
+            0.        ]
+         [118.08448276 118.08448276 217.83103448   0.           0.
+            0.        ]
+         [  0.           0.           0.          49.87327586   0.
+            0.        ]
+         [  0.           0.           0.           0.          49.87327586
+            0.        ]
+         [  0.           0.           0.           0.           0.
+           49.87327586]]
+
+        Now, we consider an aggregate of grains whose orientations follow a pure fibre texture along the X axis. First,
+        generate a (large) random set of rotation corresponding to this texture:
+
+        >>> from scipy.spatial.transform import Rotation
+        >>> import numpy as np
+        >>> g = Rotation.from_euler('X', np.linspace(0, 90, 1000), degrees=True)    # 1000 rotations around X
+
+        Now apply rotations to compute the array of stiffness tensors:
+
+        >>> C_rotated = C * g
+        >>> C_rotated
+        Stiffness tensor array of shape (1000,)
+
+        Finally, one can check that the Voigt average, computed from the rotated stiffness tensors is:
+
+        >>> C_rotated.Hill_average()
+        Stiffness tensor (in Voigt mapping):
+        [[ 1.86000000e+02  1.34000000e+02  1.34000000e+02 -8.62027175e-16
+           0.00000000e+00  0.00000000e+00]
+         [ 1.34000000e+02  2.05164524e+02  1.14835476e+02 -5.48889226e-16
+           0.00000000e+00  0.00000000e+00]
+         [ 1.34000000e+02  1.14835476e+02  2.05164524e+02 -1.44776034e-15
+           0.00000000e+00  0.00000000e+00]
+         [-8.09683464e-17  8.46209730e-17 -3.98365128e-16  4.52092721e+01
+           0.00000000e+00  0.00000000e+00]
+         [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
+           7.70000000e+01 -7.54674101e-17]
+         [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
+           7.54674101e-17  7.70000000e+01]]
         """
         Reuss = self.Reuss_average(axis=axis)
         Voigt = self.Voigt_average(axis=axis)
@@ -768,21 +1120,28 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
             raise NotImplementedError('Only Voigt, Reus, and Hill are implemented.')
 
     @classmethod
-    def isotropic(cls, E=None, nu=None, lame1=None, lame2=None, phase_name=None):
+    def isotropic(cls, E=None, nu=None, G=None, lame1=None, lame2=None, K=None, phase_name=None):
         """
-        Create an isotropic stiffness tensor from two elasticity coefficients, namely: E, nu, lame1, or lame2. Exactly
-        two of these coefficients must be provided.
+        Create an isotropic stiffness tensor.
+
+        The stiffness tensor must be constructed from exactly two elasticity coefficients, namely: E, nu, G, lame1, or
+        lame2. Note that lame2 is just an alias for G. Each of these coefficient can be a list; in this case, the
+        returned object is a tensor array (see examples).
 
         Parameters
         ----------
-        E : float, None
+        E : float or list, None
             Young modulus
-        nu : float, None
+        nu : float or list, None
             Poisson ratio
-        lame1 : float, None
+        G : float or list, None
+            Shear modulus
+        lame1 : float or list, None
             First Lamé coefficient
-        lame2 : float, None
-            Second Lamé coefficient
+        lame2 : float or list, None
+            Second Lamé coefficient (alias for G)
+        K : float or list, None
+            Bulk modulus
         phase_name : str, None
             Name to print
 
@@ -808,34 +1167,33 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         >>> C=StiffnessTensor.isotropic(E=210e3, nu=0.28)
         >>> C.shear_modulus
         Hyperspherical function
-        Min=82031.24999999997, Max=82031.25000000006
-        """
-        argument_vector = np.array([E, nu, lame1, lame2])
-        if np.count_nonzero(argument_vector) != 2:
-            raise ValueError("Exactly two values are required among E, nu, lame1 and lame2.")
-        if E is not None:
-            if nu is not None:
-                lame1 = E * nu / ((1 + nu) * (1 - 2 * nu))
-                lame2 = E / (1 + nu) / 2
-            elif lame1 is not None:
-                R = np.sqrt(E ** 2 + 9 * lame1 ** 2 + 2 * E * lame1)
-                lame2 = (E - 3 * lame1 + R) / 4
-            elif lame2 is not None:
-                lame1 = lame2 * (E - 2 * lame2) / (3 * lame2 - E)
-            else:
-                raise ValueError('Either nu, lame1 or lame2 must be provided.')
-        elif nu is not None:
-            if lame1 is not None:
-                lame2 = lame1 * (1 - 2 * nu) / (2 * nu)
-            elif lame2 is not None:
-                lame1 = 2 * lame2 * nu / (1 - 2 * nu)
-            else:
-                raise ValueError('Either lame1 or lame2 must be provided.')
-        C11 = lame1 + 2 * lame2
-        C12 = lame1
-        C44 = lame2
-        matrix = _isotropic_matrix(C11, C12, C44)
-        return StiffnessTensor(np.array(matrix), symmetry='isotropic', phase_name=phase_name)
+        Min=82031.24999999991, Max=82031.25000000006
+
+        Similarly, the same tensor can be defined from another pair of parameters, e.g. Young and shear moduli:
+
+        >>> C=StiffnessTensor.isotropic(E=210e3, G=82031)
+        >>> C.Young_modulus
+        Spherical function
+        Min=210000.0000000001, Max=210000.00000000032
+
+        One can build a tensor array by providing a list of values for the input arguments, instead of floats. For
+        instance:
+
+        >>> C = StiffnessTensor.isotropic(E=(210, 70), nu=(0.28, 0.35)) # Elastic moduli for steel and aluminium
+        >>> C.shape
+        (2,)
+
+        We can easily check that the shear moduli for steel and aluminium are:
+
+        >>> C[0].shear_modulus
+        Hyperspherical function
+        Min=82.0312499999999, Max=82.03125000000006
+
+        >>> C[1].shear_modulus
+        Hyperspherical function
+        Min=25.925925925925895, Max=25.925925925925952
+        """
+        return ComplianceTensor.isotropic(E=E, nu=nu, G=G, lame1=lame1, lame2=lame2, K=K, phase_name=phase_name).inv()
 
     @classmethod
     def orthotropic(cls, *, Ex, Ey, Ez, Gxy, Gxz, Gyz,
@@ -894,17 +1252,9 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
             \\frac{\\nu_{xy}}{E_x} = \\frac{\\nu_{yx}}{E_y}
 
         """
-        nu_yx = _switch_poisson_ratios(nu_xy, nu_yx, Ex, Ey,'xy')
-        nu_zx = _switch_poisson_ratios(nu_xz, nu_zx, Ex, Ez,'xz')
-        nu_zy = _switch_poisson_ratios(nu_yz, nu_zy, Ey, Ez,'yz')
-        tri_sup = np.array([[1 / Ex, -nu_yx / Ey, -nu_zx / Ez, 0, 0, 0],
-                            [0, 1 / Ey, -nu_zy / Ez, 0, 0, 0],
-                            [0, 0, 1 / Ez, 0, 0, 0],
-                            [0, 0, 0, 1 / Gyz, 0, 0],
-                            [0, 0, 0, 0, 1 / Gxz, 0],
-                            [0, 0, 0, 0, 0, 1 / Gxy]])
-        S = tri_sup + np.tril(tri_sup.T, -1)
-        return StiffnessTensor(np.linalg.inv(S), symmetry='orthotropic', **kwargs)
+        return ComplianceTensor.orthotropic(Ex=Ex, Ey=Ey, Ez=Ez, Gxy=Gxy, Gxz=Gxz, Gyz=Gyz,
+                                            nu_yx=nu_yx, nu_zx=nu_zx, nu_zy=nu_zy,
+                                            nu_xy=nu_xy, nu_xz=nu_xz, nu_yz=nu_yz).inv()
 
     @classmethod
     def transverse_isotropic(cls, *, Ex, Ez, Gxz, nu_yx=None, nu_xy=None, nu_zx=None, nu_xz=None, **kwargs):
@@ -973,8 +1323,8 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
 
         Returns
         -------
-        Gamma : np.ndarray
-            Array of Christoffel tensor(s). if u is a list of directions, Gamma[i] is the Christoffel tensor for
+        SymmetricSecondOrderTensor
+            Christoffel tensor(s). if u is a list of directions, Gamma[i] is the Christoffel tensor for
             direction  u[i].
 
         See Also
@@ -983,14 +1333,24 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
 
         Notes
         -----
-        For a given stiffness tensor **C** and a given unit vector **u**, the Christoffel tensor is defined as [2]_ :
+        For a given stiffness tensor **C** and a given unit vector **u**, the Christoffel tensor is defined as [Jaeken]_ :
 
             .. math:: M_{ij} = C_{iklj}.u_k.u_l
 
+        Examples
+        --------
+        >>> from Elasticipy.tensors.elasticity import StiffnessTensor
+        >>> C = StiffnessTensor.cubic(C11=186, C12=134, C44=77) # Cubic Cu
+        >>> C.Christoffel_tensor([0, 0, 1])
+        Symmetric second-order tensor
+        [[ 77.   0.   0.]
+         [  0.  77.   0.]
+         [  0.   0. 186.]]
         """
         u_vec = np.atleast_2d(u)
         u_vec = (u_vec.T / np.linalg.norm(u_vec, axis=1)).T
-        return np.einsum('inmj,pn,pm->pij', self.full_tensor(), u_vec, u_vec)
+        G = np.einsum('inmj,pn,pm->pij', self.full_tensor, u_vec, u_vec)
+        return SymmetricSecondOrderTensor(np.squeeze(G))
 
     def wave_velocity(self, rho):
         """
@@ -1016,7 +1376,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
 
         Notes
         -----
-        The estimation of the wave velocities is made by finding the eigenvalues of the Christoffel tensor [2]_.
+        The estimation of the wave velocities is made by finding the eigenvalues of the Christoffel tensor [Jaeken]_.
 
         One should double-check the units. The table below provides hints about the unit you get, depending on the units
         you use for stiffness and the mass density:
@@ -1037,22 +1397,51 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
 
         References
         ----------
-        .. [2] J. W. Jaeken, S. Cottenier, Solving the Christoffel equation: Phase and group velocities, Computer Physics
+        .. [Jaeken] J. W. Jaeken, S. Cottenier, Solving the Christoffel equation: Phase and group velocities, Computer Physics
                Communications (207), 2016, https://doi.org/10.1016/j.cpc.2016.06.014.
 
+        Examples
+        --------
+        We will investigate the wave velocities in cubic Cu. First, define the stiffness tensor:
+
+        >>> C = StiffnessTensor.cubic(C11=186e3, C12=134e3, C44=77e3) # Stiffness in MPa
+        >>> rho = 8960 # mass density in kg/m³
+        >>> c_p, c_s1, c_s2 = C.wave_velocity(rho)
+
+        The range of velocities of the (fast) primary wave range can be printed with:
+
+        >>> print(c_p)
+        Spherical function
+        Min=4.556196722204669, Max=5.324304112812698
+
+        As the stiffness is given in MPa and the mass desity is given in kg/m³, the velocities are returned in km/s
+        (see Notes). If one wants to know the direction for min/max values:
+
+        >>> val_min, u_min = c_p.min()
+        >>> print(u_min)
+        [[0. 0. 1.]]
+
+        >>> val_max, u_max = c_p.max()
+        >>> print(u_max)
+        [[0.57735022 0.57735033 0.57735026]]
+
+        The secondary wave velocities are given by ``cs_1`` and ``cs_2``:
+
+        >>> c_s1
+        Spherical function
+        Min=2.1906864565414192, Max=2.9315098498896446
+
+        >>> c_s2
+        Spherical function
+        Min=1.7034628596749235, Max=2.9315098498896437
         """
-        self._single_tensor_only('wave_velocity')
+        if self.ndim:
+            raise ValueError('This function is not suitable for tensor array. Consider subscripting (e.g. C[0].wave_velocity()).')
         def make_fun(index):
             def fun(n):
                 Gamma = self.Christoffel_tensor(n)
-                eig, _ = np.linalg.eig(Gamma)
-                if index == 0:
-                    eig_of_interest = np.max(eig, axis=-1)
-                elif index == 1:
-                    eig_of_interest = np.median(eig, axis=-1)
-                else:
-                    eig_of_interest = np.min(eig, axis=-1)
-                return np.sqrt(eig_of_interest / rho)
+                eig = Gamma.eigvals()
+                return np.sqrt(eig[...,index] / rho)
 
             return fun
 
@@ -1093,9 +1482,8 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
                 key = str(material.material_id)
                 if material.elastic_tensor is not None:
                     matrix = material.elastic_tensor.ieee_format
-                    symmetry = material.symmetry.crystal_system.value
                     phase_name = material.formula_pretty
-                    C = StiffnessTensor(np.asarray(matrix), symmetry=str(symmetry), phase_name=phase_name)
+                    C = StiffnessTensor(np.asarray(matrix), phase_name=phase_name)
                 else:
                     C = None
                 Cdict[key] = C
@@ -1130,7 +1518,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         if np.all([isinstance(a, ComplianceTensor) for a in Cs]):
             Cs = [C.inv() for C in Cs]
         if np.all([isinstance(a, StiffnessTensor) for a in Cs]):
-            C_stack = np.array([C._matrix for C in Cs])
+            C_stack = np.array([C.matrix() for C in Cs])
             method = method.capitalize()
             if method == 'Voigt':
                 C_avg = np.average(C_stack, weights=volume_fractions, axis=0)
@@ -1174,13 +1562,16 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         .. [3] S. I. Ranganathan and M. Ostoja-Starzewski, Universal Elastic Anisotropy Index,
            *Phys. Rev. Lett.*, 101(5), 055504, 2008. https://doi.org/10.1103/PhysRevLett.101.055504
         """
-        self._single_tensor_only('universal_anisotropy')
-        Cvoigt = self.Voigt_average()
-        Creuss = self.Reuss_average()
-        Gv = Cvoigt._matrix[3, 3]
-        Gr = Creuss._matrix[3, 3]
-        Kv = Cvoigt.bulk_modulus
-        Kr = Creuss.bulk_modulus
+        if isinstance(self, StiffnessTensor):
+            C_voigt = self.infinite_random_average()
+            S_reuss = self.inv().infinite_random_average()
+        else:
+            S_reuss = self.infinite_random_average()
+            C_voigt = self.inv().infinite_random_average()
+        Kv = C_voigt.bulk_modulus
+        Kr = S_reuss.bulk_modulus
+        Gv = C_voigt._matrix[..., 3, 3] / 2
+        Gr = 1 / S_reuss._matrix[..., 3, 3] / 2
         return 5 * Gv / Gr + Kv / Kr - 6
 
     def Zener_ratio(self, tol=1e-4):
@@ -1245,7 +1636,6 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
             0.        ]
          [ 25.98076211 -25.98076211   0.           0.           0.
            65.        ]]
-        Symmetry: cubic
 
         Still, we have
         >>> C_rot.Zener_ratio()
@@ -1274,7 +1664,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
             from pymatgen.analysis.elasticity import elastic as matgenElast
         except ImportError:
             raise ModuleNotFoundError('pymatgen module is required for this function.')
-        return matgenElast.ElasticTensor(self.full_tensor())
+        return matgenElast.ElasticTensor(self.full_tensor)
 
     def to_Kelvin(self):
         """
@@ -1292,7 +1682,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
 
         Notes
         -----
-        This mapping convention is defined as follows [4]_:
+        This mapping convention is defined as follows [Helbig]_:
 
         .. math::
 
@@ -1308,11 +1698,32 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
 
         References
         ----------
-        .. [4] Helbig, K. (2013). What Kelvin might have written about Elasticity. Geophysical Prospecting, 61(1), 1-20.
-            doi: 10.1111/j.1365-2478.2011.01049.x
-        """
-        kelvin_mapping = KelvinMapping()
-        return self._matrix /self.mapping.matrix * kelvin_mapping.matrix
+        .. [Helbig] Helbig, K. (2013). What Kelvin might have written about Elasticity. Geophysical Prospecting, 61(1), 1-20.
+            doi: `10.1111/j.1365-2478.2011.01049.x`_
+
+            .. _10.1111/j.1365-2478.2011.01049.x: https://doi.org/10.1111/j.1365-2478.2011.01049.x
+
+        Examples
+        --------
+        >>> from Elasticipy.tensors.elasticity import StiffnessTensor
+        >>> C = StiffnessTensor.cubic(C11=200, C12=40, C44=20)
+        >>> print(C)
+        Stiffness tensor (in Voigt mapping):
+        [[200.  40.  40.   0.   0.   0.]
+         [ 40. 200.  40.   0.   0.   0.]
+         [ 40.  40. 200.   0.   0.   0.]
+         [  0.   0.   0.  20.   0.   0.]
+         [  0.   0.   0.   0.  20.   0.]
+         [  0.   0.   0.   0.   0.  20.]]
+        >>> C.to_Kelvin()
+        array([[200.,  40.,  40.,   0.,   0.,   0.],
+               [ 40., 200.,  40.,   0.,   0.,   0.],
+               [ 40.,  40., 200.,   0.,   0.,   0.],
+               [  0.,   0.,   0.,  40.,   0.,   0.],
+               [  0.,   0.,   0.,   0.,  40.,   0.],
+               [  0.,   0.,   0.,   0.,   0.,  40.]])
+        """
+        return self._matrix
 
     def eig(self):
         """
@@ -1335,9 +1746,9 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
 
         Notes
         -----
-        The definition for eigenstiffnesses and the eigenstrains are introduced in [4]_.
+        The definition for eigenstiffnesses and the eigenstrains are introduced in [Helbig]_.
         """
-        return np.linalg.eigh(self.to_Kelvin())
+        return np.linalg.eigh(self._matrix)
 
     @property
     def eig_stiffnesses(self):
@@ -1354,8 +1765,22 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         eig : returns the eigenstiffnesses and the eigenstrains
         eig_strains : returns the eigenstrains only
         eig_stiffnesses_multiplicity : returns the unique values of eigenstiffnesses with multiplicity
+
+        Notes
+        -----
+        The eigenstiffnesses are defined in [Helbig]_.
+
+        Examples
+        --------
+        >>> from Elasticipy.tensors.elasticity import StiffnessTensor
+        >>> C = StiffnessTensor.cubic(C11=200, C12=40, C44=20)
+        >>> C.eig_stiffnesses
+        array([ 40.,  40.,  40., 160., 160., 280.])
+
+        These values actually correspond to 2*C44 (with multiplicity = 3), C11-C12 (with multiplicity = 2) and C11+2C12
+        (no multiplicity); see [Helbig]_.
         """
-        return np.linalg.eigvalsh(self.to_Kelvin())
+        return np.linalg.eigvalsh(self._matrix)
 
     @property
     def eig_strains(self):
@@ -1409,10 +1834,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         --------
         to_Kelvin : return the components as a (6,6) matrix following the Kelvin convention
         """
-        kelvin_mapping = KelvinMapping()
-        t = cls(matrix / kelvin_mapping.matrix, **kwargs)
-        t._matrix *= t.mapping.matrix
-        return t
+        return cls(matrix, mapping=kelvin_mapping, **kwargs)
 
     def eig_stiffnesses_multiplicity(self, tol=1e-4):
         """
@@ -1534,9 +1956,9 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
             8.1901353 ]
          [-20.34233446   0.99714278  19.34519167  -6.52548033   8.1901353
            39.41409344]]
-        Symmetry: cubic
 
-        Once rotated, it is not clear if the stiffness tensors has cubic symmetry. Yet:
+        Once rotated, it is not clear if the stiffness tensors has cubic symmetry on sight. Yet:
+
         >>> C_rotated.is_cubic()
         True
 
@@ -1572,12 +1994,127 @@ class ComplianceTensor(StiffnessTensor):
     """
     Class for manipulating compliance tensors
     """
-    tensor_name = 'Compliance'
-    C11_C12_factor = 2.0
-    component_prefix = 'S'
-    C46_C56_factor = 2.0
+    _tensor_name = 'Compliance'
+    _C11_C12_factor = 2.0
+    _component_prefix = 'S'
+    _C46_C56_factor = 2.0
 
     def __init__(self, C, check_positive_definite=True, mapping=VoigtMapping(tensor='Compliance'), **kwargs):
+        """
+        Construct a compliance tensor or an array of commpliance tensors.
+
+        The compliance tensor can be constructed from a (6,6) matrix or slices of (6,6) matrices. These matrices must be
+        symmetric. An error is thrown if this matrix in not definite positive (except if
+        ``check_positive_definite==False``, see below). The input argument can also be the full tensor (array of shape
+        (...,3,3,3,3)).
+
+        Parameters
+        ----------
+        M : list or np.ndarray
+            (...,6,6) matrix corresponding to the compliance tensor, written using the Voigt notation, or array of shape
+            (...,3,3,3,3).
+        phase_name : str, optional
+            Phase name to display
+        check_positive_definite : bool, optional
+            Whether to check if the input matrix is positive definite or not. True by default.
+        check_symmetry : bool, optional
+            Whether to check or not that the input matrix is symmetric.
+        force_symmetry : bool, optional
+            If true, the major symmetry of the tensor is forced
+        mapping : str or MappingConvention
+            mapping convention to use. Default is VoigtMapping.
+
+        Notes
+        -----
+        The units used when building the comliance tensor are up to the user (/GPa, /MPa, /psi etc.). Therefore, the
+        results you will get when performing operations (Young's modulus, "product" with strain tensor etc.) will be
+        consistent with these units. For instance, if the compliance tensor is defined in /GPa, the computed stress will
+        be given in GPa.
+
+        Examples
+        --------
+        Create a compliance tensor for cubic symmetry:
+
+        >>> matrix = [[200, 40,  40,  0,  0,  0 ],
+        ...           [40,  200, 40,  0,  0,  0 ],
+        ...           [40,  40,  200, 0,  0,  0 ],
+        ...           [0,   0,   0,   20, 0,  0 ],
+        ...           [0,   0,   0,   0,  20, 0 ],
+        ...           [0,   0,   0,   0,   0, 20]]
+        >>> from Elasticipy.tensors.elasticity import ComplianceTensor
+        >>> S = ComplianceTensor(matrix)
+        >>> print(S)
+        Compliance tensor (in Voigt mapping):
+        [[200.  40.  40.   0.   0.   0.]
+         [ 40. 200.  40.   0.   0.   0.]
+         [ 40.  40. 200.   0.   0.   0.]
+         [  0.   0.   0.  20.   0.   0.]
+         [  0.   0.   0.   0.  20.   0.]
+         [  0.   0.   0.   0.   0.  20.]]
+
+        Create a stiffness tensor from full (3,3,3,3) array:
+
+        >>> S_full = S.full_tensor # (3,3,3,3) numpy array
+        >>> print((type(S_full), S_full.shape))
+        (<class 'numpy.ndarray'>, (3, 3, 3, 3))
+
+        >>> ComplianceTensor(S_full)
+        Compliance tensor (in Voigt mapping):
+        [[200.  40.  40.   0.   0.   0.]
+         [ 40. 200.  40.   0.   0.   0.]
+         [ 40.  40. 200.   0.   0.   0.]
+         [  0.   0.   0.  20.   0.   0.]
+         [  0.   0.   0.   0.  20.   0.]
+         [  0.   0.   0.   0.   0.  20.]]
+
+        Create an array of compliance tensors:
+
+        First, we create two slices of (6,6) matrices, corresponding to two compliance values:
+
+        >>> slices = [[[200, 40,  40,  0,  0,  0 ],
+        ...            [40,  200, 40,  0,  0,  0 ],
+        ...            [40,  40,  200, 0,  0,  0 ],
+        ...            [0,   0,   0,   20, 0,  0 ],
+        ...            [0,   0,   0,   0,  20, 0 ],
+        ...            [0,   0,   0,   0,   0, 20]],
+        ...           [[250, 80,  80,  0,  0,  0 ],
+        ...            [80,  250, 80,  0,  0,  0 ],
+        ...            [80,  80,  250, 0,  0,  0 ],
+        ...            [0,   0,   0,   40, 0,  0 ],
+        ...            [0,   0,   0,   0,  40, 0 ],
+        ...            [0,   0,   0,   0,   0, 40]]]
+
+        Then, one can create an array of compliance tensors:
+
+        >>> S_array=ComplianceTensor(slices)
+        >>> print(S_array)
+        Compliance tensor (in Voigt mapping):
+        [[[200.  40.  40.   0.   0.   0.]
+          [ 40. 200.  40.   0.   0.   0.]
+          [ 40.  40. 200.   0.   0.   0.]
+          [  0.   0.   0.  20.   0.   0.]
+          [  0.   0.   0.   0.  20.   0.]
+          [  0.   0.   0.   0.   0.  20.]]
+        <BLANKLINE>
+         [[250.  80.  80.   0.   0.   0.]
+          [ 80. 250.  80.   0.   0.   0.]
+          [ 80.  80. 250.   0.   0.   0.]
+          [  0.   0.   0.  40.   0.   0.]
+          [  0.   0.   0.   0.  40.   0.]
+          [  0.   0.   0.   0.   0.  40.]]]
+
+
+        This array can be subindexed. E.g.:
+
+        >>> S_array[0]
+        Compliance tensor (in Voigt mapping):
+        [[200.  40.  40.   0.   0.   0.]
+         [ 40. 200.  40.   0.   0.   0.]
+         [ 40.  40. 200.   0.   0.   0.]
+         [  0.   0.   0.  20.   0.   0.]
+         [  0.   0.   0.   0.  20.   0.]
+         [  0.   0.   0.   0.   0.  20.]]
+        """
         super().__init__(C, check_positive_definite=check_positive_definite, mapping=mapping, **kwargs)
         self.mapping_name = 'Voigt'
 
@@ -1600,21 +2137,15 @@ class ComplianceTensor(StiffnessTensor):
             Reciprocal tensor
         """
         S = np.linalg.inv(self._matrix)
-        return StiffnessTensor(S, symmetry=self.symmetry, phase_name=self.phase_name)
+        t = StiffnessTensor(S, mapping=kelvin_mapping, phase_name=self.phase_name)
+        t.mapping = self.mapping.mapping_inverse
+        return t
 
     def Reuss_average(self, axis=None):
         if self.ndim:
             return self.mean(axis=axis)
         else:
-            s = self._matrix
-            A = s[0, 0] + s[1, 1] + s[2, 2]
-            B = s[0, 1] + s[0, 2] + s[1, 2]
-            C = s[3, 3] + s[4, 4] + s[5, 5]
-            S11 = 1 / 5 *  A + 2 / 15 * B + 1 / 15 * C
-            S12 = 1 / 15 * A + 4 / 15 * B - 1 / 30 * C
-            S44 = 4 / 15 * (A - B) + 1 / 5 * C
-            mat = _isotropic_matrix(S11, S12, S44)
-            return ComplianceTensor(mat, symmetry='isotropic', phase_name=self.phase_name)
+            return self.infinite_random_average()
 
     def Voigt_average(self, axis=None):
         return self.inv().Voigt_average(axis=axis).inv()
@@ -1623,12 +2154,82 @@ class ComplianceTensor(StiffnessTensor):
         return self.inv().Hill_average(axis=axis).inv()
 
     @classmethod
-    def isotropic(cls, E=None, nu=None, lame1=None, lame2=None, phase_name=None):
-        return super().isotropic(E=E, nu=nu, lame1=lame1, lame2=lame2, phase_name=None).inv()
+    def isotropic(cls, E=None, nu=None, G=None, lame1=None, lame2=None, K=None, phase_name=None):
+        if lame2 is not None:
+            if G is None:
+                G = lame2
+            else:
+                raise ValueError('G and lame2 cannot be provided together.')
+        n_specified = sum(v is not None for v in [E, nu, lame1, G, K])
+        if n_specified != 2:
+            raise ValueError("Exactly two values are required among E, nu, G, K, lame1 and lame2.")
+        if K is not None:
+            K = np.asarray(K)
+            if E is not None:
+                E = np.asarray(E, dtype=float)
+                G = 3 * K * E / (9 * K - E)
+                nu = (3 * K - E) / 6 / K
+            elif lame1 is not None:
+                lame1 = np.asarray(lame1, dtype=float)
+                E = 9 * K * (K - lame1) / (3 * K -lame1)
+                G= 3 * (K - lame1) / 2
+                nu = lame1 / (3*K-lame1)
+            elif G is not None:
+                G = np.asarray(G, dtype=float)
+                E = 9 * K * G / (3 * K + G)
+                nu = (3 * K - 2 * G) / 2 / (3 * K + G)
+            elif nu is not None:
+                nu = np.asarray(nu, dtype=float)
+                E = 3 * K * (1 - 2 * nu)
+                G = E / 2 / (1 + nu)
+        elif E is not None:
+            E = np.asarray(E, dtype=float)
+            if lame1 is not None:
+                lame1 = np.asarray(lame1, dtype=float)
+                R = np.sqrt(E**2 + 9*lame1**2 + 2*E*lame1)
+                G = (E - 3 * lame1 + R) / 4
+                nu = 2 * lame1 / (E + lame1 + R)
+            elif G is not None:
+                G = np.asarray(G, dtype=float)
+                nu = E / 2 / G - 1
+            elif nu is not None:
+                nu = np.asarray(nu, dtype=float)
+                G = E / 2 / (1 + nu)
+        elif lame1 is not None:
+            lame1 = np.asarray(lame1, dtype=float)
+            if G is not None:
+                G = np.asarray(G, dtype=float)
+                E = G * (3 * lame1 + 2 * G) / (lame1 + G)
+                nu = lame1 / 2 / (lame1 + G)
+            elif nu is not None:
+                nu = np.asarray(nu, dtype=float)
+                E = lame1 * ( 1 + nu) * (1 - 2 * nu) / nu
+                G = lame1 * (1 - 2 * nu) / 2 / nu
+        elif (nu is not None) and (G is not None):
+            nu = np.asarray(nu, dtype=float)
+            G = np.asarray(G)
+            E = 2 * G * (1 + nu)
+        S11 = 1/E
+        S12 = -nu/E
+        S44 = 1 / G
+        S_mat = _isotropic_matrix(S11, S12, S44)
+        return ComplianceTensor(S_mat, phase_name=phase_name)
 
     @classmethod
-    def orthotropic(cls, *args, **kwargs):
-        return super().orthotropic(*args, **kwargs).inv()
+    def orthotropic(cls, *, Ex, Ey, Ez, Gxy, Gxz, Gyz,
+                    nu_yx=None, nu_zx=None, nu_zy=None,
+                    nu_xy=None, nu_xz=None, nu_yz=None, **kwargs):
+        nu_yx = _switch_poisson_ratios(nu_xy, nu_yx, Ex, Ey,'xy')
+        nu_zx = _switch_poisson_ratios(nu_xz, nu_zx, Ex, Ez,'xz')
+        nu_zy = _switch_poisson_ratios(nu_yz, nu_zy, Ey, Ez,'yz')
+        tri_sup = np.array([[1 / Ex, -nu_yx / Ey, -nu_zx / Ez, 0, 0, 0],
+                            [0, 1 / Ey, -nu_zy / Ez, 0, 0, 0],
+                            [0, 0, 1 / Ez, 0, 0, 0],
+                            [0, 0, 0, 1 / Gyz, 0, 0],
+                            [0, 0, 0, 0, 1 / Gxz, 0],
+                            [0, 0, 0, 0, 0, 1 / Gxy]])
+        S = tri_sup + np.tril(tri_sup.T, -1)
+        return ComplianceTensor(S, **kwargs)
 
     @classmethod
     def transverse_isotropic(cls, *args, **kwargs):
@@ -1671,7 +2272,7 @@ class ComplianceTensor(StiffnessTensor):
             from pymatgen.analysis.elasticity import elastic as matgenElast
         except ImportError:
             raise ModuleNotFoundError('pymatgen module is required for this function.')
-        return matgenElast.ComplianceTensor(self.full_tensor())
+        return matgenElast.ComplianceTensor(self.full_tensor)
 
     def eig(self):
         """
@@ -1694,7 +2295,7 @@ class ComplianceTensor(StiffnessTensor):
 
         Notes
         -----
-        The definition for eigencompliances and the eigenstresses are introduced in [4]_.
+        The definition for eigencompliances and the eigenstresses are introduced in [Helbig]_.
         """
         return np.linalg.eigh(self.to_Kelvin())
 
@@ -1745,4 +2346,232 @@ class ComplianceTensor(StiffnessTensor):
         --------
         eig_compliances : compute the eigencompliances from the Kelvin's matrix of compliance
         """
-        return 1/self.eig_compliances
+        return 1/self.eig_compliances
+
+    @property
+    def lame1(self):
+        return self.inv().lame1
+
+    @property
+    def lame2(self):
+        return self.inv().lame2
+
+
+    @classmethod
+    def hexagonal(cls, *, S11=0., S12=0., S13=0., S33=0., S44=0., phase_name=None):
+        """
+        Create a fourth-order tensor from hexagonal symmetry.
+
+        Parameters
+        ----------
+        S11, S12 , S13, S33, S44 : float
+            Components of the tensor, using the Voigt notation
+        phase_name : str, optional
+            Phase name to display
+        Returns
+        -------
+        FourthOrderTensor
+
+        See Also
+        --------
+        transverse_isotropic : creates a transverse-isotropic tensor from engineering parameters
+        cubic : create a tensor from cubic symmetry
+        tetragonal : create a tensor from tetragonal symmetry
+        """
+        return cls._fromCrystalSymmetry(symmetry='hexagonal', S11=S11, S12=S12, S13=S13, S33=S33, S44=S44,
+                                       phase_name=phase_name, prefix='S')
+
+    @classmethod
+    def trigonal(cls, *, S11=0., S12=0., S13=0., S14=0., S33=0., S44=0., S15=0., phase_name=None):
+        """
+        Create a fourth-order tensor from trigonal symmetry.
+
+        Parameters
+        ----------
+        S11, S12, S13, S14, S33, S44 : float
+            Components of the tensor, using the Voigt notation
+        S15 : float, optional
+            S15 component of the tensor, only used for point groups 3 and -3.
+        phase_name : str, optional
+            Phase name to display
+        Returns
+        -------
+        FourthOrderTensor
+
+        See Also
+        --------
+        tetragonal : create a tensor from tetragonal symmetry
+        orthorhombic : create a tensor from orthorhombic symmetry
+        """
+        return cls._fromCrystalSymmetry(symmetry='trigonal', point_group='3',
+                                        S11=S11, S12=S12, S13=S13, S14=S14, S15=S15,
+                                        S33=S33, S44=S44, phase_name=phase_name, prefix='S')
+
+    @classmethod
+    def tetragonal(cls, *, S11=0., S12=0., S13=0., S33=0., S44=0., S16=0., S66=0., phase_name=None):
+        """
+        Create a fourth-order tensor from tetragonal symmetry.
+
+        Parameters
+        ----------
+        S11,  S12, S13, S33, S44, S66 : float
+            Components of the tensor, using the Voigt notation
+        S16 : float, optional
+            S16 component in Voigt notation (for point groups 4, -4 and 4/m only)
+        phase_name : str, optional
+            Phase name to display
+
+        Returns
+        -------
+        FourthOrderTensor
+
+        See Also
+        --------
+        trigonal : create a tensor from trigonal symmetry
+        orthorhombic : create a tensor from orthorhombic symmetry
+        """
+        return cls._fromCrystalSymmetry(symmetry='tetragonal', point_group='4',
+                                        S11=S11, S12=S12, S13=S13, S16=S16,
+                                        S33=S33, S44=S44, S66=S66, phase_name=phase_name, prefix='S')
+
+    @classmethod
+    def cubic(cls, *, S11=0., S12=0., S44=0., phase_name=None):
+        """
+        Create a fourth-order tensor from cubic symmetry.
+
+        Parameters
+        ----------
+        S11 , S12, S44 : float
+        phase_name : str, optional
+            Phase name to display
+
+        Returns
+        -------
+        StiffnessTensor
+
+        See Also
+        --------
+        hexagonal : create a tensor from hexagonal symmetry
+        orthorhombic : create a tensor from orthorhombic symmetry
+        """
+        return cls._fromCrystalSymmetry(symmetry='cubic', S11=S11, S12=S12, S44=S44, phase_name=phase_name, prefix='S')
+
+    @classmethod
+    def orthorhombic(cls, *, S11=0., S12=0., S13=0., S22=0., S23=0., S33=0., S44=0., S55=0., S66=0., phase_name=None):
+        """
+        Create a fourth-order tensor from orthorhombic symmetry.
+
+        Parameters
+        ----------
+        S11, S12, S13, S22, S23, S33, S44, S55, S66 : float
+            Components of the tensor, using the Voigt notation
+        phase_name : str, optional
+            Phase name to display
+
+        Returns
+        -------
+        FourthOrderTensor
+
+        See Also
+        --------
+        monoclinic : create a tensor from monoclinic symmetry
+        orthorhombic : create a tensor from orthorhombic symmetry
+        """
+        return cls._fromCrystalSymmetry(symmetry='orthorhombic',
+                                       S11=S11, S12=S12, S13=S13, S22=S22, S23=S23, S33=S33, S44=S44, S55=S55, S66=S66,
+                                       phase_name=phase_name, prefix='S')
+
+    @classmethod
+    def monoclinic(cls, *, S11=0., S12=0., S13=0., S22=0., S23=0., S33=0., S44=0., S55=0., S66=0.,
+                   S15=None, S25=None, S35=None, S46=None,
+                   S16=None, S26=None, S36=None, S45=None,
+                   phase_name=None):
+        """
+        Create a fourth-order tensor from monoclinic symmetry. It automatically detects whether the components are given
+        according to the Y or Z diad, depending on the input arguments.
+
+        For Diad || y, S15, S25, S35 and S46 must be provided.
+        For Diad || z, S16, S26, S36 and S45 must be provided.
+
+        Parameters
+        ----------
+        S11, S12 , S13, S22, S23, S33, S44, S55, S66 : float
+            Components of the tensor, using the Voigt notation
+        S15 : float, optional
+            S15 component of the tensor (if Diad || y)
+        S25 : float, optional
+            S25 component of the tensor (if Diad || y)
+        S35 : float, optional
+            S35 component of the tensor (if Diad || y)
+        S46 : float, optional
+            S46 component of the tensor (if Diad || y)
+        S16 : float, optional
+            S16 component of the tensor (if Diad || z)
+        S26 : float, optional
+            S26 component of the tensor (if Diad || z)
+        S36 : float, optional
+            S36 component of the tensor (if Diad || z)
+        S45 : float, optional
+            S45 component of the tensor (if Diad || z)
+        phase_name : str, optional
+            Name to display
+
+        Returns
+        -------
+        FourthOrderTensor
+
+        See Also
+        --------
+        triclinic : create a tensor from triclinic symmetry
+        orthorhombic : create a tensor from orthorhombic symmetry
+        """
+        diad_y = not (None in (S15, S25, S35, S46))
+        diad_z = not (None in (S16, S26, S36, S45))
+        if diad_y and diad_z:
+            raise KeyError('Ambiguous diad. Provide either S15, S25, S35 and S46; or S16, S26, S36 and S45')
+        elif diad_y:
+            return cls._fromCrystalSymmetry(symmetry='monoclinic', diad='y',
+                                           S11=S11, S12=S12, S13=S13, S22=S22, S23=S23, S33=S33, S44=S44, S55=S55,
+                                           S66=S66,
+                                           S15=S15, S25=S25, S35=S35, S46=S46, phase_name=phase_name, prefix='S')
+        elif diad_z:
+            return cls._fromCrystalSymmetry(symmetry='monoclinic', diad='z',
+                                           S11=S11, S12=S12, S13=S13, S22=S22, S23=S23, S33=S33, S44=S44, S55=S55,
+                                           S66=S66,
+                                           S16=S16, S26=S26, S36=S36, S45=S45, phase_name=phase_name, prefix='S')
+        else:
+            raise KeyError('For monoclinic symmetry, one should provide either S15, S25, S35 and S46, '
+                           'or S16, S26, S36 and S45.')
+
+    @classmethod
+    def triclinic(cls, S11=0., S12=0., S13=0., S14=0., S15=0., S16=0.,
+                  S22=0., S23=0., C24=0., S25=0., S26=0.,
+                  S33=0., C34=0., S35=0., S36=0.,
+                  S44=0., S45=0., S46=0.,
+                  S55=0., C56=0.,
+                  S66=0., phase_name=None):
+        """
+
+        Parameters
+        ----------
+        S11 , S12 , S13 , S14 , S15 , S16 , S22 , S23 , C24 , S25 , S26 , S33 , C34 , S35 , S36 , S44 , S45 , S46 , S55 , C56 , S66 : float
+            Components of the tensor
+        phase_name : str, optional
+            Name to display
+
+        Returns
+        -------
+        FourthOrderTensor
+
+        See Also
+        --------
+        monoclinic : create a tensor from monoclinic symmetry
+        orthorhombic : create a tensor from orthorhombic symmetry
+        """
+        matrix = np.array([[S11, S12, S13, S14, S15, S16],
+                           [S12, S22, S23, C24, S25, S26],
+                           [S13, S23, S33, C34, S35, S36],
+                           [S14, C24, C34, S44, S45, S46],
+                           [S15, S25, S35, S45, S55, C56],
+                           [S16, S26, S36, S46, C56, S66]])
+        return cls(matrix, phase_name=phase_name)