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

Elasticipy/StressStrainTensors.py

@@ -1,138 +1,16 @@
-import numpy as np
-from Elasticipy.SecondOrderTensor import SymmetricSecondOrderTensor
-
-
-class StrainTensor(SymmetricSecondOrderTensor):
-    """
-    Class for manipulating symmetric strain tensors or arrays of symmetric strain tensors.
-
-    """
-    name = 'Strain tensor'
-    voigt_map = [1, 1, 1, 2, 2, 2]
-
-    def principal_strains(self):
-        """
-        Values of the principals strains.
-
-        If the tensor array is of shape [m,n,...], the results will be of shape [m,n,...,3].
-
-        Returns
-        -------
-        np.ndarray
-            Principal strain values
-        """
-        return self.eigvals()
-
-    def volumetric_strain(self):
-        """
-        Volumetric change (1st invariant of the strain tensor)
-
-        Returns
-        -------
-        numpy.ndarray or float
-            Volumetric change
-        """
-        return self.I1
-
-    def eq_strain(self):
-        """von Mises equivalent strain"""
-        return np.sqrt(2/3 * self.ddot(self))
-
-    def elastic_energy(self, stress):
-        """
-        Compute the elastic energy.
-
-        Parameters
-        ----------
-        stress : StressTensor
-            Corresponding stress tensor
-
-        Returns
-        -------
-        Volumetric elastic energy
-        """
-        return 0.5 * self.ddot(stress)
-
-
-class StressTensor(SymmetricSecondOrderTensor):
-    """
-    Class for manipulating stress tensors or arrays of stress tensors.
-    """
-    name = 'Stress tensor'
-
-    def principal_stresses(self):
-        """
-        Values of the principals stresses.
-
-        If the tensor array is of shape [m,n,...], the results will be of shape [m,n,...,3].
-
-        Returns
-        -------
-        np.ndarray
-            Principal stresses
-        """
-        return self.eigvals()
-
-    def vonMises(self):
-        """
-        von Mises equivalent stress.
-
-        Returns
-        -------
-        np.ndarray or float
-            von Mises equivalent stress
-
-        See Also
-        --------
-        Tresca : Tresca equivalent stress
-        """
-        return np.sqrt(3 * self.J2)
-
-    def Tresca(self):
-        """
-        Tresca(-Guest) equivalent stress.
-
-        Returns
-        -------
-        np.ndarray or float
-            Tresca equivalent stress
-
-        See Also
-        --------
-        vonMises : von Mises equivalent stress
-        """
-        ps = self.principal_stresses()
-        return ps[...,0] - ps[...,-1]
-
-    def hydrostatic_pressure(self):
-        """
-        Hydrostatic pressure
-
-        Returns
-        -------
-        np.ndarray or float
-
-        See Also
-        --------
-        sphericalPart : spherical part of the stress
-        """
-        return -self.I1/3
-
-    def elastic_energy(self, strain, mode='pair'):
-        """
-        Compute the elastic energy.
-
-        Parameters
-        ----------
-        strain : StrainTensor
-            Corresponding elastic strain tensor
-        mode : str, optional
-            If 'pair' (default), the elastic energies are computed element-wise. Broadcasting rule applies.
-            If 'cross', each cross-combination of stress and strain are considered.
-
-        Returns
-        -------
-        numpy.ndarray
-            Volumetric elastic energy
-        """
-        return 0.5 * self.ddot(strain, mode=mode)
+import warnings
+from Elasticipy.tensors.stress_strain import StressTensor as NewStressTensor
+from Elasticipy.tensors.stress_strain import StrainTensor as NewStrainTensor
+
+warnings.warn(
+    "The module 'Elasticipy.StressStrainTensors' is deprecated and will be removed in a future release. "
+    "Please use 'Elasticipy.tensors.stress_strain' instead.",
+    DeprecationWarning,
+    stacklevel=2
+)
+
+class StressTensor(NewStressTensor):
+    pass
+
+class StrainTensor(NewStrainTensor):
+    pass

Elasticipy/ThermalExpansion.py

@@ -1,249 +1,12 @@
 import warnings
+from Elasticipy.tensors.thermal_expansion import ThermalExpansionTensor as NewThermalExpansionTensor
 
-from Elasticipy.SecondOrderTensor import SymmetricSecondOrderTensor, ALPHABET, is_orix_rotation
-from Elasticipy.StressStrainTensors import StrainTensor
-import numpy as np
-from scipy.spatial.transform import Rotation
+warnings.warn(
+    "The module 'Elasticipy.ThermalExpansion' is deprecated and will be removed in a future release. "
+    "Please use 'Elasticipy.tensors.thermal_expansion' instead.",
+    DeprecationWarning,
+    stacklevel=2
+)
 
-class ThermalExpansionTensor(SymmetricSecondOrderTensor):
-    name = 'Thermal expansion tensor'
-
-    def __mul__(self, other):
-        if isinstance(other, Rotation) or is_orix_rotation(other):
-            return super().__mul__(other)
-        else:
-            other = np.asarray(other)
-            other_expanded = other[..., None, None]
-            other_with_eye = other_expanded * np.ones(3)
-            new_mat = self.matrix * other_with_eye
-            return StrainTensor(new_mat)
-
-    def apply_temperature(self, temperature, mode='pair'):
-        """
-        Apply temperature increase to the thermal expansion tensor, or to the array.
-
-        Application can be made pair-wise, or considering all cross-combinations (see below).
-
-        Parameters
-        ----------
-        temperature : float or numpy.ndarray
-        mode : str, optional
-            If "pair" (default), the temperatures are applied pair-wise on the tensor array. Broadcasting rule applies
-            If "cross", all cross combinations are considered. Therefore, if ``C=A.apply_temperature(T, mode="cross")``,
-            then ``C.shape=A.shape + T.shape``.
-
-        Returns
-        -------
-        StrainTensor
-            Strain corresponding to the applied temperature increase(s).
-
-        Examples
-        --------
-        Let consider a transverse isotropic case (e.g. carbon fibers):
-        >>> from Elasticipy.ThermalExpansion import ThermalExpansionTensor as ThEx
-        >>> alpha = ThEx.transverse_isotropic(alpha_11=5.6e-6, alpha_33=-0.4e-6)
-
-        Now apply temperature increases:
-        >>> T = [0, 1, 2]
-        >>> eps = alpha.apply_temperature(T)
-
-        We get a strain tensor of the same shape as the applied temperatures:
-        >>> eps
-        Strain tensor
-        Shape=(3,)
-        >>> eps[-1]
-        Strain tensor
-        [[ 1.12e-05  0.00e+00  0.00e+00]
-         [ 0.00e+00  1.12e-05  0.00e+00]
-         [ 0.00e+00  0.00e+00 -8.00e-07]]
-
-         Now let's rotate the thermal expansions:
-         >>> from scipy.spatial.transform import Rotation
-         >>> rot = Rotation.random(3) # Set of 3 random 3D rotations
-         >>> alpha_rotated = alpha * rot
-
-         If we want to combine each rotated thermal expansion with the corresponding temperature increase:
-         >>> eps_rotated_pair = alpha_rotated * T # Equivalent to alpha_rotated.apply_temperature(T)
-         >>> eps_rotated_pair
-         Strain tensor
-         Shape=(3,)
-
-         Conversely, if we want to evaluate all cross-combinations of thermal expansions and temperature increases:
-
-         >>> eps_rotated_cross = alpha_rotated.apply_temperature(T, mode='cross')
-         >>> eps_rotated_cross
-         Strain tensor
-         Shape=(3, 3)
-
-        """
-        temperature = np.asarray(temperature)
-        if mode == 'pair':
-            matrix = self.matrix*temperature[...,np.newaxis,np.newaxis]
-        elif mode == 'cross':
-            indices_self = ALPHABET[:self.ndim]
-            indices_temp = ALPHABET[:len(temperature.shape)].upper()
-            ein_str = indices_self + 'ij,' + indices_temp + '->' + indices_self + indices_temp + 'ij'
-            matrix = np.einsum(ein_str, self.matrix, temperature)
-        else:
-            raise ValueError('Invalid mode. It could be either "pair" or "cross".')
-        return StrainTensor(matrix)
-
-
-    def matmul(self, other):
-        """
-        Matrix like product with array of float, resulting either in StrainTensor.
-
-        Compute the product between the tensor and a numpy array in a "matrix-product" way,*
-        that is by computing each of the products. If T.shape=(m,n,o,...) and other.shape=(p,q,r,...), then::
-
-            T.matmul(other).shape = (m,n,o,...,p,q,r,...)
-
-        Parameters
-        ----------
-        other : np.ndarray
-            Value to multiply by.
-        Returns
-        -------
-        StrainTensor
-            Array fo strain tensors corresponding to all cross-combinations between Thermal expansions and temperature
-            increases.
-        """
-        warnings.warn(
-            'matmul() is deprecated and will be removed in a future version. Use dot(tensor,mode="cross") or '
-            'rotate(rotation,mode="cross") instead.',
-            DeprecationWarning,
-            stacklevel=2)
-        if isinstance(other, Rotation) or is_orix_rotation(other):
-            return super().matmul(other)
-        else:
-            return self.apply_temperature(other, mode='cross')
-
-
-    @classmethod
-    def isotropic(cls, alpha):
-        """
-        Create an isotropic thermal expansion tensor.
-
-        Parameters
-        ----------
-        alpha : float
-            Thermal expansion coefficient.
-
-        Returns
-        -------
-        ThermalExpansionTensor
-        """
-        return cls(np.eye(3)*alpha)
-
-    @classmethod
-    def orthotropic(cls, alpha_11, alpha_22, alpha_33):
-        """
-        Create an orthotropic thermal expansion tensor.
-
-        Parameters
-        ----------
-        alpha_11, alpha_22, alpha_33 : float
-            Thermal expansion coefficients along the first, second and third axes, respectively.
-
-        Returns
-        -------
-        ThermalExpansionTensor
-        """
-        return cls(np.diag([alpha_11, alpha_22, alpha_33]))
-
-    @classmethod
-    def orthorhombic(cls, *args):
-        """
-        Create a thermal expansion tensor corresponding to an orthotropic thermal expansion coefficient.
-
-        This function is an alias for orthotropic().
-
-        Parameters
-        ----------
-        args : list
-            Orthotropic thermal expansion coefficient.
-
-        Returns
-        -------
-        ThermalExpansionTensor
-
-        See Also
-        --------
-        orthotropic
-        """
-        return cls.orthotropic(*args)
-
-    @classmethod
-    def monoclinic(cls, alpha_11, alpha_22, alpha_33, alpha_13=None, alpha_12=None):
-        """
-        Create a thermal expansion tensor for monoclinic symmetry.
-
-        If alpha_13, the Diad || z is assumed. If alpha_12, the Diad || z is assumed. Therefore, these two parameters
-        are exclusive.
-
-        Parameters
-        ----------
-        alpha_11, alpha_22, alpha_33 : float
-            Thermal expansion coefficient along the first, second and third axes, respectively.
-        alpha_13 : float, optional
-            Thermal expansion coefficient corresponding to XZ shear (for Diad || y)
-        alpha_12: float, optional
-            Thermal expansion coefficient corresponding to XY shear (for Diad || z)
-
-        Returns
-        -------
-        ThermalExpansionTensor
-        """
-        matrix = np.diag([alpha_11, alpha_22, alpha_33])
-        if (alpha_13 is not None) and (alpha_12 is None):
-            matrix[0, 2] = matrix[2, 0]= alpha_13
-        elif (alpha_12 is not None) and (alpha_13 is None):
-            matrix[0, 1] = matrix[1, 0]= alpha_12
-        elif (alpha_13 is not None) and (alpha_12 is not None):
-            raise ValueError('alpha_13 and alpha_12 cannot be used together.')
-        else:
-            raise ValueError('Either alpha_13 or alpha_12 must be provided.')
-        return cls(matrix)
-
-
-    @classmethod
-    def triclinic(cls, alpha_11=0., alpha_12=0., alpha_13=0., alpha_22=0., alpha_23=0., alpha_33=0.):
-        """
-        Create a thermal expansion tensor for triclinic symmetry.
-
-        Parameters
-        ----------
-        alpha_11, alpha_12, alpha_13, alpha_22, alpha_23, alpha_33 : float
-            Values of the thermal expansion coefficients
-
-        Returns
-        -------
-        ThermalExpansionTensor
-        """
-        mat = [[alpha_11, alpha_12, alpha_13],
-               [alpha_12, alpha_22, alpha_23],
-               [alpha_13, alpha_23, alpha_33]]
-        return cls(mat)
-
-    @classmethod
-    def transverse_isotropic(cls, alpha_11, alpha_33):
-        """
-        Create a thermal expansion tensor for transverse isotropic symmetry.
-
-        Parameters
-        ----------
-        alpha_11 : float
-            Thermal expansion coefficient along the first and second axes
-        alpha_33 : float
-            Thermal expansion coefficient along the third axis
-
-        Returns
-        -------
-        ThermalExpansionTensor
-        """
-        return cls(np.diag([alpha_11, alpha_11, alpha_33]))
-
-    @property
-    def volumetric_coefficient(self):
-        """ Returns the volumetric thermal expansion coefficient."""
-        return self.I1
+class ThermalExpansionTensor(NewThermalExpansionTensor):
+    pass

Elasticipy/gui.py

@@ -1,15 +1,15 @@
 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
 )
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 from matplotlib.figure import Figure
 
-from Elasticipy.CrystalSymmetries import SYMMETRIES
-from Elasticipy.FourthOrderTensor import StiffnessTensor
+from Elasticipy.crystal_symmetries import SYMMETRIES
+from Elasticipy.tensors.elasticity import StiffnessTensor
 
 WHICH_OPTIONS = {'Mean': 'mean', 'Max': 'max', 'Min': 'min', 'Std. dev.': 'std'}
 

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)
+