elasticipy 6.0.0__py3-none-any.whl → 6.1.0__py3-none-any.whl

elasticipy/gui/about.py

@@ -1,25 +1,27 @@
 from qtpy.QtWidgets import QVBoxLayout, QLabel, QPushButton
 from qtpy.QtGui import QPixmap
 from qtpy.QtCore import Qt
+from importlib import resources
 
-def about(dialog, logo_path):
-    dialog.setWindowTitle("About elasticipy")
+def about(dialog):
+    dialog.setWindowTitle("About Elasticipy")
     dialog.setFixedWidth(400)
 
     layout = QVBoxLayout(dialog)
 
-    if logo_path.exists():
-        logo = QLabel()
-        pixmap = QPixmap(str(logo_path))
-        pixmap = pixmap.scaledToWidth(250, Qt.SmoothTransformation)
-        logo.setPixmap(pixmap)
-        logo.setAlignment(Qt.AlignCenter)
-        layout.addWidget(logo)
+    logo = QLabel()
+    pixmap = QPixmap(
+        str(resources.files("elasticipy.resources") / "logo_text.png")
+    )
+    pixmap = pixmap.scaledToWidth(250, Qt.SmoothTransformation)
+    logo.setPixmap(pixmap)
+    logo.setAlignment(Qt.AlignCenter)
+    layout.addWidget(logo)
 
     # --- Text ---
     text = QLabel(
         "A Python library for elasticity tensors computations<br><br>"
-        "© 2024–2025 Dorian Depriester, MIT Licence"
+        "© 2025–2026 Dorian Depriester, MIT Licence"
     )
     text.setAlignment(Qt.AlignCenter)
     layout.addWidget(text)

elasticipy/gui/gui.py

@@ -11,16 +11,12 @@ from elasticipy.crystal_symmetries import SYMMETRIES
 from elasticipy.gui.rotate_window import EulerBungeDialog
 from elasticipy.gui.about import about
 from elasticipy.tensors.elasticity import StiffnessTensor
-from pathlib import Path
+from importlib import resources
 
 from scipy.spatial.transform import Rotation
 
 WHICH_OPTIONS = {'Mean': 'mean', 'Max': 'max', 'Min': 'min', 'Std. dev.': 'std'}
 
-# --- Logo ---
-here = Path(__file__).resolve().parent
-LOGO_PATH = here / ".." / "resources" / "logo_text.svg"
-ICON_PATH = here / ".." / "resources" / "favicon.png"
 
 class ElasticityGUI(QMainWindow):
     def __init__(self):
@@ -388,7 +384,7 @@ class ElasticityGUI(QMainWindow):
 
     def show_about(self):
         dialog = QDialog(self)
-        dialog = about(dialog, LOGO_PATH)
+        dialog = about(dialog)
         dialog.exec_()
 
     def open_euler_dialog(self):
@@ -420,7 +416,8 @@ class ElasticityGUI(QMainWindow):
 def crystal_elastic_plotter():
     app = QApplication(sys.argv)
     try:
-        icon = QIcon(str(ICON_PATH))
+        path_to_icon = str(resources.files("elasticipy.resources") / "favicon.png")
+        icon = QIcon(str(path_to_icon))
     except Exception:
         icon = QIcon()
     app.setWindowIcon(icon)

elasticipy/interfaces/FEPX.py

@@ -1,6 +1,6 @@
 from elasticipy.tensors.second_order import SymmetricSecondOrderTensor, SecondOrderTensor, \
     SkewSymmetricSecondOrderTensor
-from elasticipy.tensors.stress_strain import StressTensor, StrainTensor
+from elasticipy.tensors.stress_strain import StressTensor, StrainTensor, StrainRateTensor
 import pandas as pd
 import numpy as np
 import os
@@ -12,8 +12,8 @@ DTYPES={'stress':StressTensor,
         'strain_el':StrainTensor,
         'strain_pl':StrainTensor,
         'velgrad':SecondOrderTensor,
-        'defrate':SymmetricSecondOrderTensor,
-        'defrate_pl':SymmetricSecondOrderTensor,
+        'defrate':StrainRateTensor,
+        'defrate_pl':StrainRateTensor,
         'spinrate':SkewSymmetricSecondOrderTensor,
         }
 

elasticipy/interfaces/PRISMS.py

@@ -10,8 +10,8 @@ def from_quadrature_file(file, returns='stress'):
     """
     Read data from quadrature output file generated by PRISMS plasticity.
 
-    These files, usually named QuadratureOutputsXXX.csv (where XXX denotes the time increment), contain large amount of
-    data, such as gradient components, stress values, grain ID etc.
+    These files, usually named ``QuadratureOutputsXXX.csv`` (where XXX denotes the time increment), contain large amount
+    of data, such as gradient components, stress values, grain ID etc.
 
     Parameters
     ----------
@@ -76,7 +76,7 @@ def from_stressstrain_file(file):
     """
     Read data from stress-strain file generated by PRISMS plasticity.
 
-    This file is usually named stressstrain.txt
+    This file is usually named ``stressstrain.txt``.
 
     Parameters
     ----------

elasticipy/plasticity.py

@@ -63,7 +63,7 @@ class IsotropicHardening:
          criterion: von Mises
          current strain: 0.0
 
-        >>> JC.flow_stress(0.0) # Check that the yield stress = A
+        >>> print(JC.flow_stress(0.0)) # Check that the yield stress = A
         792.0
 
         In order to get the full tensile curve in 0 to 10% strain range:

elasticipy/spherical_function.py

@@ -247,7 +247,7 @@ class SphericalFunction:
 
         The Young modulus along x direction is:
 
-        >>> E.eval([1,0,0])
+        >>> print(E.eval([1,0,0]))
         74.4390243902439
 
         The Young moduli along a set a directions can be evaluated at once. E.g. along x, y and z:
@@ -305,7 +305,7 @@ class SphericalFunction:
         In spherical coordinates, the x direction is defined by theta=90° and phi=0. Therefore, the Young modulus along
         x direction is:
 
-        >>> E.eval_spherical([0, 90], degrees=True)
+        >>> print(E.eval_spherical([0, 90], degrees=True))
         74.4390243902439
         """
         angles = np.atleast_2d(args)
@@ -627,6 +627,7 @@ class SphericalFunction:
             r = self.eval_spherical(angles)
             ax.plot(theta_polar, r, **kwargs)
             axs_new.append(ax)
+        new_fig.tight_layout()
         return new_fig, axs_new
 
     def plot_as_pole_figure(self, n_theta=50, n_phi=200, projection='lambert',
@@ -981,6 +982,7 @@ class HyperSphericalFunction(SphericalFunction):
         handles.extend([line, area])
         labels.extend([line.get_label(), area.get_label()])
         new_fig.legend(handles, labels, loc='upper center', ncol=2, bbox_to_anchor=(0.5, 0.95))
+        new_fig.tight_layout()
         return new_fig, axs
 
     def plot_as_pole_figure(self, n_theta=50, n_phi=200, n_psi=50, which='mean', projection='lambert', fig=None,
@@ -1032,7 +1034,7 @@ class HyperSphericalFunction(SphericalFunction):
             subplot_kwargs = {}
         if fig is None:
             fig = plt.figure()
-        ax = add_polefigure(fig, *subplot_kwargs, projection=projection, **subplot_kwargs)
+        ax = add_polefigure(fig, *subplot_args, projection=projection, **subplot_kwargs)
         phi = np.linspace(*self.domain[0], n_phi)
         theta = np.linspace(*self.domain[1], n_theta)
         psi = np.linspace(*self.domain[2], n_psi)

elasticipy/tensors/elasticity.py

@@ -725,6 +725,34 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         -------
         HyperSphericalFunction
             Shear modulus
+
+        Examples
+        --------
+        Let's compute the shear modulus of an isotropic material, defined by its Young modulus and Poisson ratio:
+
+        >>> from elasticipy.tensors.elasticity import StiffnessTensor
+        >>> C = StiffnessTensor.isotropic(E=210, nu=0.27)
+        >>> C.shear_modulus
+        Hyperspherical function
+        Min=82.67716535433061, Max=82.67716535433077
+
+        For a cubic material (e.g. copper):
+
+        >>> C = StiffnessTensor.cubic(C11=186, C12=134, C44=77)
+        >>> G = C.shear_modulus
+        >>> G
+        Hyperspherical function
+        Min=26.000000000000007, Max=77.00000000000001
+
+        In details, the Poisson ratio between [1,0,0] and [0,1,0] directions is:
+
+        >>> print(G.eval([1,0,0],[0,1,0]))
+        77.0
+
+        whereas:
+
+        >>> print(G.eval([1,1,0],[-1,1,0]))
+        26.000000000000007
         """
         if isinstance(self, ComplianceTensor):
             S = self
@@ -756,6 +784,34 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
             \\nu_{ij}=-\\frac{\\partial \\varepsilon_{jj}}{\\partial \\varepsilon_{ii}}
 
         where :math:`\\varepsilon_{jj}` denotes the (compressive) longitudinal strain along the j-th direction.
+
+        Examples
+        --------
+        Let's compute the Poisson ratio of an isotropic material, defined by its Young and shear moduli:
+
+        >>> from elasticipy.tensors.elasticity import StiffnessTensor
+        >>> C = StiffnessTensor.isotropic(E=210, G=83)
+        >>> C.Poisson_ratio
+        Hyperspherical function
+        Min=0.2650602409638549, Max=0.2650602409638558
+
+        For a cubic material (e.g. copper):
+
+        >>> C = StiffnessTensor.cubic(C11=186, C12=134, C44=77)
+        >>> nu = C.Poisson_ratio
+        >>> nu
+        Hyperspherical function
+        Min=-0.09637908596800088, Max=0.789864502792421
+
+        In details, the Poisson ratio between [1,0,0] and [0,1,0] directions is:
+
+        >>> print(nu.eval([1,0,0],[0,1,0]))
+        0.41875000000000007
+
+        whereas:
+
+        >>> print(nu.eval([1,1,0],[-1,1,0]))
+        -0.09637908596800099
         """
         if isinstance(self, ComplianceTensor):
             Sfull = self.full_tensor
@@ -850,7 +906,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         else:
             return np.nan
 
-    def Voigt_average(self, axis=None):
+    def Voigt_average(self, axis=None, orientations=None):
         """
         Compute the Voigt average (from the mean of stiffness tensors).
 
@@ -861,6 +917,9 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         ----------
         axis : int, optional
             If provided, the average is computed along this axis. Otherwise, the mean is computed on the flattened array.
+        orientations : scipy.spatial.transform.Rotation or orix.quaternion.orientation.Orientation or crystal_texture.CrystalTexture or crystal_texture.CompositeTexture, optional
+            Orientation to use to compute the average. If the object is a single tensor, all the rotated tensor will be
+            computed accordingly, before computing the mean.
 
         Returns
         -------
@@ -909,6 +968,23 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
 
         >>> 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]]
+
+        A shorter way to do that is to pass the rotations to the function:
+
+        >>> C.Voigt_average(orientations=g)
+        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
@@ -924,10 +1000,16 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         """
         if self.ndim:
             return self.mean(axis=axis)
-        else:
+        elif orientations is None:
             return self.infinite_random_average()
+        else:
+            C_rotated = self * orientations
+            if C_rotated.ndim:
+                return C_rotated.Voigt_average()
+            else:
+                return C_rotated
 
-    def Reuss_average(self, axis=None):
+    def Reuss_average(self, axis=None, orientations=None):
         """
         Compute the Reuss average (from the mean of compliance tensors).
 
@@ -938,6 +1020,9 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         ----------
         axis : int, optional
             If provided, axis to compute the average along with. If none, the average is computed on the flattened array
+        orientations : scipy.spatial.transform.Rotation or orix.quaternion.orientation.Orientation or crystal_texture.CrystalTexture or crystal_texture.CompositeTexture, optional
+            Orientation to use to compute the average. If the object is a single tensor, all the rotated tensor will be
+            computed accordingly, before computing the mean.
 
         Returns
         -------
@@ -1004,10 +1089,27 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
            7.70000000e+01 -7.54674101e-17]
          [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
            7.54674101e-17  7.70000000e+01]]
+
+        A shorter way to do that is to pass the rotations to the function:
+
+        >>> C.Reuss_average(orientations=g)
+        Stiffness tensor (in Voigt mapping):
+        [[ 1.86000000e+02  1.34000000e+02  1.34000000e+02  7.28375071e-16
+           0.00000000e+00  0.00000000e+00]
+         [ 1.34000000e+02  1.98854548e+02  1.21145452e+02 -1.02540555e-15
+           0.00000000e+00  0.00000000e+00]
+         [ 1.34000000e+02  1.21145452e+02  1.98854548e+02 -1.02540555e-15
+           0.00000000e+00  0.00000000e+00]
+         [ 1.05096715e-14  1.06717815e-14  1.06717815e-14  3.88930441e+01
+           0.00000000e+00  0.00000000e+00]
+         [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
+           7.70000000e+01  1.07632754e-16]
+         [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
+          -1.07632754e-16  7.70000000e+01]]
         """
-        return self.inv().Reuss_average(axis=axis).inv()
+        return self.inv().Reuss_average(axis=axis, orientations=orientations).inv()
 
-    def Hill_average(self, axis=None):
+    def Hill_average(self, axis=None, orientations=None):
         """
         Compute the Voigt-Reuss-Hill average (mean of Voigt and Reuss averages for stiffness tensors).
 
@@ -1018,6 +1120,9 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         ----------
         axis : int, optional
             If provided, axis to compute the average along with. If none, the average is computed on the flattened array
+        orientations : scipy.spatial.transform.Rotation or orix.quaternion.orientation.Orientation or crystal_texture.CrystalTexture or crystal_texture.CompositeTexture, optional
+            Orientation to use to compute the average. If the object is a single tensor, all the rotated tensor will be
+            computed accordingly, before computing the mean.
 
         Returns
         -------
@@ -1084,12 +1189,29 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
            7.70000000e+01 -7.54674101e-17]
          [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
            7.54674101e-17  7.70000000e+01]]
+
+        A shorter way to do that is to pass the rotations to the function:
+
+        >>> C.Hill_average(orientations=g)
+        Stiffness tensor (in Voigt mapping):
+        [[ 1.86000000e+02  1.34000000e+02  1.34000000e+02  3.42205120e-16
+           0.00000000e+00  0.00000000e+00]
+         [ 1.34000000e+02  2.05164524e+02  1.14835476e+02 -5.12702777e-16
+           0.00000000e+00  0.00000000e+00]
+         [ 1.34000000e+02  1.14835476e+02  2.05164524e+02 -5.12702777e-16
+           0.00000000e+00  0.00000000e+00]
+         [ 5.25483573e-15  5.33589076e-15  5.33589076e-15  4.52092721e+01
+           0.00000000e+00  0.00000000e+00]
+         [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
+           7.70000000e+01  1.60826722e-17]
+         [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
+          -1.60826722e-17  7.70000000e+01]]
         """
-        Reuss = self.Reuss_average(axis=axis)
-        Voigt = self.Voigt_average(axis=axis)
+        Reuss = self.Reuss_average(axis=axis, orientations=orientations)
+        Voigt = self.Voigt_average(axis=axis, orientations=orientations)
         return (Reuss + Voigt) * 0.5
 
-    def average(self, method, axis=None):
+    def average(self, method, axis=None, orientations=None):
         """
         Compute either the Voigt, Reuss, or Hill average of the stiffness tensor.
 
@@ -1101,6 +1223,9 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
             If provided, axis to compute the average along with. If none, the average is computed on the flattened array
         method : str {'Voigt', 'Reuss', 'Hill'}
             Method to use to compute the average.
+        orientations : scipy.spatial.transform.Rotation or orix.quaternion.orientation.Orientation or crystal_texture.CrystalTexture or crystal_texture.CompositeTexture, optional
+            Orientation to use to compute the average. If the object is a single tensor, all the rotated tensor will be
+            computed accordingly, before computing the mean.
 
         Returns
         -------
@@ -1115,9 +1240,9 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         method = method.capitalize()
         if method in ('Voigt', 'Reuss', 'Hill'):
             fun = getattr(self, method + '_average')
-            return fun(axis=axis)
+            return fun(axis=axis, orientations=orientations)
         else:
-            raise NotImplementedError('Only Voigt, Reus, and Hill are implemented.')
+            raise NotImplementedError('Only Voigt, Reuss, and Hill are implemented.')
 
     @classmethod
     def isotropic(cls, E=None, nu=None, G=None, lame1=None, lame2=None, K=None, phase_name=None):
@@ -1612,7 +1737,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         --------
         >>> from elasticipy.tensors.elasticity import StiffnessTensor
         >>> C = StiffnessTensor.cubic(C11=200, C12=40, C44=20)
-        >>> C.Zener_ratio()
+        >>> print(C.Zener_ratio())
         0.25
 
         which obvisouly corresponds to 2.C44/(C11-C12).
@@ -1959,7 +2084,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
 
         Once rotated, it is not clear if the stiffness tensors has cubic symmetry on sight. Yet:
 
-        >>> C_rotated.is_cubic()
+        >>> print(C_rotated.is_cubic())
         True
 
         """
@@ -2141,17 +2266,23 @@ class ComplianceTensor(StiffnessTensor):
         t.mapping = self.mapping.mapping_inverse
         return t
 
-    def Reuss_average(self, axis=None):
+    def Reuss_average(self, axis=None, orientations=None):
         if self.ndim:
             return self.mean(axis=axis)
-        else:
+        elif orientations is None:
             return self.infinite_random_average()
+        else:
+            C_rotated = self * orientations
+            if C_rotated.ndim:
+                return C_rotated.Reuss_average()
+            else:
+                return C_rotated
 
-    def Voigt_average(self, axis=None):
-        return self.inv().Voigt_average(axis=axis).inv()
+    def Voigt_average(self, axis=None, orientations=None):
+        return self.inv().Voigt_average(axis=axis, orientations=orientations).inv()
 
-    def Hill_average(self, axis=None):
-        return self.inv().Hill_average(axis=axis).inv()
+    def Hill_average(self, axis=None, orientations=None):
+        return self.inv().Hill_average(axis=axis, orientations=orientations).inv()
 
     @classmethod
     def isotropic(cls, E=None, nu=None, G=None, lame1=None, lame2=None, K=None, phase_name=None):

elasticipy/tensors/fourth_order.py

@@ -143,12 +143,12 @@ class FourthOrderTensor:
 
         For instance:
 
-        >>> T_array[0,0,0,0]
+        >>> print(T_array[0,0,0,0])
         100.0
 
         whereas
 
-        >>> T_array[0,1,0,1] # Corresponds to T_{66}/2
+        >>> print(T_array[0,1,0,1]) # Corresponds to T_{66}/2
         75.0
 
         The half factor comes from the Kelvin mapping convention (see Notes). One can also use the Voigt mapping to
@@ -168,17 +168,17 @@ class FourthOrderTensor:
         Although T and T_voigt appear to be the same, note that they are not expressed using the same mapping
         convention. Indeed:
 
-        >>> T_voigt.full_tensor[0,0,0,0]
+        >>> print(T_voigt.full_tensor[0,0,0,0])
         100.0
 
         whereas
 
-        >>> T_voigt.full_tensor[0,1,0,1]
+        >>> print(T_voigt.full_tensor[0,1,0,1])
         150.0
 
         Alternatively, the differences can be checked with:
 
-        >>> T == T_voigt
+        >>> print(T == T_voigt)
         False
 
         Conversely, let consider the following Voigt matrix:
@@ -201,12 +201,12 @@ class FourthOrderTensor:
 
         Although T and T_voigt2 are not written using the same mapping, we can compare them:
 
-        >>> T == T_voigt2 # Same tensors, but different mapping
+        >>> print(T == T_voigt2) # Same tensors, but different mapping
         True
 
         whereas
 
-        >>> T == T_voigt  # Different tensors, but same mapping
+        >>> print(T == T_voigt)  # Different tensors, but same mapping
         False
 
         This property comes from the fact that the comparison is made independently of the underlying mapping convention.
@@ -643,10 +643,12 @@ class FourthOrderTensor:
                 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:
+        elif isinstance(other, (float, int)):
             new_tensor = deepcopy(self)
             new_tensor._matrix = self._matrix * other
             return new_tensor
+        else:
+            return NotImplemented
 
     def __truediv__(self, other):
         if isinstance(other, (SecondOrderTensor, FourthOrderTensor)):
@@ -811,7 +813,7 @@ class FourthOrderTensor:
 
         Still, we have:
 
-        >>> I == Iv
+        >>> print(I == Iv)
         True
 
         as they correspond to the same tensor, but expressed as a matrix with different mapping conventions. Indeed,
@@ -855,7 +857,7 @@ class FourthOrderTensor:
         mapping convention. Indeed, one can check that the full tensor is actually full of ones. E.g.:
 
         >>> tensor_of_ones.full_tensor[0,1,0,2]
-        1.0
+        np.float64(1.0)
 
         Alternatively, the Voigt mapping convention may help figuring it out:
 
@@ -872,7 +874,7 @@ class FourthOrderTensor:
 
         although both tensors are actually the same:
 
-        >>> tensor_of_ones == tensor_of_ones_voigt
+        >>> print(tensor_of_ones == tensor_of_ones_voigt)
         True
         """
         return cls._broadcast_matrix(kelvin_mapping.matrix, shape=shape, **kwargs)
@@ -1239,6 +1241,25 @@ class FourthOrderTensor:
         a = deepcopy(self)
         return a
 
+    def tensor_average(self, weights=None, axis=0):
+        """
+        Compute the average of a tensor array.
+
+        Parameters
+        ----------
+        weights : list of float or tuple of floats, optional
+            If provided, each tensor value is weighted accordingly
+        axis : int, optional
+            Axis to compute the average over (default: 0)
+
+        Returns
+        -------
+        FourthOrderTensor
+        """
+        t = deepcopy(self)
+        t._matrix = np.average(t._matrix, weights=weights, axis=axis)
+        return t
+
 class SymmetricFourthOrderTensor(FourthOrderTensor):
     _tensor_name = 'Symmetric 4th-order'