elasticipy 2.8.9__tar.gz → 2.9.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: elasticipy
-Version: 2.8.9
+Version: 2.9.0
 Summary: A Python library for elasticity tensor computations
 Author-email: Dorian Depriester <dorian.dep@gmail.com>
 License: MIT

elasticipy-2.9.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')
+    >>> ax.set_xlabel(r'$\varepsilon_{xx}$')
+    >>> ax.set_ylabel('Tensile stress (MPa)')
+
+.. 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')
+    >>> ax.legend()
+
+.. 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}$')
+    >>> ax.set_ylabel('Shear stress (MPa)')
+    >>> ax.legend()
+
+
+.. 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.9 → elasticipy-2.9.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.9.0/src/Elasticipy/Plasticity.py

@@ -0,0 +1,282 @@
+import numpy as np
+from Elasticipy.StressStrainTensors import StrainTensor, StressTensor
+
+class IsotropicHardening:
+    """
+    Template class for isotropic hardening plasticity models
+    """
+    def __init__(self, criterion='von Mises'):
+        """
+        Create an instance of a plastic model, assuming isotropic hardening
+
+        Parameters
+        ----------
+        criterion : str, optional
+            Plasticity criterion to use. Can be 'von Mises', 'Tresca' or 'J2'. J2 is the same as von Mises.
+        """
+        criterion = criterion.lower()
+        if criterion in ('von mises', 'mises', 'vonmises', 'j2'):
+            criterion = 'j2'
+        elif criterion != 'tresca':
+            raise ValueError('The criterion can be "Tresca", "von Mises" or "J2".')
+        self.criterion = criterion.lower()
+        self.plastic_strain = 0.0
+
+    def flow_stress(self, strain, **kwargs):
+        pass
+
+    def apply_strain(self, strain, **kwargs):
+        """
+        Apply strain to the current JC model.
+
+        This function updates the internal variable to store hardening state.
+
+        Parameters
+        ----------
+        strain : float or StrainTensor
+        kwargs : dict
+            Keyword arguments passed to flow_stress()
+
+        Returns
+        -------
+        float
+            Associated flow stress (positive)
+
+        See Also
+        --------
+        flow_stress : compute the flow stress, given a cumulative equivalent strain
+        """
+        if isinstance(strain, float):
+            self.plastic_strain += np.abs(strain)
+        elif isinstance(strain, StrainTensor):
+            self.plastic_strain += strain.eq_strain()
+        else:
+            raise ValueError('The applied strain must be float of StrainTensor')
+        return self.flow_stress(self.plastic_strain, **kwargs)
+
+    def compute_strain_increment(self, stress, **kwargs):
+        pass
+
+    def reset_strain(self):
+        self.plastic_strain = 0.0
+
+    def eq_stress(self, stress):
+        if self.criterion == 'j2':
+            return stress.vonMises()
+        else:
+            return stress.Tresca()
+
+
+class JohnsonCook(IsotropicHardening):
+    def __init__(self, A, B, n, C=None, eps_dot_ref=1.0, m=None, T0=25, Tm=None, criterion='von Mises'):
+        """
+        Constructor for a Jonhson-Cook (JC) model.
+
+        The JC model is an exponential-law strain hardening model, which can take into account strain-rate sensibility
+        and temperature-dependence (although they are not mandatory). See notes for details.
+
+        Parameters
+        ----------
+        A : float
+            Yield stress
+        B : float
+            Work hardening coefficient
+        n : float
+            Work hardening exponent
+        C : float, optional
+            Strain-rate sensitivity coefficient
+        eps_dot_ref : float, optional
+            Reference strain-rate
+        m : float, optional
+            Temperature sensitivity exponent
+        T0 : float, optional
+            Reference temperature
+        Tm : float, optional
+            Melting temperature (at which the flow stress is zero)
+        criterion : str, optional
+            Plasticity criterion to use. It can be 'von Mises' or 'Tresca'.
+
+        Notes
+        -----
+        The flow stress (:math:`\\sigma`) depends on the strain (:math:`\\varepsilon`),
+        the strain rate :math:`\\dot{\\varepsilon}` and
+        the temperature (:math:`T`) so that:
+
+        .. 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}
+        """
+        super().__init__(criterion=criterion)
+        self.A = A
+        self.B = B
+        self.C = C
+        self.n = n
+        self.m = m
+        self.eps_dot_ref = eps_dot_ref
+        self.T0 = T0
+        self.Tm = Tm
+
+    def flow_stress(self, eps_p, eps_dot=None, T=None):
+        """
+        Compute the flow stress from the Johnson-Cook model
+
+        Parameters
+        ----------
+        eps_p : float or list or tuple or numpy.ndarray
+            Equivalent plastic strain
+        eps_dot : float or list or tuple or numpy.ndarray, optional
+            Equivalent plastic strain rate. If float, the strain-rate is supposed to be homogeneous for every value of
+            eps_p.
+        T : float or list or tuple or np.ndarray
+            Temperature. If float, the temperature is supposed to be homogeneous for every value of eps_p.
+        Returns
+        -------
+        float or numpy.ndarray
+            Flow stress
+        """
+        eps_p = np.asarray(eps_p)
+        stress = (self.A + self.B * eps_p**self.n)
+
+        if eps_dot is not None:
+            eps_dot = np.asarray(eps_dot)
+            if (self.C is None) or (self.eps_dot_ref is None):
+                raise ValueError('C and eps_dot_ref must be defined for using a rate-dependent model')
+            stress *= (1 + self.C * np.log(eps_dot / self.eps_dot_ref))
+
+        if T is not None:
+            T = np.asarray(T)
+            if self.T0 is None or self.Tm is None or self.m is None:
+                raise ValueError('T0, Tm and m must be defined for using a temperature-dependent model')
+            theta = (T - self.T0) / (self.Tm - self.T0)
+            theta = np.clip(theta, None, 1.0)
+            stress *= (1 - theta**self.m)
+
+        return stress
+
+
+
+    def compute_strain_increment(self, stress, T=None, apply_strain=True, criterion='von Mises'):
+        """
+        Given the equivalent stress, compute the strain increment with respect to the normality rule.
+
+        Parameters
+        ----------
+        stress : float or StressTensor
+            Equivalent stress to compute the stress from, or full stress tensor.
+        T : float
+            Temperature
+        apply_strain : bool, optional
+            If true, the JC model will be updated to account for the applied strain (hardening)
+        criterion : str, optional
+            Plasticity criterion to consider to compute the equivalent stress and apply the normality rule.
+            It can be 'von Mises', 'Tresca' or 'J2'. 'J2' is equivalent to 'von Mises'.
+
+        Returns
+        -------
+        StrainTensor or float
+            Increment of plastic strain. If the input stress is float, only the magnitude of the increment will be
+            returned (float value). If the stress is of type StressTensor, the returned value will be a full
+            StrainTensor.
+
+        See Also
+        --------
+        apply_strain : apply strain to the JC model and updates its hardening value
+        """
+        if isinstance(stress, StressTensor):
+            eq_stress = self.eq_stress(stress)
+        else:
+            eq_stress = stress
+        if T is None:
+            if eq_stress > self.A:
+                k = eq_stress  - self.A
+                total_strain = (1 / self.B * k) ** (1 / self.n)
+                strain_increment = np.max((total_strain - self.plastic_strain, 0))
+            else:
+                strain_increment = 0.0
+        else:
+            if self.T0 is None or self.Tm is None or self.m is None:
+                raise ValueError('T0, Tm and m must be defined for using a temperature-dependent model')
+            else:
+                if T >= self.Tm:
+                    strain_increment = np.inf
+                else:
+                    theta = (T - self.T0) / (self.Tm - self.T0)
+                    theta_m = theta**self.m
+                    k = (eq_stress / (1 - theta_m) - self.A)
+                    if k<0:
+                        strain_increment = 0.0
+                    else:
+                        total_strain = (1/self.B * k)**(1/self.n)
+                        strain_increment = np.max((total_strain - self.plastic_strain, 0))
+        if apply_strain:
+            self.apply_strain(strain_increment)
+
+        if isinstance(stress, StressTensor):
+            n = normality_rule(stress, criterion=criterion)
+            return n * strain_increment
+        else:
+            return strain_increment
+
+    def reset_strain(self):
+        """
+        Reinitialize the plastic strain to 0
+        """
+        self.plastic_strain = 0.0
+
+
+def normality_rule(stress, criterion='von Mises'):
+    """
+    Apply the normality rule for plastic flow, given a yield criterion.
+
+    The stress can be a single tensor, or an array of tensors.
+
+    Parameters
+    ----------
+    stress : StressTensor
+        Stress tensor to apply the normality rule from
+    criterion : str, optional
+        Name of the criterion to use. Can be either 'von Mises' or 'Tresca'
+
+    Returns
+    -------
+    StrainTensor
+        If a single stress tensor is passed, the returned array will be of shape
+
+    Notes
+    -----
+    The singular points for the Tresca criterion are treated as the von Mises criterion, which is equivalent to the
+    average of the two adjacent normals of the domain.
+    """
+    if criterion.lower()=='von mises':
+        eq_stress = stress.vonMises()
+        dev_stress= stress.deviatoric_part()
+        gradient_tensor = dev_stress / eq_stress
+        return StrainTensor(3/2 * gradient_tensor.matrix)
+    elif criterion.lower()=='tresca':
+        vals, dirs = stress.eig()
+        u1 = dirs[...,0]
+        u3 = dirs[...,2]
+        s1 = vals[...,0]
+        s2 = vals[..., 1]
+        s3 = vals[...,2]
+        A = np.einsum('...i,...j->...ij',u1, u1)
+        B = np.einsum('...i,...j->...ij',u3, u3)
+        normal = A - B
+        singular_points = np.logical_or(s2==s1, s2==s3)
+        normal[singular_points] = normality_rule(stress[singular_points], criterion='von Mises').matrix
+        normal[np.logical_and(s2==s1, s2==s3)] = 0.0
+        strain = StrainTensor(normal)
+        return strain / strain.eq_strain()
+    else:
+        raise NotImplementedError('The normality rule is only implemented for von Mises (J2) and Tresca criteria.')