elasticipy 2.9.0__tar.gz → 3.0.0__tar.gz

{elasticipy-2.9.0 → 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.9.0/src/elasticipy.egg-info → elasticipy-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: elasticipy
-Version: 2.9.0
+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.9.0 → 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-2.9.0 → elasticipy-3.0.0}/docs/source/Tutorials/Plasticity.rst

@@ -63,17 +63,17 @@ 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
+    ...       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')
-    >>> ax.set_xlabel(r'$\varepsilon_{xx}$')
-    >>> ax.set_ylabel('Tensile stress (MPa)')
+    >>> 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
 
@@ -90,22 +90,22 @@ to add a subroutine (optimization loop) to find the tensile stress so that the a
     >>> 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
+    ...        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')
-    >>> ax.legend()
+    >>> ax.plot(elong, stress.C[0,0], label='Strain-controlled', linestyle='dotted') # doctest: +SKIP
+    >>> ax.legend() # doctest: +SKIP
 
 .. image:: images/StressStrain-controlled.png
 
@@ -115,10 +115,10 @@ 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)]
+    ...              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)
 
@@ -128,9 +128,9 @@ 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)]
+    ...              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)
 
@@ -166,15 +166,15 @@ 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])
-    >>> ax.set_xlabel(r'$\varepsilon_{xy}$')
-    >>> ax.set_ylabel('Shear stress (MPa)')
-    >>> ax.legend()
+        ... 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

{elasticipy-2.9.0 → 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.9.0 → 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.9.0 → 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