elasticipy 4.0.0__tar.gz → 4.1.1__tar.gz

{elasticipy-4.0.0 → elasticipy-4.1.1}/.github/workflows/Codecov.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.10", "3.11", "3.12"]
+        python-version: ["3.11", "3.12"]
         
     steps:
       - name: Checkout

{elasticipy-4.0.0 → elasticipy-4.1.1}/.readthedocs.yaml

@@ -15,7 +15,7 @@ build:
     # golang: "1.20"
   jobs:
     post_create_environment:
-      - python -m pip install sphinx_rtd_theme mp_api
+      - python -m pip install sphinx_rtd_theme mp_api sphinx_copybutton
 
 # Build documentation in the "docs/" directory with Sphinx
 sphinx:

elasticipy-4.1.1/CITATION.bib

@@ -0,0 +1,17 @@
+@software{dorian_depriester_2025_15188346,
+  author       = {Dorian Depriester},
+  title        = {DorianDepriester/Elasticipy: v4.0.0},
+  month        = apr,
+  year         = 2025,
+  publisher    = {Zenodo},
+  version      = {v4.0.0},
+  doi          = {10.5281/zenodo.15188346},
+  url          = {https://doi.org/10.5281/zenodo.15188346},
+  swhid        = {swh:1:dir:f9538575fb87ee10510bd51906012987986fc36a
+                   ;origin=https://doi.org/10.5281/zenodo.14501849;vi
+                   sit=swh:1:snp:20bf603cb1ae305b4d37a4567557ac860e09
+                   d3e5;anchor=swh:1:rel:6dad2d91dcebe09e35d44f82a0c8
+                   a46c77f0d057;path=DorianDepriester-
+                   Elasticipy-c8bfc05
+                  },
+}

elasticipy-4.1.1/CITATION.cff

@@ -0,0 +1,11 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+authors:
+- family-names: "Depriester"
+  given-names: "Dorian"
+  orcid: "https://orcid.org/0000-0002-2881-8942"
+title: "Elasticipy"
+version: 4.0.0
+doi: 10.5281/zenodo.15188346
+date-released: 2025-04-10
+url: "https://github.com/DorianDepriester/Elasticipy"

{elasticipy-4.0.0 → elasticipy-4.1.1}/CONTRIBUTING.md

@@ -25,7 +25,7 @@ All types of contributions are encouraged and valued. See the [Table of Contents
 ## Code of Conduct
 
 This project and everyone participating in it is governed by the
-[Elasticipy Code of Conduct](https://github.com/DorianDepriester/Elasticipy/blob//CODE_OF_CONDUCT.md).
+[Elasticipy Code of Conduct](https://github.com/DorianDepriester/Elasticipy/blob/main/CODE_OF_CONDUCT.md).
 By participating, you are expected to uphold this code. Please report unacceptable behavior
 to <dorian.dep@gmail.com>.
 

{elasticipy-4.0.0 → elasticipy-4.1.1}/Examples/Elate_vs_Elasticipy.py

@@ -13,7 +13,7 @@ C = StiffnessTensor.monoclinic(phase_name='TiNi',
                                C22=240, C23=131, C33=175,
                                C44=81, C55=11, C66=85,
                                C15=-18, C25=1, C35=-3, C46=3)
-Celate = Elastic(list(C.matrix))
+Celate = Elastic(list(C._matrix))
 
 # Plotting with Elate
 start_time=time.perf_counter()

{elasticipy-4.0.0 → elasticipy-4.1.1}/Examples/Example_Stiffness_tensor.py

@@ -1,7 +1,14 @@
 from Elasticipy.tensors.elasticity import StiffnessTensor
 from scipy.spatial.transform import Rotation
+
+################################################
+# The lines below are only required in PyCharm
+################################################
 import matplotlib as mpl
-mpl.use('Qt5Agg')   # Ensure interactive plot
+mpl.use('Qt5Agg')
+from qtpy import QtWidgets
+app = QtWidgets.QApplication.instance() or QtWidgets.QApplication([])
+################################################
 
 # First, let consider the NiTi material:
 C = StiffnessTensor.fromCrystalSymmetry(symmetry='monoclinic', diad='y', phase_name='TiNi',
@@ -15,29 +22,43 @@ print(C)
 E = C.Young_modulus
 # See min/max values
 print(E)
+
 # Now illustrate the spatial dependence
-E.plot_xyz_sections()   # As 2D sections...
-E.plot3D()                # ...or in 3D
-E.plot_as_pole_figure()     # or even with PF
+fig,_ = E.plot_xyz_sections()   # As 2D sections...
+fig.show()
+fig,_ = E.plot3D()              # ...or in 3D
+fig.show()
+fig,_ =E.plot_as_pole_figure()  # or even with PF
+fig.show()
+
+# Print out the maximum value for the Young modulus
 print(E.max())
 
 # Apply a random rotation on stiffness tensor
 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()
+fig, _ = Crot.Young_modulus.plot3D()
+fig.show()
 
 # Now let's consider the shear modulus
 G = C.shear_modulus
-G.plot_xyz_sections()   # Plot sections with min, max and mean
-G.plot3D()     # And plot it in 3D
+fig,_ = G.plot_xyz_sections()   # Plot sections with min, max and mean
+fig.show()
+
+fig,_ = G.plot3D()              # And plot it in 3D
+fig.show()
 print(G.min())
 print(G.max())
 
 # Finally, let's have a look on the Poisson ratio
 nu = C.Poisson_ratio
-nu.plot_xyz_sections()
-nu.plot3D(which='max')
+fig,_ = nu.plot_xyz_sections()
+fig.show()
+fig,_ = nu.plot3D(which='max')
+fig.show()
+
+# Check out the maximum and minimum values
 print(nu.min())
 print(nu.max())
 
@@ -45,7 +66,8 @@ print(nu.max())
 oris = Rotation.random(1000)
 Crotated = C*oris  # Compute the Voigt average
 Cvoigt = Crotated.Voigt_average()
-print(Cvoigt.Young_modulus) # Look at the corresponding Young modulis
+print(Cvoigt.Young_modulus) # Look at the corresponding Young moduli
 print(C.Voigt_average().Young_modulus) # Compare with infinite number of orientations
 
 
+app.exec() # Only required in PyCharm (see lines 7-10)

{elasticipy-4.0.0 → elasticipy-4.1.1}/Examples/Example_StressStrain_arrays.py

@@ -1,30 +1,25 @@
-# ======================================================
-# Imports and simple example of stress
-# ======================================================
 import numpy as np
 from Elasticipy.tensors.stress_strain import StressTensor, StrainTensor
+from Elasticipy.tensors.elasticity import StiffnessTensor
+from scipy.spatial.transform import Rotation
 
-
-stress = StressTensor([[0, 1, 0],
-                       [1, 0, 0],
-                       [0, 0, 0]])
+# ======================================================
+# Simple example of stress
+# ======================================================
+stress = StressTensor.shear([1,0,0],[0,1,0],1)
 print(stress.vonMises())
 print(stress.Tresca())
 
 # ======================================================
 # Simple example of strain
 # ======================================================
-strain = StrainTensor([[0, 1e-3, 0],
-                       [1e-3, 0, 0],
-                       [0, 0, 0]])
+strain = StrainTensor.shear([1,0,0],[0,1,0],1e-3)
 print(strain.principal_strains())
 print(strain.volumetric_strain())
 
 # ======================================================
 # Linear elasticity
 # ======================================================
-from Elasticipy.tensors.elasticity import StiffnessTensor
-
 C = StiffnessTensor.fromCrystalSymmetry(symmetry='cubic', phase_name='ferrite',
                                         C11=274, C12=175, C44=89)
 print(C)
@@ -34,15 +29,14 @@ print(sigma)
 
 S = C.inv()
 print(S)
-
 print(S * sigma)
 
 # ======================================================
 # Multidimensional tensor arrays
 # ======================================================
 n_array = 10
-sigma = StressTensor.zeros(n_array)  # Initialize the array to zero-stresses
-sigma.C[0, 1] = sigma.C[1, 0] = np.linspace(0, 100, n_array)    # The shear stress is linearly increasing
+sigma_xy = np.linspace(0, 100, n_array)
+sigma = StressTensor.shear([1,0,0], [0,1,0],sigma_xy)
 print(sigma[0])     # Check the initial value of the stress...
 print(sigma[-1])    # ...and the final value.
 
@@ -56,12 +50,10 @@ print(energy)     # print the elastic energy
 # ======================================================
 # Apply random rotations
 # ======================================================
-from scipy.spatial.transform import Rotation
-
 n_ori = 1000
 rotations = Rotation.random(n_ori)
 
-eps_rotated = eps.matmul(rotations)
+eps_rotated = eps.rotate(rotations, mode='cross')
 print(eps_rotated.shape)    # Just to check how it looks like
 
 sigma_rotated = C * eps_rotated
@@ -72,7 +64,10 @@ sigma_mean = sigma.mean(axis=1)     # Compute the mean over all orientations
 print(sigma_mean[-1])
 
 C_rotated = C * rotations
-C_Voigt = C_rotated.Voigt_average()
+C_Voigt = C_rotated.Voigt_average() # Now check that the previous result is consistent with Voigt average
 sigma_Voigt = C_Voigt * eps
 print(sigma_Voigt[-1])
 
+fig, ax = sigma_Voigt[-1].draw_Mohr_circles()
+fig.show()
+

{elasticipy-4.0.0 → elasticipy-4.1.1}/Examples/Example_WaveVelocity.py

@@ -1,15 +1,14 @@
 from Elasticipy.tensors.elasticity import StiffnessTensor
-import matplotlib as mpl
-mpl.use('Qt5Agg')   # Ensure interactive plot
+from matplotlib import pyplot as plt
 
-C = StiffnessTensor.fromCrystalSymmetry(symmetry='orthorombic', phase_name='forsterite',
+C = StiffnessTensor.fromCrystalSymmetry(symmetry='orthorhombic', phase_name='forsterite',
                                         C11=320, C12=68.2, C13=71.6,
                                         C22=196.5, C23=76.8, C33=233.5, C44=64, C55=77, C66=78.7)
 rho = 3.355
 
 cp, cs_fast, cs_slow = C.wave_velocity(rho)
-print(cp)
-
-fig, _ =cp.plot_as_pole_figure(subplot_args=(131,), title='p wave', show=False)
-cs_fast.plot_as_pole_figure(subplot_args=(132,), title='s wave (fast)', fig=fig, show=False)
-cs_slow.plot_as_pole_figure(subplot_args=(133,), title='s wave (slow)', fig=fig, show=True)
+fig = plt.figure(figsize=(12,4))
+cp.plot_as_pole_figure(subplot_args=(131,), title='p wave', fig=fig)
+cs_fast.plot_as_pole_figure(subplot_args=(132,), title='s wave (fast)', fig=fig)
+cs_slow.plot_as_pole_figure(subplot_args=(133,), title='s wave (slow)', fig=fig)
+fig.show()

{elasticipy-4.0.0 → elasticipy-4.1.1}/Examples/SelfConsistent.py

@@ -27,7 +27,7 @@ def polarization_tensor(C_macro_local, a1, a2, a3, n_phi, n_theta):
 
 def localization_tensor(C_macro_local, C_incl, n_phi, n_theta, a1, a2, a3):
     E = polarization_tensor(C_macro_local, a1, a2, a3, n_phi, n_theta)
-    delta = FourthOrderTensor(C_incl.matrix - C_macro_local.matrix)
+    delta = FourthOrderTensor(C_incl._matrix - C_macro_local._matrix)
     Ainv = E.ddot(delta) + I
     return Ainv.inv()
 
@@ -53,13 +53,13 @@ def Kroner_Eshelby(Ci, g, method='strain', max_iter=5, atol=1e-3, rtol=1e-3, dis
         Q = Ci_rotated.ddot(A)
         if method=='stress':
             CiAi_mean = Q.mean()
-            C_macro = StiffnessTensor.from_Kelvin(CiAi_mean.matrix, force_symmetries=True)
+            C_macro = StiffnessTensor.from_Kelvin(CiAi_mean._matrix, force_symmetries=True)
             err = A.mean() - FourthOrderTensor.identity()
         else:
             B = Q.ddot(C_macro.inv())
             R = Ci_rotated.inv().ddot(B)
             R_mean = R.mean()
-            C_macro = StiffnessTensor.from_Kelvin(R_mean.inv().matrix, force_symmetries=True)
+            C_macro = StiffnessTensor.from_Kelvin(R_mean.inv()._matrix, force_symmetries=True)
             err = B.mean() - FourthOrderTensor.identity()
 
         # Stopping criteria
@@ -77,13 +77,10 @@ def Kroner_Eshelby(Ci, g, method='strain', max_iter=5, atol=1e-3, rtol=1e-3, dis
         if k == max_iter:
             keep_on = False
         if display:
-            err = np.max(np.abs(err.matrix))
+            err = np.max(np.abs(err._matrix))
             print('Iter #{}: abs. change={:0.5f}; rel. change={:0.5f}; error={:0.5f}'.format(k, max_abs_change, rel_change,err))
     return C_macro, message
 
-Cstrip = StiffnessTensor.transverse_isotropic(Ex= 10.2, Ez=146.8, nu_zx=0.274, nu_yx=0.355, Gxz=7)
-Cstrip = Cstrip * Rotation.from_euler('Y', 90, degrees=True)
-#orientations = Rotation.from_euler('Z', np.linspace(0, 180, 10, endpoint=False), degrees=True)
-orientations = Rotation.random(100, random_state=1234)
-Cstrip = StiffnessTensor.cubic(C11=186, C12=134, C44=77)
-C_stress, reason = Kroner_Eshelby(Cstrip, orientations, display=True, method='strain')
+C=StiffnessTensor.cubic(C11=108, C44=28.3, C12=62)
+orientations = Rotation.random(1000)
+Cmacro, msg = Kroner_Eshelby(C, orientations, method='stress', display=True)

{elasticipy-4.0.0 → elasticipy-4.1.1}/Examples/essai_plasticity.py

@@ -3,8 +3,6 @@ from Elasticipy.tensors.stress_strain import StressTensor, StrainTensor
 from Elasticipy.tensors.elasticity 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
@@ -70,4 +68,5 @@ for j, model in enumerate(models):
     ax.plot(eps_xy, stress_mag, label=labels[j])
 ax.set_xlabel(r'$\varepsilon_{xy}$')
 ax.set_ylabel('Shear stress (MPa)')
-ax.legend()
+ax.legend()
+fig.show()

{elasticipy-4.0.0 → elasticipy-4.1.1}/Examples/example_readwrite.py

@@ -2,9 +2,11 @@ from Elasticipy.tensors.elasticity import StiffnessTensor
 
 C = StiffnessTensor.from_MP("mp-1048")
 C.save_to_txt("TiNi.txt")
-C.save_to_txt("TiNi.txt", matrix_only=True)
+C.save_to_txt("TiNi-matrix.txt", matrix_only=True)
 
 C2 = StiffnessTensor.from_txt_file("TiNi.txt")
-Cu2= StiffnessTensor.from_txt_file("TiNi.txt")
+C3 = StiffnessTensor.from_txt_file("TiNi-matrix.txt")
+print(C==C2)
+print(C==C3)
 
 

{elasticipy-4.0.0 → elasticipy-4.1.1}/JOSS/paper.md

@@ -112,7 +112,7 @@ orthogonal sections.
 
 ![Young modulus (GPa) of Cu single crystal as a 3D surface (a) or a pole figure (b); 
 Young modulus of Cu polycrystal with $[001]$ fiber texture, plotted in three orthogonal sections, depending on the
-averaging method. \label{fig:Young}](YoungModulus.png)
+averaging method (c). \label{fig:Young}](YoungModulus.png)
 
 Elasticipy also introduces the concept of *tensor arrays*, in a similar way as in MTEX [@MTEX], allowing to 
 process several tensors at once with simple and highly efficient commands. In order to highlight the performances 
@@ -136,19 +136,20 @@ to other averaging methods (e.g. self-consistent models), possibly beyond linear
 with ease. It already implements thermal expansion.
 
 # Usage
+This section presents the syntaxes of few basic operations performed with Elasticipy v4.0.0.
 
 ## Plot directional engineering constants
 
 \autoref{fig:Young}.a) and b) were rendered with the following syntax:
 
 ````python
-
 from Elasticipy.tensors.elasticity import StiffnessTensor
-
 C = StiffnessTensor.cubic(C11=186, C12=134, C44=77)
 E = C.Young_modulus
-E.plot3D(n_phi=500, n_theta=500)
-E.plot_as_pole_figure()
+fig, _ = E.plot3D(n_phi=500, n_theta=500)
+fig.show()
+fig, _ = E.plot_as_pole_figure()
+fig.show()
 ````
 
 ## Create an array of rotated stiffness tensors and compute average
@@ -162,7 +163,7 @@ n = 10000
 phi1 = np.random.random(n)*2*np.pi  # Random sampling from 0 to 2pi
 Euler_angles = np.array([phi1,  np.zeros(n),  np.zeros(n)]).T # Fibre texture
 rotations = Rotation.from_euler('ZXZ', Euler_angles) # Bunge-Euler angles
-C_rotated = C * rotations # n-lenght tensor array
+C_rotated = C * rotations # n-length tensor array
 ````
 
 Then, the Voigt--Reuss--Hill average [@hill] can be computed from the tensor array:
@@ -174,7 +175,8 @@ C_VRH = C_rotated.Hill_average()
 Finally, the corresponding Young moduli can be plotted in orthogonal sections, as shown in \autoref{fig:Young}.c), with:
 
 ````python
-C_VRH.Young_modulus.plot_xyz_sections()
+fig, ax = C_VRH.Young_modulus.plot_xyz_sections()
+fig.show()
 ````
 
 ## Arrays of stress/strain tensor
@@ -184,7 +186,6 @@ will create a tensor array corresponding to evenly-spaced strain along $[1,0,0]$
 
 ````python
 from Elasticipy.tensors.stress_strain import StrainTensor
-
 m = 1000  # length of tensor array
 mag = np.linspace(0, 0.1, m)  # Strain magnitude
 strain = StrainTensor.tensile([1, 0, 0], mag)
@@ -194,7 +195,7 @@ Given the stiffness tensor ``C`` (see above), one can compute the corresponding
 ````python
 stress = C * strain
 ````
-Finally, ``stress.von_Mises()`` returns an array of length ``n`` and data type ``float64``, providing all the 
+Finally, ``stress.vonMises()`` returns an array of length ``n`` and data type ``float64``, providing all the 
 corresponding von Mises equivalent stresses.
 
 # References

{elasticipy-4.0.0 → elasticipy-4.1.1}/PKG-INFO

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

{elasticipy-4.0.0 → elasticipy-4.1.1}/README.md

@@ -17,7 +17,7 @@ Among other features, this package implements:
 
 - Computation of elasticity tensors,
 - Analysis of elastic anisotropy and wave propagation,
-- Working with multidimensional arrays of strain and stress tensors,
+- Working with multidimensional arrays of tensors,
 - Thermal expansion tensors,
 - Rotation of tensors,
 - Integration with crystal symmetry groups,
@@ -47,4 +47,20 @@ The project uses unit tests with `pytest` and coverage reports generated using `
 Certain parts of the code, particularly those related to graphical user interfaces (GUIs) or visual plotting, are 
 **excluded from code coverage analysis**. This includes the following file:
 
-- **`src/Elasticipy/gui.py`**
+- **`src/Elasticipy/gui.py`**
+
+## Cite this package
+If you use Elasticipy, please cite [![DOI](https://zenodo.org/badge/876162900.svg)](https://doi.org/10.5281/zenodo.14501849)
+
+You can use the following BibTeX entry:
+````bibtex
+@software{Elasticipy,
+author = {Depriester, Dorian},
+doi = {10.5281/zenodo.15188346},
+month = apr,
+title = {{Elasticipy}},
+url = {https://github.com/DorianDepriester/Elasticipy},
+version = {4.0.0},
+year = {2025}
+}
+````

elasticipy-4.1.1/docs/source/Elasticipy.interfaces.FEPX.rst

@@ -0,0 +1,7 @@
+Elasticipy.interfaces.FEPX module
+====================================
+
+.. automodule:: Elasticipy.interfaces.FEPX
+   :members:
+   :undoc-members:
+   :show-inheritance:

elasticipy-4.1.1/docs/source/Elasticipy.interfaces.PRISMS.rst

@@ -0,0 +1,7 @@
+Elasticipy.interfaces.PRISMS module
+====================================
+
+.. automodule:: Elasticipy.interfaces.PRISMS
+   :members:
+   :undoc-members:
+   :show-inheritance:

{elasticipy-4.0.0 → elasticipy-4.1.1}/docs/source/Elasticipy.rst

@@ -13,7 +13,8 @@ Submodules
    Elasticipy.tensors.stress_strain
    Elasticipy.spherical_function
    Elasticipy.plasticity
-
+   Elasticipy.interfaces.PRISMS
+   Elasticipy.interfaces.FEPX
 
 Module contents
 ---------------

{elasticipy-4.0.0 → elasticipy-4.1.1}/docs/source/Tutorials/Plasticity.rst

@@ -75,33 +75,6 @@ That's all. Finally, let us plot the applied stress as a function of the overall
     >>> ax.set_xlabel(r'$\varepsilon_{xx}$') # doctest: +SKIP
     >>> ax.set_ylabel('Tensile stress (MPa)') # doctest: +SKIP
 
-Now, let say that we want to investigate the material's response for the tensile stress ranging from 0 to 725 MPa:
-
-    >>> 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
 
 
@@ -179,12 +152,11 @@ 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')
+    >>> JC_tresca = 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)
@@ -193,12 +165,12 @@ For instance, one can highlight the difference between the J2 and Tresca plastic
     >>> 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])
+    ...     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]) # doctest: +SKIP
     >>> ax.set_xlabel(r'$\varepsilon_{xy}$') # doctest: +SKIP
     >>> ax.set_ylabel('Shear stress (MPa)') # doctest: +SKIP
     >>> ax.legend() # doctest: +SKIP

{elasticipy-4.0.0 → elasticipy-4.1.1}/docs/source/Tutorials/Tutorial_StiffnessTensor.rst

@@ -32,6 +32,11 @@ let's see its value along the x, y and z directions:
     >>> print((Ex, Ey, Ez))
     (124.52232440357189, 120.92120854784433, 96.13750721721384)
 
+.. note::
+
+    As the components for the stiffness tensor were provided in GPa, the values for the Young modulus are given in GPa
+    as well.
+
 Actually, a more compact syntax, and a faster way to do that, is to use:
 
     >>> import numpy as np
@@ -87,7 +92,9 @@ Spherical functions
 ~~~~~~~~~~~~~~~~~~~
 In order to fully evidence the directional dependence of the Young moduli, we can plot them as 3D surface:
 
+    >>> from matplotlib import pyplot as plt
     >>> E.plot3D() # doctest: +SKIP
+    >>> plt.show()
 
     .. image:: images/E_plot3D.png
         :width: 400
@@ -96,6 +103,7 @@ It is advised to use interactive plot to be able to zoom/rotate the surface. For
 document/articles), we can plot the values as a Pole Figure (PF):
 
     >>> E.plot_as_pole_figure() # doctest: +SKIP
+    >>> plt.show()
 
     .. image:: images/E_PF.png
         :width: 400
@@ -103,6 +111,7 @@ document/articles), we can plot the values as a Pole Figure (PF):
 Alternatively, we can plot the Young moduli on X-Y, X-Z and Y-Z sections only:
 
     >>> E.plot_xyz_sections() # doctest: +SKIP
+    >>> plt.show()
 
     .. image:: images/E_xyz_sections.png
         :width: 600
@@ -114,6 +123,7 @@ But at least, for a each direction **u**, we can consider the mean value for all
 plotting:
 
     >>> G.plot3D() # doctest: +SKIP
+    >>> plt.show()
 
     .. image:: images/G_plot3D.png
         :width: 400
@@ -121,6 +131,7 @@ plotting:
 Instead of the mean value, we can consider other statistics, e.g.:
 
     >>> G.plot3D(which='min')   # doctest: +SKIP
+    >>> plt.show()
 
     .. image:: images/G_plot3D_min.png
         :width: 400
@@ -130,6 +141,7 @@ This also works for ``max`` and ``std``. These parameters also apply for pole fi
 When plotting the X-Y, X-Z and Y-Z sections, the min, max and mean values are plotted at once:
 
     >>> G.plot_xyz_sections() # doctest: +SKIP
+    >>> plt.show()
 
     .. image:: images/G_xyz_sections.png
         :width: 600