elasticipy 4.0.0__py3-none-any.whl → 4.1.0__py3-none-any.whl

Elasticipy/gui.py

@@ -1,7 +1,7 @@
 import sys
 
 import numpy as np
-from PyQt5.QtWidgets import (
+from qtpy.QtWidgets import (
     QApplication, QMainWindow, QComboBox, QGridLayout, QLabel,
     QLineEdit, QPushButton, QVBoxLayout, QHBoxLayout, QWidget, QFrame, QMessageBox
 )

Elasticipy/interfaces/FEPX.py

@@ -0,0 +1,119 @@
+from Elasticipy.tensors.second_order import SymmetricSecondOrderTensor, SecondOrderTensor, \
+    SkewSymmetricSecondOrderTensor
+from Elasticipy.tensors.stress_strain import StressTensor, StrainTensor
+import pandas as pd
+import numpy as np
+import os
+import re
+from pathlib import Path
+
+DTYPES={'stress':StressTensor,
+        'strain':StrainTensor,
+        'strain_el':StrainTensor,
+        'strain_pl':StrainTensor,
+        'velgrad':SecondOrderTensor,
+        'defrate':SymmetricSecondOrderTensor,
+        'defrate_pl':SymmetricSecondOrderTensor,
+        'spinrate':SkewSymmetricSecondOrderTensor,
+        }
+
+
+def _list_valid_filenames(folder, startswith='strain'):
+    file_list = os.listdir(folder)
+    pattern = r'{}\.step\d+'.format(startswith)
+    return [f for f in file_list if re.fullmatch(pattern, f)]
+
+def from_step_file(file, dtype=None):
+    """
+    Import data from a single step file given by FEPX.
+
+    The type of returns is inferred from the data one wants to parse
+    (according the `FEPX documentation <https://fepx.info/doc/output.html>`_ ).
+
+    Parameters
+    ----------
+    file : str
+        Path to the file to read
+    dtype : type, optional
+        If provided, sets the type of returned array. It can be:
+          - float
+          - SecondOrderTensor
+          - SymmetricSecondOrderTensor
+          - SkewSymmetricSecondOrderTensor
+          - stressTensor
+          - strainTensor
+
+    Returns
+    -------
+    SecondOrderTensor or numpy.ndarray
+        Array of second-order tensors built from the read data. The array will be of shape (n,), where n is the number
+        of elements in the mesh.
+    """
+    data = pd.read_csv(file, header=None, sep=' ')
+    array = data.to_numpy()
+    base_name = os.path.splitext(os.path.basename(file))[0]
+    if dtype is None:
+        if base_name in DTYPES:
+            dtype = DTYPES[base_name]
+        else:
+            dtype = float
+    if issubclass(dtype,SymmetricSecondOrderTensor):
+        return dtype.from_Voigt(array, voigt_map=[1,1,1,1,1,1])
+    elif dtype == SkewSymmetricSecondOrderTensor:
+        zeros = np.zeros(array.shape[0])
+        mat = np.array([[ zeros,         array[:, 0],   array[:, 1]],
+                        [-array[:, 0],  zeros,          array[:, 2]],
+                        [-array[:, 1], -array[:, 2],    zeros     ]]).transpose((2, 0, 1))
+        return SkewSymmetricSecondOrderTensor(mat)
+    elif dtype == SecondOrderTensor:
+        length = array.shape[0]
+        return SecondOrderTensor(array.reshape((length,3,3)))
+    elif dtype == float:
+        return array
+
+
+
+def from_results_folder(folder, dtype=None):
+    """
+    Import all data of a given field from FEPX results folder.
+
+    The type of returns is inferred from the data one wants to parse
+    (according the `FEPX documentation <https://fepx.info/doc/output.html>`_ ).
+
+    Parameters
+    ----------
+    folder : str
+        Path to the folder to read the results from
+    dtype : type, optional
+        If provided, sets the type of returned array. It can be:
+          - float
+          - SecondOrderTensor
+          - SymmetricSecondOrderTensor
+          - SkewSymmetricSecondOrderTensor
+          - stressTensor
+          - strainTensor
+
+    Returns
+    -------
+    SecondOrderTensor or numpy.ndarray
+        Array of second-order tensors built from the read data. The array will be of shape (m, n), where m is the number
+         of time increment n is the number of elements in the mesh.
+    """
+    dir_path = Path(folder)
+    folder_name = dir_path.name
+    if not dir_path.is_dir():
+        raise ValueError(f"{folder} is not a valid directory.")
+    constructor = None
+    array = []
+    for file in dir_path.iterdir():
+        if file.is_file() and file.name.startswith(folder_name):
+            data_file = from_step_file(str(file), dtype=dtype)
+            if constructor is None:
+                constructor = type(data_file)
+            elif constructor != type(data_file):
+                raise ValueError('The types of data contained in {} seem to be inconsistent.'.format(folder))
+            array.append(data_file)
+    if constructor == np.ndarray:
+        return np.stack(array, axis=0)
+    else:
+        return constructor.stack(array)

Elasticipy/interfaces/PRISMS.py

@@ -0,0 +1,103 @@
+from Elasticipy.tensors.second_order import SecondOrderTensor, SymmetricSecondOrderTensor
+from Elasticipy.tensors.stress_strain import StressTensor
+import pandas as pd
+import numpy as np
+
+def _rebuild_tensor(F11, F22, F33, F12, F13, F21, F23, F31, F32):
+    return np.array([[F11, F12, F13], [F21, F22, F23], [F31, F32, F33]]).transpose((2,0,1))
+
+def from_quadrature_file(file, returns='stress'):
+    """
+    Read data from quadrature output file generated by PRISMS plasticity.
+
+    These files, usually named QuadratureOutputsXXX.csv (where XXX denotes the time increment), contain large amount of
+    data, such as gradient components, stress values, grain ID etc.
+
+    Parameters
+    ----------
+    file : str
+        Path to quadrature file
+    returns : str or list of str or tuple of str
+        name(s) of requested field(s). They can be:
+          - grain ID
+          - phase ID
+          - det(J)
+          - twin
+          - coordinates
+          - orientation
+          - elastic gradient
+          - plastic gradient
+          - stress
+    Returns
+    -------
+    ndarray or SecondOrderTensor or StressTensor
+        The number of returned values depends on the requested fields.
+    """
+    data=pd.read_csv(file, header=None, dtype=float, usecols=range(0,37))
+    grainID, phaseID, detJ, twin, x, y, z, rot1, rot2, rot3, *other = data.T.to_numpy()
+    Fe11, Fe22, Fe33, Fe12, Fe13, Fe21, Fe23, Fe31, Fe32, *FpStress = other
+    Fp11, Fp22, Fp33, Fp12, Fp13, Fp21, Fp23, Fp31, Fp32, *stress_compo = FpStress
+    if isinstance(returns, str):
+        returns_list = (returns,)
+    else:
+        returns_list = returns
+    returned_values = []
+    for r in returns_list:
+        rl = r.lower()
+        if (rl == 'grain id') or (rl == 'grainid'):
+            returned_values.append(grainID)
+        elif (rl == 'phase id') or (rl == 'phaseid'):
+            returned_values.append(phaseID)
+        elif rl == 'det(j)':
+            returned_values.append(detJ)
+        elif rl == 'twin':
+            returned_values.append(twin)
+        elif rl == 'coordinates':
+            returned_values.append(np.array([x, y, z]).T)
+        elif rl == 'orientation':
+            returned_values.append(np.array([rot1, rot2, rot3]).T)
+        elif rl == 'elastic gradient':
+            Fe = _rebuild_tensor(Fe11, Fe22, Fe33, Fe12, Fe13, Fe21, Fe23, Fe31, Fe32)
+            returned_values.append(SecondOrderTensor(Fe))
+        elif rl == 'plastic gradient':
+            Fp = _rebuild_tensor(Fp11, Fp22, Fp33, Fp12, Fp13, Fp21, Fp23, Fp31, Fp32)
+            returned_values.append(SecondOrderTensor(Fp))
+        elif rl == 'stress':
+            stress = _rebuild_tensor(*stress_compo)
+            returned_values.append(StressTensor(stress))
+        else:
+            raise ValueError('Unknown return type')
+    if isinstance(returns, str):
+        return returned_values[0]
+    else:
+        return tuple(returned_values)
+
+def from_stressstrain_file(file):
+    """
+    Read data from stress-strain file generated by PRISMS plasticity.
+
+    This file is usually named stressstrain.txt
+
+    Parameters
+    ----------
+    file : str
+        Path to stress-strain file
+
+    Returns
+    -------
+    SymmetricSecondOrderTensor
+        Average Green-Lagrange strain tensor
+    StressTensor
+        Average stress tensor
+    """
+    data = pd.read_csv(file, sep='\t')
+    Exx, Exy, Exz = data['Exx'], data['Exy'], data['Exz']
+    Eyy, Eyz = data['Eyy'], data['Eyz']
+    Ezz = data['Ezz']
+    E = np.array([[Exx, Exy, Exz], [Exy, Eyy, Eyz], [Exz, Eyz, Ezz]]).transpose((2,0,1))
+    Txx, Txy, Txz = data['Txx'], data['Txy'], data['Txz']
+    Tyy, Tyz = data['Tyy'], data['Tyz']
+    Tzz = data['Tzz']
+    T = np.array([[Txx, Txy, Txz], [Txy, Tyy, Tyz], [Txz, Tyz, Tzz]]).transpose((2, 0, 1))
+    return SymmetricSecondOrderTensor(E), StressTensor(T)
+

Elasticipy/plasticity.py

@@ -6,6 +6,9 @@ class IsotropicHardening:
     """
     Template class for isotropic hardening plasticity models
     """
+    type = "Isotropic"
+    name = 'Generic'
+
     def __init__(self, criterion='von Mises'):
         """
         Create an instance of a plastic model, assuming isotropic hardening
@@ -27,6 +30,12 @@ class IsotropicHardening:
             self.criterion = criterion
         self.plastic_strain = 0.0
 
+    def __repr__(self):
+        return (('{} plasticity model\n'.format(self.name) +
+                ' type: {}\n'.format(self.type)) +
+                ' criterion: {}\n'.format(self.criterion.name) +
+                ' current strain: {}'.format(self.plastic_strain))
+
     def flow_stress(self, strain, **kwargs):
         pass
 
@@ -67,9 +76,14 @@ class IsotropicHardening:
 
 
 class JohnsonCook(IsotropicHardening):
+    """
+    Special case of isotropic hardening with an underlying Johnson Cook hardening evolution rule
+    """
+    name = "Johnson-Cook"
+
     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.
+        Constructor for a Johnson-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.
@@ -235,6 +249,11 @@ class JohnsonCook(IsotropicHardening):
 
 
 class PlasticityCriterion:
+    """
+    Template class for plasticity criteria
+    """
+    name = 'generic'
+
     @staticmethod
     def eq_stress(stress, **kwargs):
         """
@@ -271,6 +290,10 @@ class PlasticityCriterion:
         pass
 
 class VonMisesPlasticity(PlasticityCriterion):
+    """
+    von Mises plasticity criterion, with associated normality rule
+    """
+    name = 'von Mises'
     @staticmethod
     def eq_stress(stress, **kwargs):
         return stress.vonMises()
@@ -283,6 +306,11 @@ class VonMisesPlasticity(PlasticityCriterion):
         return StrainTensor(3 / 2 * gradient_tensor.matrix)
 
 class TrescaPlasticity(PlasticityCriterion):
+    """
+    Tresca plasticity criterion, with associated normality rule
+    """
+    name = 'Tresca'
+
     @staticmethod
     def eq_stress(stress, **kwargs):
         return stress.Tresca()
@@ -305,6 +333,11 @@ class TrescaPlasticity(PlasticityCriterion):
         return strain / strain.eq_strain()
 
 class DruckerPrager(PlasticityCriterion):
+    """
+    Drucker-Prager pressure-dependent plasticity criterion, with associated normality rule
+    """
+    name = 'Drucker-Prager'
+
     def __init__(self, alpha):
         """
         Create a Drucker-Prager (DG) plasticity criterion.

Elasticipy/polefigure.py

@@ -101,6 +101,27 @@ class LambertScale(mscale.ScaleBase):
 mscale.register_scale(LambertScale)
 
 def add_polefigure(fig, *args, projection='stereographic', **kwargs):
+    """
+    Add a pole figure to the figure object.
+
+    Parameters
+    ----------
+    fig : matplotlib.figure.Figure
+        Handle to an existing figure
+    args : list
+        Positional arguments to pass to the subplot constructor
+    projection : str, optional
+        Projection to use. I can be 'stereographic' (default), 'equal area' or 'lambert' (which is equivalent to equal
+        area).
+
+    kwargs : dict
+        Keyword arguments to pass to the subplot constructor
+
+    Returns
+    -------
+    matplotlib.axes._subplots.AxesSubplot
+        Handle to the added axes
+    """
     if projection.lower() == 'equal area':
         projection = 'lambert'
     ax = fig.add_subplot(*args, projection='polar', **kwargs)

Elasticipy/spherical_function.py

@@ -541,8 +541,6 @@ class SphericalFunction:
         u, evals = self.evaluate_on_spherical_grid((n_phi, n_theta), return_in_spherical=False, use_symmetry=False)
         ax = _plot3D(new_fig, u, evals, **kwargs)
         ax.axis('equal')
-        if fig is None:
-            plt.show()
         return new_fig, ax
 
     def plot_xyz_sections(self, n_theta=500, fig=None, axs=None, **kwargs):
@@ -590,12 +588,10 @@ class SphericalFunction:
             r = self.eval_spherical(angles)
             ax.plot(theta_polar, r, **kwargs)
             axs_new.append(ax)
-        if fig is None:
-            new_fig.show()
         return new_fig, axs_new
 
     def plot_as_pole_figure(self, n_theta=50, n_phi=200, projection='lambert',
-                            fig=None, plot_type='imshow', show=True, title=None,
+                            fig=None, plot_type='imshow', title=None,
                             subplot_args=(), subplot_kwargs=None, **kwargs):
         """
         Plots a pole figure visualization of spherical data using specified parameters and plot types.
@@ -617,7 +613,7 @@ class SphericalFunction:
         plot_type : str, optional
             The type of plot to generate: 'imshow', 'contourf', or 'contour', by default 'imshow'.
         title : str, optional
-            Title to add to the current axis. Defaut is None.
+            Title to add to the current axis. Default is None.
         subplot_args : tuple
             List of arguments to pass to the subplot function, by default ()
         subplot_kwargs : dict
@@ -656,8 +652,6 @@ class SphericalFunction:
         ax.set_rlim(*self.domain[1])
         ax.set_title(title)
         new_fig.colorbar(sc)
-        if show:
-            plt.show()
         return new_fig, ax
 
 
@@ -886,8 +880,6 @@ class HyperSphericalFunction(SphericalFunction):
         else:
             r_grid = np.mean(values, axis=2)
         ax = _plot3D(new_fig, u[:, :, 0, :], r_grid, **kwargs)
-        if fig is None:
-            plt.show()
         return new_fig, ax
 
     def plot_xyz_sections(self, n_theta=500, n_psi=100, color_minmax='blue', alpha_minmax=0.2, color_mean='red',
@@ -950,8 +942,6 @@ class HyperSphericalFunction(SphericalFunction):
         handles.extend([line, area])
         labels.extend([line.get_label(), area.get_label()])
         new_fig.legend(handles, labels, loc='upper center', ncol=2, bbox_to_anchor=(0.5, 0.95))
-        if fig is None:
-            new_fig.show()
         return new_fig, axs
 
     def plot_as_pole_figure(self, n_theta=50, n_phi=200, n_psi=50, which='mean', projection='lambert', fig=None,
@@ -1033,6 +1023,4 @@ class HyperSphericalFunction(SphericalFunction):
         ax.set_rlim(*self.domain[1])
         ax.set_title(title)
         fig.colorbar(sc)
-        if show:
-            plt.show()
         return fig, ax