elasticipy 2.8.10__tar.gz → 3.0.0__tar.gz

{elasticipy-2.8.10 → elasticipy-3.0.0}/Examples/Example_Stiffness_tensor.py

@@ -22,7 +22,7 @@ E.plot_as_pole_figure()     # or even with PF
 print(E.max())
 
 # Apply a random rotation on stiffness tensor
-rotation = Rotation.from_euler('zxz', [0, 45, 0], degrees=True)
+rotation = Rotation.from_euler('ZXZ', [90, 45, 0], degrees=True)
 Crot = C*rotation
 # Check that the Young modulus has changed as well
 Crot.Young_modulus.plot3D()

elasticipy-3.0.0/Examples/essai_plasticity.py

@@ -0,0 +1,73 @@
+from Elasticipy.Plasticity import JohnsonCook
+from Elasticipy.StressStrainTensors import StressTensor, StrainTensor
+from Elasticipy.FourthOrderTensor import StiffnessTensor
+import numpy as np
+from matplotlib import pyplot as plt
+import matplotlib as mpl
+mpl.use('Qt5Agg')   # Ensure interactive plot
+
+
+JC = JohnsonCook(A=363, B=792.7122, n=0.5756) # https://doi.org/10.1016/j.matpr.2020.05.213
+C = StiffnessTensor.isotropic(E=210000, nu=0.27)
+
+n_step = 100
+sigma_max = 725
+stress_mag = np.linspace(0, sigma_max, n_step)
+stress = StressTensor.shear([1,0,0], [0,1,0],stress_mag)
+
+elastic_strain = C.inv() * stress
+plastic_strain = StrainTensor.zeros(n_step)
+for i in range(2, n_step):
+    strain_increment = JC.compute_strain_increment(stress[i])
+    plastic_strain[i] = plastic_strain[i-1] + strain_increment
+
+
+eps_xx = elastic_strain.C[0,1]+plastic_strain.C[0,1]
+fig, ax = plt.subplots()
+ax.plot(eps_xx, stress_mag, label='Stress-controlled')
+ax.set_xlabel(r'$\varepsilon_{xy}$')
+ax.set_ylabel('Shear stress (MPa)')
+
+##
+from scipy.optimize import minimize_scalar
+stress = StressTensor.zeros(n_step)
+plastic_strain = StrainTensor.zeros(n_step)
+JC.reset_strain()
+for i in range(2, n_step):
+    def fun(tensile_stress):
+        trial_stress = StressTensor.shear([1,0,0], [0,1,0], tensile_stress)
+        trial_elastic_strain = C.inv() * trial_stress
+        trial_strain_increment = JC.compute_strain_increment(trial_stress, apply_strain=False)
+        trial_plastic_strain = plastic_strain[i - 1] + trial_strain_increment
+        trial_elongation =  trial_plastic_strain.C[0,1] +  trial_elastic_strain.C[0,1]
+        return (trial_elongation - eps_xx[i])**2
+    s = minimize_scalar(fun)
+    s0 = s.x
+    stress.C[0,1][i] = s0
+    strain_increment = JC.compute_strain_increment(stress[i])
+    plastic_strain[i] = plastic_strain[i-1] + strain_increment
+
+ax.plot(eps_xx, stress.C[0,1], label='Strain-controlled', linestyle='dotted')
+ax.legend()
+
+
+#
+JC.reset_strain()
+JC_tresca = JohnsonCook(A=363, B=792.7122, n=0.5756, criterion='Tresca')
+stress_mag = np.linspace(0, 500, n_step)
+stress = StressTensor.shear([1,0,0], [0,1,0],stress_mag)
+models = (JC, JC_tresca)
+labels = ('von Mises', 'Tresca')
+
+elastic_strain = C.inv() * stress
+fig, ax = plt.subplots()
+for j, model in enumerate(models):
+    plastic_strain = StrainTensor.zeros(n_step)
+    for i in range(2, n_step):
+        strain_increment = model.compute_strain_increment(stress[i])
+        plastic_strain[i] = plastic_strain[i-1] + strain_increment
+    eps_xy = elastic_strain.C[0,1]+plastic_strain.C[0,1]
+    ax.plot(eps_xy, stress_mag, label=labels[j])
+ax.set_xlabel(r'$\varepsilon_{xy}$')
+ax.set_ylabel('Shear stress (MPa)')
+ax.legend()

{elasticipy-2.8.10 → elasticipy-3.0.0}/JOSS/paper.bib

@@ -6,6 +6,7 @@ pages = {314-319},
 year = {2013},
 issn = {0927-0256},
 url = {https://doi.org/10.1016/j.commatsci.2012.10.028},
+doi = {10.1016/j.commatsci.2012.10.028},
 author = {Shyue Ping Ong and William Davidson Richards and Anubhav Jain and Geoffroy Hautier and Michael Kocher and Shreyas Cholia and Dan Gunter and Vincent L. Chevrier and Kristin A. Persson and Gerbrand Ceder},
 keywords = {Materials, Project, Design, Thermodynamics, High-throughput},
 }
@@ -33,7 +34,8 @@ journal = {Journal of Physics: Condensed Matter},
   pages={175--192},
   year={2011},
   publisher={The Geological Society of London London},
-  url={http://dx.doi.org/10.1144/SP360.10}
+  url={http://dx.doi.org/10.1144/SP360.10},
+  doi={10.1144/SP360.10}
 }
 
 @book{nye,
@@ -124,4 +126,4 @@ DOI = {10.5194/se-11-259-2020}
  doi           = {10.1038/s41586-020-2649-2},
  publisher     = {Springer Science and Business Media {LLC}},
  url           = {https://doi.org/10.1038/s41586-020-2649-2}
-}
+}

{elasticipy-2.8.10/src/elasticipy.egg-info → elasticipy-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: elasticipy
-Version: 2.8.10
+Version: 3.0.0
 Summary: A Python library for elasticity tensor computations
 Author-email: Dorian Depriester <dorian.dep@gmail.com>
 License: MIT
@@ -36,6 +36,7 @@ Requires-Dist: mp_api; extra == "dev"
 [![DOI](https://zenodo.org/badge/876162900.svg)](https://doi.org/10.5281/zenodo.14501849)
 [![codecov](https://codecov.io/gh/DorianDepriester/Elasticipy/graph/badge.svg?token=VUZPEUPBH1)](https://codecov.io/gh/DorianDepriester/Elasticipy)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/Elasticipy)
+[![status](https://joss.theoj.org/papers/8cce91b782f17f52e9ee30916cd86ad5/status.svg)](https://joss.theoj.org/papers/8cce91b782f17f52e9ee30916cd86ad5)
 
 
 

{elasticipy-2.8.10 → elasticipy-3.0.0}/README.md

@@ -6,6 +6,7 @@
 [![DOI](https://zenodo.org/badge/876162900.svg)](https://doi.org/10.5281/zenodo.14501849)
 [![codecov](https://codecov.io/gh/DorianDepriester/Elasticipy/graph/badge.svg?token=VUZPEUPBH1)](https://codecov.io/gh/DorianDepriester/Elasticipy)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/Elasticipy)
+[![status](https://joss.theoj.org/papers/8cce91b782f17f52e9ee30916cd86ad5/status.svg)](https://joss.theoj.org/papers/8cce91b782f17f52e9ee30916cd86ad5)
 
 
 

elasticipy-3.0.0/docs/source/Tutorials/Plasticity.rst

@@ -0,0 +1,187 @@
+Plasticity
+----------
+Although Elasticipy was not initially meant to work on plasticity (hence the name...), it provides some clues about
+simulations of elasto-plastic behaviour of materials. This tutorial shows how one can simulate a tensile test in the
+elasto-plastic domain of a material.
+
+The Johnson-Cook model
+======================
+The Johnson-Cook (JC) model is widely used in the literature for modeling isotropic hardening of metalic materials.
+Therefore, it is available out-of-the-box in Elasticipy. It assumes that the flow stress (:math:`\sigma`) depends on the
+equivalent strain (:math:`\varepsilon`), the strain rate (:math:`\dot{\varepsilon}`) and the temperature (:math:`T`),
+according to the following equation:
+
+.. math::
+
+        \sigma = \left(A + B\varepsilon^n\right)
+                \left[1 + C\log\left(\frac{\varepsilon}{\dot{\varepsilon}_0}\right)\right]
+                \left(1-\theta^m\right)
+
+with
+
+.. math::
+
+        \theta = \begin{cases}
+                    \frac{T-T_0}{T_m-T_0} & \text{if } T<T_m\\\\
+                    1                      & \text{otherwise}
+                    \end{cases}
+
+
+:math:`A`, :math:`B`, :math:`C`, :math:`\dot{\varepsilon}_0`, :math:`T_0`, :math:`T_m` and :math:`m` are parameters
+whose values depend on the material.
+
+Simulation of a stress-controlled tensile test
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+At first, we will try to simulate a stress-controlled tensile test. Although this approach is quite uncommon, we will do
+this anyway, just because it is easier to program.
+
+First, let us create the model:
+
+.. doctest::
+
+    >>> from Elasticipy.Plasticity import JohnsonCook
+    >>> JC = JohnsonCook(A=363, B=792.7122, n=0.5756)
+
+The parameters are taken from [1]_. As we will also take elastic behaviour into account, we also need:
+
+    >>> from Elasticipy.FourthOrderTensor import StiffnessTensor
+    >>> C = StiffnessTensor.isotropic(E=210000, nu=0.27)
+
+Now, let say that we want to investigate the material's response for the tensile stress ranging from 0 to 725 MPa:
+
+    >>> from Elasticipy.StressStrainTensors import StressTensor, StrainTensor
+    >>> import numpy as np
+    >>> n_step = 100
+    >>> stress_mag = np.linspace(0, 725, n_step)
+    >>> stress = StressTensor.tensile([1,0,0], stress_mag)
+
+At least, we can directly compute the elastic strain for each step:
+
+    >>> elastic_strain = C.inv() * stress
+
+So now, the plastic strain can be computed using an iterative approach:
+
+    >>> plastic_strain = StrainTensor.zeros(n_step)
+    >>> for i in range(1, n_step):
+    ...       strain_increment = JC.compute_strain_increment(stress[i])
+    ...       plastic_strain[i] = plastic_strain[i-1] + strain_increment
+
+That's all. Finally, let us plot the applied stress as a function of the overall elongation:
+
+    >>> from matplotlib import pyplot as plt
+    >>> elong = elastic_strain.C[0,0]+plastic_strain.C[0,0]
+    >>> fig, ax = plt.subplots()
+    >>> ax.plot(elong, stress_mag, label='Stress-controlled') # doctest: +SKIP
+    >>> ax.set_xlabel(r'$\varepsilon_{xx}$') # doctest: +SKIP
+    >>> ax.set_ylabel('Tensile stress (MPa)') # doctest: +SKIP
+
+.. image:: images/Stress-controlled.png
+
+
+Simulation of a strain-controlled tensile test
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The difficulty of simulating a strain-controlled tensile test is that, at a given step, one must identify both the
+elastic and the plastic strain (if any) at once, while ensuring that the stress keeps uniaxial. Therefore, the hack is
+to add a subroutine (optimization loop) to find the tensile stress so that the associated strain complies with the applied strain:
+
+    >>> from scipy.optimize import minimize_scalar
+    >>> JC.reset_strain() # Ensure that the previous hardening does not count
+    >>> stress = StressTensor.zeros(n_step)
+    >>> plastic_strain = StrainTensor.zeros(n_step)
+    >>> JC.reset_strain()
+    >>> for i in range(1, n_step):
+    ...        def fun(tensile_stress):
+    ...            trial_stress = StressTensor.tensile([1,0,0], tensile_stress)
+    ...            trial_elastic_strain = C.inv() * trial_stress
+    ...            trial_strain_increment = JC.compute_strain_increment(trial_stress, apply_strain=False)
+    ...            trial_plastic_strain = plastic_strain[i - 1] + trial_strain_increment
+    ...            trial_elongation =  trial_plastic_strain.C[0,0] +  trial_elastic_strain.C[0,0]
+    ...            return (trial_elongation - elong[i])**2
+    ...        s = minimize_scalar(fun)
+    ...        stress.C[0,0][i] = s.x
+    ...        strain_increment = JC.compute_strain_increment(stress[i])
+    ...        plastic_strain[i] = plastic_strain[i-1] + strain_increment
+
+Finally, let's plot the corresponding tensile curve ontop of that of the stress-controlled tensile test:
+
+    >>> ax.plot(elong, stress.C[0,0], label='Strain-controlled', linestyle='dotted') # doctest: +SKIP
+    >>> ax.legend() # doctest: +SKIP
+
+.. image:: images/StressStrain-controlled.png
+
+
+Incremental loading
+===================
+Here, we have only considered monotonic loading, but we can also consider different loading path, such as incremental:
+
+    >>> load_path = [np.linspace(0,0.1),
+    ...              np.linspace(0.1,0.099),
+    ...              np.linspace(0.099,0.2),
+    ...              np.linspace(0.2,0.199),
+    ...              np.linspace(0.199,0.3)]
+    >>> elong = np.concatenate(load_path)
+    >>> n_step = len(elong)
+
+.. image:: images/Incremental.png
+
+or cyclic:
+
+
+    >>> load_path = [np.linspace(0,0.1),
+    ...              np.linspace(0.1,-0.2),
+    ...              np.linspace(-0.2,0.3),
+    ...              np.linspace(0.3,-0.4)]
+    >>> elong = np.concatenate(load_path)
+    >>> n_step = len(elong)
+
+.. image:: images/Cyclic.png
+
+.. note::
+
+    The figure above clearly evidences the isotropic hardening inherent to the JC model.
+
+
+Complex loading path
+====================
+In the example above, we have only studied longitudinal stress/strain. Still, it is worth mentioning that other stress
+states can be investigated (e.g. shear, multiaxial etc.) thanks to the
+`normality rule <https://www.doitpoms.ac.uk/tlplib/granular_materials/normal.php>`_.
+
+Tresca's plasticity criterion
+=============================
+Above, we have used the von Mises plasticity criterion (a.k.a J2 criterion). This can be switched to Tresca by passing
+the plasticity criterion to the model constructor:
+
+    >>> JC = JohnsonCook(A=363, B=792.7122, n=0.5756, criterion='Tresca')
+
+For instance, one can highlight the difference between the J2 and Tresca plasticity in shear:
+
+    >>> JC.reset_strain()
+    >>> JC_tresca = JohnsonCook(A=363, B=792.7122, n=0.5756, criterion='Tresca')
+    >>> stress_mag = np.linspace(0, 500, n_step)
+    >>> stress = StressTensor.shear([1,0,0], [0,1,0],stress_mag)
+    >>> models = (JC, JC_tresca)
+    >>> labels = ('von Mises', 'Tresca')
+    >>>
+    >>> elastic_strain = C.inv() * stress
+    >>> fig, ax = plt.subplots()
+    >>> for j, model in enumerate(models):
+        ... plastic_strain = StrainTensor.zeros(n_step)
+        ... for i in range(1, n_step):
+        ...     strain_increment = model.compute_strain_increment(stress[i])
+        ...     plastic_strain[i] = plastic_strain[i-1] + strain_increment
+        ... eps_xy = elastic_strain.C[0,1]+plastic_strain.C[0,1]
+        ... ax.plot(eps_xy, stress_mag, label=labels[j])
+    >>> ax.set_xlabel(r'$\varepsilon_{xy}$') # doctest: +SKIP
+    >>> ax.set_ylabel('Shear stress (MPa)') # doctest: +SKIP
+    >>> ax.legend() # doctest: +SKIP
+
+
+.. image:: images/Shear.png
+
+
+
+.. [1]  Sandeep Yadav, Sorabh Singhal, Yogeshwar Jasra, Ravindra K. Saxena,
+        Determination of Johnson-Cook material model for weldment of mild steel,
+        Materials Today: Proceedings, Volume 28, Part 3, 2020, Pages 1801-1808, ISSN 2214-7853,
+        https://doi.org/10.1016/j.matpr.2020.05.213.

{elasticipy-2.8.10 → elasticipy-3.0.0}/docs/source/Tutorials/Tutorial_StiffnessTensor.rst

@@ -55,7 +55,7 @@ deviation of the Young modulus:
 Another way to evidence anisotropy is to use the universal anisotropy factor [1]_:
 
     >>> C.universal_anisotropy
-    5.14100955164141
+    5.1410095516414085
 
 Shear moduli and Poisson ratios
 -------------------------------

elasticipy-3.0.0/docs/source/Tutorials/Tutorial_StressStrain.rst

@@ -0,0 +1,231 @@
+Stress and strain tensors
+=========================
+
+This tutorial illustrates how we work on strain and stress tensors, and how Elasticipy handles arrays of tensors.
+
+Single tensors
+--------------
+Let's start with basic operations with the stress tensor. For instance, we can compute the von Mises and Tresca
+equivalent stresses:
+
+
+.. doctest::
+
+    >>> from Elasticipy.StressStrainTensors import StressTensor, StrainTensor
+            >>> stress = StressTensor.shear([1, 0, 0], [0, 1, 0], 1.0) # Unit XY shear stress
+            >>> print(stress.vonMises(), stress.Tresca())
+            1.7320508075688772 2.0
+
+So now, let's have a look on the strain tensor, and compute the principal strains and the volumetric change:
+
+    >>> strain = StrainTensor.shear([1,0,0], [0,1,0], 1e-3) # XY Shear strain with 1e-3 mag.
+    >>> print(strain.principal_strains())
+    [ 0.001  0.    -0.001]
+    >>> print(strain.volumetric_strain())
+    0.0
+    >>> stress = StressTensor.shear([1, 0, 0], [0, 1, 0], 1.0) # Unit XY shear stress
+    >>> print(stress.vonMises(), stress.Tresca())
+    1.7320508075688772 2.0
+
+Linear elasticity
+--------------------------------
+This section is dedicated to linear elasticity, hence introducing the fourth-order stiffness tensor.
+As an example, create a stiffness tensor corresponding to steel:
+
+    >>> from Elasticipy.FourthOrderTensor import StiffnessTensor
+    >>> C = StiffnessTensor.isotropic(E=210e3, nu=0.28)
+    >>> print(C)
+    Stiffness tensor (in Voigt notation):
+    [[268465.90909091 104403.40909091 104403.40909091      0.
+           0.              0.        ]
+     [104403.40909091 268465.90909091 104403.40909091      0.
+           0.              0.        ]
+     [104403.40909091 104403.40909091 268465.90909091      0.
+           0.              0.        ]
+     [     0.              0.              0.          82031.25
+           0.              0.        ]
+     [     0.              0.              0.              0.
+       82031.25            0.        ]
+     [     0.              0.              0.              0.
+           0.          82031.25      ]]
+    Symmetry: isotropic
+
+
+Considering the previous strain, evaluate the corresponding stress:
+
+    >>> sigma = C * strain
+    >>> print(sigma)
+    Stress tensor
+    [[  0.     164.0625   0.    ]
+     [164.0625   0.       0.    ]
+     [  0.       0.       0.    ]]
+
+Conversely, one can compute the compliance tensor:
+
+    >>> S = C.inv()
+    >>> print(S)
+    Compliance tensor (in Voigt notation):
+    [[ 4.76190476e-06 -1.33333333e-06 -1.33333333e-06  0.00000000e+00
+       0.00000000e+00  0.00000000e+00]
+     [-1.33333333e-06  4.76190476e-06 -1.33333333e-06  0.00000000e+00
+       0.00000000e+00  0.00000000e+00]
+     [-1.33333333e-06 -1.33333333e-06  4.76190476e-06  0.00000000e+00
+       0.00000000e+00  0.00000000e+00]
+     [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  1.21904762e-05
+       0.00000000e+00  0.00000000e+00]
+     [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
+       1.21904762e-05  0.00000000e+00]
+     [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
+       0.00000000e+00  1.21904762e-05]]
+    Symmetry: isotropic
+
+and check that we retrieve the correct (initial) strain:
+
+    >>> print(S * sigma)
+    Strain tensor
+    [[0.    0.001 0.   ]
+     [0.001 0.    0.   ]
+     [0.    0.    0.   ]]
+
+.. _multidimensional-arrays:
+
+Multidimensional tensor arrays
+------------------------------
+Elasticipy allows to process thousands of tensors at one, with the aid of tensor arrays.
+As an illustration, we consider the anisotropic behaviour of ferrite:
+
+    >>> C = StiffnessTensor.fromCrystalSymmetry(symmetry='cubic', phase_name='ferrite',
+    ...                                         C11=274, C12=175, C44=89)
+    >>> print(C)
+    Stiffness tensor (in Voigt notation) for ferrite:
+    [[274. 175. 175.   0.   0.   0.]
+     [175. 274. 175.   0.   0.   0.]
+     [175. 175. 274.   0.   0.   0.]
+     [  0.   0.   0.  89.   0.   0.]
+     [  0.   0.   0.   0.  89.   0.]
+     [  0.   0.   0.   0.   0.  89.]]
+    Symmetry: cubic
+
+Let's start by creating an array of 10 stresses:
+
+    >>> import numpy as np
+    >>> n_array = 10
+    >>> shear_stress = np.linspace(0, 100, n_array)
+    >>> sigma = StressTensor.shear([1,0,0],[0,1,0], shear_stress)  # Array of stresses corresponding to X-Y shear
+    >>> print(sigma[0])     # Check the initial value of the stress...
+    Stress tensor
+    [[0. 0. 0.]
+     [0. 0. 0.]
+     [0. 0. 0.]]
+    >>> print(sigma[-1])    # ...and the final value.
+    Stress tensor
+    [[  0. 100.   0.]
+     [100.   0.   0.]
+     [  0.   0.   0.]]
+
+The corresponding strain array is evaluated with the same syntax as before:
+
+    >>> eps = C.inv() * sigma
+    >>> print(eps[0])     # Now check the initial value of strain...
+    Strain tensor
+    [[0. 0. 0.]
+     [0. 0. 0.]
+     [0. 0. 0.]]
+    >>> print(eps[-1])    # ...and the final value.
+    Strain tensor
+    [[0.         0.56179775 0.        ]
+     [0.56179775 0.         0.        ]
+     [0.         0.         0.        ]]
+
+We can for instance compute the corresponding elastic energies:
+
+    >>> print(eps.elastic_energy(sigma))
+    [ 0.          0.69357747  2.77430989  6.24219725 11.09723956 17.33943682
+     24.96878901 33.98529616 44.38895825 56.17977528]
+
+Another application of working with an array of stress tensors is to check whether a tensor field complies with the
+balance of linear momentum (see `here <https://en.wikiversity.org/wiki/Continuum_mechanics/Balance_of_linear_momentum>`_
+for details) or not. For instance, if we want to compute the divergence of ``sigma``:
+
+    >>> sigma.div()
+    array([[ 0.        , 11.11111111,  0.        ],
+           [ 0.        , 11.11111111,  0.        ],
+           [ 0.        , 11.11111111,  0.        ],
+           [ 0.        , 11.11111111,  0.        ],
+           [ 0.        , 11.11111111,  0.        ],
+           [ 0.        , 11.11111111,  0.        ],
+           [ 0.        , 11.11111111,  0.        ],
+           [ 0.        , 11.11111111,  0.        ],
+           [ 0.        , 11.11111111,  0.        ],
+           [ 0.        , 11.11111111,  0.        ]])
+
+Here, the *i*-th row provides the divergence vector for the *i*-th stress tensor.
+See `the full documentation <../Elasticipy.SecondOrderTensor.html#Elasticipy.SecondOrderTensor.SecondOrderTensor.div>`_ for
+details about this function.
+
+.. _strain_rotations:
+
+Apply rotations
+---------------
+Rotations can be applied on the tensors. If multiple rotations are applied at once, this results in tensor arrays.
+Rotations are defined by ``scipy.transform.Rotation``
+(see `here <https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.transform.Rotation.html>`__ for details).
+
+    >>> from scipy.spatial.transform import Rotation
+
+For example, let's consider a random set of 1000 rotations:
+
+    >>> n_ori = 1000
+    >>> random_state = 1234 # This is just to ensure reproducibility
+    >>> rotations = Rotation.random(n_ori, random_state=random_state)
+
+These rotations can be applied on the strain tensor
+
+    >>> eps_rotated = eps.rotate(rotations, mode='cross')
+
+
+Option ``mode='cross'`` allows to compute all combinations of strains and rotation, resulting in a kind of 2D matrix of
+strain tensors:
+
+    >>> print(eps_rotated.shape)
+    (10, 1000)
+
+Therefore, we can compute the corresponding rotated stress array:
+
+    >>> sigma_rotated = C * eps_rotated
+    >>> print(sigma_rotated.shape)    # Check out the shape of the stresses
+    (10, 1000)
+
+And get the stress back to the initial coordinate system:
+
+    >>> sigma = sigma_rotated * rotations.inv()   # Go back to initial frame
+
+As opposed to the ``rotate(..., mode='cross')`` (see above), we use ``*`` here to keep the same
+dimensionality (perform element-wise multiplication). It is equivalent to:
+
+    >>> sigma = sigma_rotated.rotate(rotations.inv())
+
+Finally, we can estimate the mean stresses among all the orientations:
+
+    >>> sigma_mean = sigma.mean(axis=1)     # Compute the mean over all orientations
+    >>> print(sigma_mean[-1]) # random
+    Stress tensor
+    [[ 5.35134832e-01  8.22419895e+01  2.02619662e-01]
+     [ 8.22419895e+01 -4.88440590e-01 -1.52733598e-01]
+     [ 2.02619662e-01 -1.52733598e-01 -4.66942413e-02]]
+
+Actually, a more straightforward method is to define a set of rotated stiffness tensors, and compute their Reuss average:
+
+    >>> C_rotated = C * rotations
+    >>> C_Voigt = C_rotated.Voigt_average()
+
+Which yields the same results in terms of stress:
+
+    >>> sigma_Voigt = C_Voigt * eps
+    >>> print(sigma_Voigt[-1])
+    Stress tensor
+    [[ 5.35134832e-01  8.22419895e+01  2.02619662e-01]
+     [ 8.22419895e+01 -4.88440590e-01 -1.52733598e-01]
+     [ 2.02619662e-01 -1.52733598e-01 -4.66942413e-02]]
+
+See :ref:`here<Averaging methods>` for further details about the averaging methods.

{elasticipy-2.8.10 → elasticipy-3.0.0}/docs/source/Tutorials/Tutorial_ThermalExpansion.rst

@@ -77,20 +77,24 @@ If we want to consider multiple orientations at once, we can create an array of
     Shape=(10000,)
 
 If we want to compute the strain for each combination of orientations and temperatures in ``[0,1,2]`` (as done above),
-we can use the ``matmul`` operator:
+we can use the ``apply_temperature()`` operator with ``mode='cross'``:
 
-    >>> eps = alpha_rotated.matmul([0,1,2])
+    >>> eps = alpha_rotated.apply_temperature([0,1,2], mode='cross')
     >>> print(eps)
     Strain tensor
     Shape=(10000, 3)
 
+.. note::
+
+    Above, we have used ``*``, which is just a shortcut for ``apply_temperature(...,mode='pair')``.
+
 For instance we can check out the maximum value for initial (0°) and final (2°) temperatures:
 
     >>> eps[:,0].max()    # 0 because it corresponds to 0°
     Strain tensor
-    [[ 0. -0. -0.]
-     [-0.  0. -0.]
-     [-0. -0.  0.]]
+    [[0. 0. 0.]
+     [0. 0. 0.]
+     [0. 0. 0.]]
     >>> eps[:,-1].max()
     Strain tensor
     [[1.12000000e-05 5.99947076e-06 5.99905095e-06]

{elasticipy-2.8.10 → elasticipy-3.0.0}/docs/source/Tutorials.rst

@@ -11,4 +11,5 @@ Tutorials
     ./Tutorials/Tutorial_ThermalExpansion.rst
     ./Tutorials/Tutorial_wave-velocities.rst
     ./Tutorials/Tutorial_MultiplePhases.rst
-    ./Tutorials/Tutorial_ReadWriteFiles.rst
+    ./Tutorials/Tutorial_ReadWriteFiles.rst
+    ./Tutorials/Plasticity.rst

{elasticipy-2.8.10 → elasticipy-3.0.0}/docs/source/index.rst

@@ -32,6 +32,10 @@ Welcome to Elasticipy's Documentation!
 .. image:: https://img.shields.io/pypi/pyversions/Elasticipy
    :alt: PyPI - Python Version
 
+.. image:: https://joss.theoj.org/papers/8cce91b782f17f52e9ee30916cd86ad5/status.svg
+   :alt: JOSS status
+   :target: https://joss.theoj.org/papers/8cce91b782f17f52e9ee30916cd86ad5
+
 
 
 Purpose of this package