elasticipy 4.1.1__py3-none-any.whl → 4.2.0__py3-none-any.whl

Elasticipy/tensors/elasticity.py

@@ -5,6 +5,7 @@ from Elasticipy.tensors.stress_strain import StrainTensor, StressTensor
 from Elasticipy.tensors.mapping import VoigtMapping, KelvinMapping
 import numpy as np
 import re
+from warnings import warn
 
 def _parse_tensor_components(prefix, **kwargs):
     pattern = r'^{}(\d{{2}})$'.format(prefix)
@@ -47,9 +48,9 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
     Class for manipulating fourth-order stiffness tensors.
     """
     tensor_name = 'Stiffness'
-    C11_C12_factor = 0.5
-    C46_C56_factor = 1.0
-    component_prefix = 'C'
+    _C11_C12_factor = 0.5
+    _C46_C56_factor = 1.0
+    _component_prefix = 'C'
 
     def __init__(self, M, symmetry='Triclinic', check_positive_definite=True, phase_name= None, mapping=VoigtMapping(), **kwargs):
         """
@@ -187,7 +188,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
     @classmethod
     def _matrixFromCrystalSymmetry(cls, symmetry='Triclinic', point_group=None, diad='y', prefix=None, **kwargs):
         if prefix is None:
-            prefix = cls.component_prefix
+            prefix = cls._component_prefix
         values = _parse_tensor_components(prefix, **kwargs)
         C = np.zeros((6, 6))
         symmetry = symmetry.capitalize()
@@ -228,17 +229,17 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         C11_C12 = symmetry_description.C11_C12
         if C11_C12:
             for index in C11_C12:
-                C[index] = (C[0, 0] - C[0, 1]) * cls.C11_C12_factor
+                C[index] = (C[0, 0] - C[0, 1]) * cls._C11_C12_factor
 
         if symmetry == 'Trigonal':
-            C[3, 5] = cls.C46_C56_factor * C[3, 5]
-            C[4, 5] = cls.C46_C56_factor * C[4, 5]
+            C[3, 5] = cls._C46_C56_factor * C[3, 5]
+            C[4, 5] = cls._C46_C56_factor * C[4, 5]
 
         return C + np.tril(C.T, -1)
 
     @classmethod
     def fromCrystalSymmetry(cls, symmetry='Triclinic', point_group=None, diad='y', phase_name=None, prefix=None,
-                            **kwargs):
+                             **kwargs):
         """
         Create a fourth-order tensor from limited number of components, taking advantage of crystallographic symmetries
 
@@ -311,8 +312,13 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         Phase: TiNi
         Symmetry: monoclinic
         """
-        matrix = cls._matrixFromCrystalSymmetry(point_group=point_group, diad=diad, symmetry=symmetry, prefix=prefix,
-                                                **kwargs)
+        warn('This function will be removed in a future release. Use {}.{}() instead'.format(cls.__name__,symmetry), DeprecationWarning, stacklevel=2)
+        return cls._fromCrystalSymmetry(symmetry=symmetry, point_group=point_group, diad=diad, phase_name=phase_name,
+                                       prefix=prefix, **kwargs)
+
+    @classmethod
+    def _fromCrystalSymmetry(cls, symmetry, phase_name, **kwargs):
+        matrix = cls._matrixFromCrystalSymmetry(symmetry=symmetry, **kwargs)
         return cls(matrix, phase_name=phase_name, symmetry=symmetry)
 
 
@@ -337,7 +343,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         cubic : create a tensor from cubic symmetry
         tetragonal : create a tensor from tetragonal symmetry
         """
-        return cls.fromCrystalSymmetry(symmetry='hexagonal', C11=C11, C12=C12, C13=C13, C33=C33, C44=C44,
+        return cls._fromCrystalSymmetry(symmetry='hexagonal', C11=C11, C12=C12, C13=C13, C33=C33, C44=C44,
                                        phase_name=phase_name, prefix='C')
 
     @classmethod
@@ -362,8 +368,9 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         tetragonal : create a tensor from tetragonal symmetry
         orthorhombic : create a tensor from orthorhombic symmetry
         """
-        return cls.fromCrystalSymmetry(point_group='3', C11=C11, C12=C12, C13=C13, C14=C14, C15=C15,
-                                       C33=C33, C44=C44, phase_name=phase_name, prefix='C')
+        return cls._fromCrystalSymmetry(symmetry='trigonal', point_group='3',
+                                        C11=C11, C12=C12, C13=C13, C14=C14, C15=C15,
+                                        C33=C33, C44=C44, phase_name=phase_name, prefix='C')
 
     @classmethod
     def tetragonal(cls, *, C11=0., C12=0., C13=0., C33=0., C44=0., C16=0., C66=0., phase_name=None):
@@ -388,8 +395,9 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         trigonal : create a tensor from trigonal symmetry
         orthorhombic : create a tensor from orthorhombic symmetry
         """
-        return cls.fromCrystalSymmetry(point_group='4', C11=C11, C12=C12, C13=C13, C16=C16,
-                                       C33=C33, C44=C44, C66=C66, phase_name=phase_name, prefix='C')
+        return cls._fromCrystalSymmetry(symmetry='tetragonal', point_group='4',
+                                        C11=C11, C12=C12, C13=C13, C16=C16,
+                                        C33=C33, C44=C44, C66=C66, phase_name=phase_name, prefix='C')
 
     @classmethod
     def cubic(cls, *, C11=0., C12=0., C44=0., phase_name=None):
@@ -411,7 +419,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         hexagonal : create a tensor from hexagonal symmetry
         orthorhombic : create a tensor from orthorhombic symmetry
         """
-        return cls.fromCrystalSymmetry(symmetry='cubic', C11=C11, C12=C12, C44=C44, phase_name=phase_name, prefix='C')
+        return cls._fromCrystalSymmetry(symmetry='cubic', C11=C11, C12=C12, C44=C44, phase_name=phase_name, prefix='C')
 
     @classmethod
     def orthorhombic(cls, *, C11=0., C12=0., C13=0., C22=0., C23=0., C33=0., C44=0., C55=0., C66=0., phase_name=None):
@@ -434,7 +442,7 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         monoclinic : create a tensor from monoclinic symmetry
         orthorhombic : create a tensor from orthorhombic symmetry
         """
-        return cls.fromCrystalSymmetry(symmetry='orthorhombic',
+        return cls._fromCrystalSymmetry(symmetry='orthorhombic',
                                        C11=C11, C12=C12, C13=C13, C22=C22, C23=C23, C33=C33, C44=C44, C55=C55, C66=C66,
                                        phase_name=phase_name, prefix='C')
 
@@ -487,12 +495,12 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         if diad_y and diad_z:
             raise KeyError('Ambiguous diad. Provide either C15, C25, C35 and C46; or C16, C26, C36 and C45')
         elif diad_y:
-            return cls.fromCrystalSymmetry(symmetry='monoclinic', diad='y',
+            return cls._fromCrystalSymmetry(symmetry='monoclinic', diad='y',
                                            C11=C11, C12=C12, C13=C13, C22=C22, C23=C23, C33=C33, C44=C44, C55=C55,
                                            C66=C66,
                                            C15=C15, C25=C25, C35=C35, C46=C46, phase_name=phase_name, prefix='C')
         elif diad_z:
-            return cls.fromCrystalSymmetry(symmetry='monoclinic', diad='z',
+            return cls._fromCrystalSymmetry(symmetry='monoclinic', diad='z',
                                            C11=C11, C12=C12, C13=C13, C22=C22, C23=C23, C33=C33, C44=C44, C55=C55,
                                            C66=C66,
                                            C16=C16, C26=C26, C36=C36, C45=C45, phase_name=phase_name, prefix='C')
@@ -653,6 +661,51 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         """
         return self.inv().bulk_modulus
 
+    @property
+    def lame1(self):
+        """"
+        Compute the first Lamé's parameter (only for isotropic materials).
+
+        If the stiffness/compliance tensor is not isotropic, NaN is returned.
+
+        Returns
+        -------
+        float
+            First Lamé's parameter
+
+        See Also
+        --------
+        lame2 : second Lamé's parameter
+        """
+        self._single_tensor_only('lame1')
+        if self.is_isotropic():
+            C11 = (self.C11 + self.C22 + self.C33) / 3
+            return C11 - 2 * self.lame2
+        else:
+            return np.nan
+
+    @property
+    def lame2(self):
+        """"
+        Compute the second Lamé's parameter (only for isotropic materials).
+
+        If the stiffness/compliance tensor is not isotropic, NaN is returned.
+
+        Returns
+        -------
+        float
+            Second Lamé's parameter
+
+        See Also
+        --------
+        lame1 : first Lamé's parameter
+        """
+        self._single_tensor_only('lame2')
+        if self.is_isotropic():
+            return (self.C44 + self.C55 + self.C66) / 3
+        else:
+            return np.nan
+
     def Voigt_average(self, axis=None):
         """
         Compute the Voigt average of the stiffness tensor.
@@ -768,10 +821,10 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
             raise NotImplementedError('Only Voigt, Reus, and Hill are implemented.')
 
     @classmethod
-    def isotropic(cls, E=None, nu=None, lame1=None, lame2=None, phase_name=None):
+    def isotropic(cls, E=None, nu=None, G=None, lame1=None, lame2=None, K=None, phase_name=None):
         """
-        Create an isotropic stiffness tensor from two elasticity coefficients, namely: E, nu, lame1, or lame2. Exactly
-        two of these coefficients must be provided.
+        Create an isotropic stiffness tensor from two elasticity coefficients, namely: E, nu, G, lame1, or lame2.
+        Exactly two of these coefficients must be provided. Note that lame2 is just an alias for G.
 
         Parameters
         ----------
@@ -779,10 +832,14 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
             Young modulus
         nu : float, None
             Poisson ratio
+        G : float, None
+            Shear modulus
         lame1 : float, None
             First Lamé coefficient
         lame2 : float, None
-            Second Lamé coefficient
+            Second Lamé coefficient (alias for G)
+        K : float, None
+            Bulk modulus
         phase_name : str, None
             Name to print
 
@@ -808,34 +865,9 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         >>> C=StiffnessTensor.isotropic(E=210e3, nu=0.28)
         >>> C.shear_modulus
         Hyperspherical function
-        Min=82031.24999999997, Max=82031.25000000006
-        """
-        argument_vector = np.array([E, nu, lame1, lame2])
-        if np.count_nonzero(argument_vector) != 2:
-            raise ValueError("Exactly two values are required among E, nu, lame1 and lame2.")
-        if E is not None:
-            if nu is not None:
-                lame1 = E * nu / ((1 + nu) * (1 - 2 * nu))
-                lame2 = E / (1 + nu) / 2
-            elif lame1 is not None:
-                R = np.sqrt(E ** 2 + 9 * lame1 ** 2 + 2 * E * lame1)
-                lame2 = (E - 3 * lame1 + R) / 4
-            elif lame2 is not None:
-                lame1 = lame2 * (E - 2 * lame2) / (3 * lame2 - E)
-            else:
-                raise ValueError('Either nu, lame1 or lame2 must be provided.')
-        elif nu is not None:
-            if lame1 is not None:
-                lame2 = lame1 * (1 - 2 * nu) / (2 * nu)
-            elif lame2 is not None:
-                lame1 = 2 * lame2 * nu / (1 - 2 * nu)
-            else:
-                raise ValueError('Either lame1 or lame2 must be provided.')
-        C11 = lame1 + 2 * lame2
-        C12 = lame1
-        C44 = lame2
-        matrix = _isotropic_matrix(C11, C12, C44)
-        return StiffnessTensor(np.array(matrix), symmetry='isotropic', phase_name=phase_name)
+        Min=82031.24999999991, Max=82031.25000000006
+        """
+        return ComplianceTensor.isotropic(E=E, nu=nu, G=G, lame1=lame1, lame2=lame2, K=K, phase_name=phase_name).inv()
 
     @classmethod
     def orthotropic(cls, *, Ex, Ey, Ez, Gxy, Gxz, Gyz,
@@ -894,17 +926,9 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
             \\frac{\\nu_{xy}}{E_x} = \\frac{\\nu_{yx}}{E_y}
 
         """
-        nu_yx = _switch_poisson_ratios(nu_xy, nu_yx, Ex, Ey,'xy')
-        nu_zx = _switch_poisson_ratios(nu_xz, nu_zx, Ex, Ez,'xz')
-        nu_zy = _switch_poisson_ratios(nu_yz, nu_zy, Ey, Ez,'yz')
-        tri_sup = np.array([[1 / Ex, -nu_yx / Ey, -nu_zx / Ez, 0, 0, 0],
-                            [0, 1 / Ey, -nu_zy / Ez, 0, 0, 0],
-                            [0, 0, 1 / Ez, 0, 0, 0],
-                            [0, 0, 0, 1 / Gyz, 0, 0],
-                            [0, 0, 0, 0, 1 / Gxz, 0],
-                            [0, 0, 0, 0, 0, 1 / Gxy]])
-        S = tri_sup + np.tril(tri_sup.T, -1)
-        return StiffnessTensor(np.linalg.inv(S), symmetry='orthotropic', **kwargs)
+        return ComplianceTensor.orthotropic(Ex=Ex, Ey=Ey, Ez=Ez, Gxy=Gxy, Gxz=Gxz, Gyz=Gyz,
+                                            nu_yx=nu_yx, nu_zx=nu_zx, nu_zy=nu_zy,
+                                            nu_xy=nu_xy, nu_xz=nu_xz, nu_yz=nu_yz).inv()
 
     @classmethod
     def transverse_isotropic(cls, *, Ex, Ez, Gxz, nu_yx=None, nu_xy=None, nu_zx=None, nu_xz=None, **kwargs):
@@ -1045,13 +1069,8 @@ class StiffnessTensor(SymmetricFourthOrderTensor):
         def make_fun(index):
             def fun(n):
                 Gamma = self.Christoffel_tensor(n)
-                eig, _ = np.linalg.eig(Gamma)
-                if index == 0:
-                    eig_of_interest = np.max(eig, axis=-1)
-                elif index == 1:
-                    eig_of_interest = np.median(eig, axis=-1)
-                else:
-                    eig_of_interest = np.min(eig, axis=-1)
+                eig, _ = np.linalg.eigh(Gamma)
+                eig_of_interest = eig[...,2-index]  # Switch ordering (descending order)
                 return np.sqrt(eig_of_interest / rho)
 
             return fun
@@ -1573,9 +1592,9 @@ class ComplianceTensor(StiffnessTensor):
     Class for manipulating compliance tensors
     """
     tensor_name = 'Compliance'
-    C11_C12_factor = 2.0
-    component_prefix = 'S'
-    C46_C56_factor = 2.0
+    _C11_C12_factor = 2.0
+    _component_prefix = 'S'
+    _C46_C56_factor = 2.0
 
     def __init__(self, C, check_positive_definite=True, mapping=VoigtMapping(tensor='Compliance'), **kwargs):
         super().__init__(C, check_positive_definite=check_positive_definite, mapping=mapping, **kwargs)
@@ -1623,12 +1642,68 @@ class ComplianceTensor(StiffnessTensor):
         return self.inv().Hill_average(axis=axis).inv()
 
     @classmethod
-    def isotropic(cls, E=None, nu=None, lame1=None, lame2=None, phase_name=None):
-        return super().isotropic(E=E, nu=nu, lame1=lame1, lame2=lame2, phase_name=None).inv()
+    def isotropic(cls, E=None, nu=None, G=None, lame1=None, lame2=None, K=None, phase_name=None):
+        if lame2 is not None:
+            if G is None:
+                G = lame2
+            else:
+                raise ValueError('G and lame2 cannot be provided together.')
+        n_specified = sum(v is not None for v in [E, nu, lame1, G, K])
+        if n_specified != 2:
+            raise ValueError("Exactly two values are required among E, nu, G, K, lame1 and lame2.")
+        if K is not None:
+            if E is not None:
+                G = 3 * K * E / (9 * K - E)
+                nu = (3 * K - E) / 6 / K
+            elif lame1 is not None:
+                E = 9 * K * (K - lame1) / (3 * K -lame1)
+                G= 3 * (K - lame1) / 2
+                nu = lame1 / (3*K-lame1)
+            elif G is not None:
+                E = 9 * K * G / (3 * K + G)
+                nu = (3 * K - 2 * G) / 2 / (3 * K + G)
+            elif nu is not None:
+                E = 3 * K * (1 - 2 * nu)
+                G = E / 2 / (1 + nu)
+        elif E is not None:
+            if lame1 is not None:
+                R = np.sqrt(E**2 + 9*lame1**2+2*E*lame1)
+                G = (E - 3 * lame1 + R) / 4
+                nu = 2 * lame1 / (E + lame1 + R)
+            elif G is not None:
+                nu = E / 2 / G - 1
+            elif nu is not None:
+                G = E / 2 / (1 + nu)
+        elif lame1 is not None:
+            if G is not None:
+                E = G * (3 * lame1 + 2 * G) / (lame1 + G)
+                nu = lame1 / 2 / (lame1 + G)
+            elif nu is not None:
+                E = lame1 * ( 1 + nu) * (1 - 2 * nu) / nu
+                G = lame1 * (1 - 2 * nu) / 2 / nu
+        elif (nu is not None) and (G is not None):
+            E = 2 * G * (1 + nu)
+        S11 = 1/E
+        S12 = -nu/E
+        S44 = 1 / G
+        S_mat = _isotropic_matrix(S11, S12, S44)
+        return ComplianceTensor(S_mat, symmetry='isotropic', phase_name=phase_name)
 
     @classmethod
-    def orthotropic(cls, *args, **kwargs):
-        return super().orthotropic(*args, **kwargs).inv()
+    def orthotropic(cls, *, Ex, Ey, Ez, Gxy, Gxz, Gyz,
+                    nu_yx=None, nu_zx=None, nu_zy=None,
+                    nu_xy=None, nu_xz=None, nu_yz=None, **kwargs):
+        nu_yx = _switch_poisson_ratios(nu_xy, nu_yx, Ex, Ey,'xy')
+        nu_zx = _switch_poisson_ratios(nu_xz, nu_zx, Ex, Ez,'xz')
+        nu_zy = _switch_poisson_ratios(nu_yz, nu_zy, Ey, Ez,'yz')
+        tri_sup = np.array([[1 / Ex, -nu_yx / Ey, -nu_zx / Ez, 0, 0, 0],
+                            [0, 1 / Ey, -nu_zy / Ez, 0, 0, 0],
+                            [0, 0, 1 / Ez, 0, 0, 0],
+                            [0, 0, 0, 1 / Gyz, 0, 0],
+                            [0, 0, 0, 0, 1 / Gxz, 0],
+                            [0, 0, 0, 0, 0, 1 / Gxy]])
+        S = tri_sup + np.tril(tri_sup.T, -1)
+        return ComplianceTensor(S, symmetry='orthotropic', **kwargs)
 
     @classmethod
     def transverse_isotropic(cls, *args, **kwargs):
@@ -1745,4 +1820,232 @@ class ComplianceTensor(StiffnessTensor):
         --------
         eig_compliances : compute the eigencompliances from the Kelvin's matrix of compliance
         """
-        return 1/self.eig_compliances
+        return 1/self.eig_compliances
+
+    @property
+    def lame1(self):
+        return self.inv().lame1
+
+    @property
+    def lame2(self):
+        return self.inv().lame2
+
+
+    @classmethod
+    def hexagonal(cls, *, S11=0., S12=0., S13=0., S33=0., S44=0., phase_name=None):
+        """
+        Create a fourth-order tensor from hexagonal symmetry.
+
+        Parameters
+        ----------
+        S11, S12 , S13, S33, S44 : float
+            Components of the tensor, using the Voigt notation
+        phase_name : str, optional
+            Phase name to display
+        Returns
+        -------
+        FourthOrderTensor
+
+        See Also
+        --------
+        transverse_isotropic : creates a transverse-isotropic tensor from engineering parameters
+        cubic : create a tensor from cubic symmetry
+        tetragonal : create a tensor from tetragonal symmetry
+        """
+        return cls._fromCrystalSymmetry(symmetry='hexagonal', S11=S11, S12=S12, S13=S13, S33=S33, S44=S44,
+                                       phase_name=phase_name, prefix='S')
+
+    @classmethod
+    def trigonal(cls, *, S11=0., S12=0., S13=0., S14=0., S33=0., S44=0., S15=0., phase_name=None):
+        """
+        Create a fourth-order tensor from trigonal symmetry.
+
+        Parameters
+        ----------
+        S11, S12, S13, S14, S33, S44 : float
+            Components of the tensor, using the Voigt notation
+        S15 : float, optional
+            S15 component of the tensor, only used for point groups 3 and -3.
+        phase_name : str, optional
+            Phase name to display
+        Returns
+        -------
+        FourthOrderTensor
+
+        See Also
+        --------
+        tetragonal : create a tensor from tetragonal symmetry
+        orthorhombic : create a tensor from orthorhombic symmetry
+        """
+        return cls._fromCrystalSymmetry(symmetry='trigonal', point_group='3',
+                                        S11=S11, S12=S12, S13=S13, S14=S14, S15=S15,
+                                        S33=S33, S44=S44, phase_name=phase_name, prefix='S')
+
+    @classmethod
+    def tetragonal(cls, *, S11=0., S12=0., S13=0., S33=0., S44=0., S16=0., S66=0., phase_name=None):
+        """
+        Create a fourth-order tensor from tetragonal symmetry.
+
+        Parameters
+        ----------
+        S11,  S12, S13, S33, S44, S66 : float
+            Components of the tensor, using the Voigt notation
+        S16 : float, optional
+            S16 component in Voigt notation (for point groups 4, -4 and 4/m only)
+        phase_name : str, optional
+            Phase name to display
+
+        Returns
+        -------
+        FourthOrderTensor
+
+        See Also
+        --------
+        trigonal : create a tensor from trigonal symmetry
+        orthorhombic : create a tensor from orthorhombic symmetry
+        """
+        return cls._fromCrystalSymmetry(symmetry='tetragonal', point_group='4',
+                                        S11=S11, S12=S12, S13=S13, S16=S16,
+                                        S33=S33, S44=S44, S66=S66, phase_name=phase_name, prefix='S')
+
+    @classmethod
+    def cubic(cls, *, S11=0., S12=0., S44=0., phase_name=None):
+        """
+        Create a fourth-order tensor from cubic symmetry.
+
+        Parameters
+        ----------
+        S11 , S12, S44 : float
+        phase_name : str, optional
+            Phase name to display
+
+        Returns
+        -------
+        StiffnessTensor
+
+        See Also
+        --------
+        hexagonal : create a tensor from hexagonal symmetry
+        orthorhombic : create a tensor from orthorhombic symmetry
+        """
+        return cls._fromCrystalSymmetry(symmetry='cubic', S11=S11, S12=S12, S44=S44, phase_name=phase_name, prefix='S')
+
+    @classmethod
+    def orthorhombic(cls, *, S11=0., S12=0., S13=0., S22=0., S23=0., S33=0., S44=0., S55=0., S66=0., phase_name=None):
+        """
+        Create a fourth-order tensor from orthorhombic symmetry.
+
+        Parameters
+        ----------
+        S11, S12, S13, S22, S23, S33, S44, S55, S66 : float
+            Components of the tensor, using the Voigt notation
+        phase_name : str, optional
+            Phase name to display
+
+        Returns
+        -------
+        FourthOrderTensor
+
+        See Also
+        --------
+        monoclinic : create a tensor from monoclinic symmetry
+        orthorhombic : create a tensor from orthorhombic symmetry
+        """
+        return cls._fromCrystalSymmetry(symmetry='orthorhombic',
+                                       S11=S11, S12=S12, S13=S13, S22=S22, S23=S23, S33=S33, S44=S44, S55=S55, S66=S66,
+                                       phase_name=phase_name, prefix='S')
+
+    @classmethod
+    def monoclinic(cls, *, S11=0., S12=0., S13=0., S22=0., S23=0., S33=0., S44=0., S55=0., S66=0.,
+                   S15=None, S25=None, S35=None, S46=None,
+                   S16=None, S26=None, S36=None, S45=None,
+                   phase_name=None):
+        """
+        Create a fourth-order tensor from monoclinic symmetry. It automatically detects whether the components are given
+        according to the Y or Z diad, depending on the input arguments.
+
+        For Diad || y, S15, S25, S35 and S46 must be provided.
+        For Diad || z, S16, S26, S36 and S45 must be provided.
+
+        Parameters
+        ----------
+        S11, S12 , S13, S22, S23, S33, S44, S55, S66 : float
+            Components of the tensor, using the Voigt notation
+        S15 : float, optional
+            S15 component of the tensor (if Diad || y)
+        S25 : float, optional
+            S25 component of the tensor (if Diad || y)
+        S35 : float, optional
+            S35 component of the tensor (if Diad || y)
+        S46 : float, optional
+            S46 component of the tensor (if Diad || y)
+        S16 : float, optional
+            S16 component of the tensor (if Diad || z)
+        S26 : float, optional
+            S26 component of the tensor (if Diad || z)
+        S36 : float, optional
+            S36 component of the tensor (if Diad || z)
+        S45 : float, optional
+            S45 component of the tensor (if Diad || z)
+        phase_name : str, optional
+            Name to display
+
+        Returns
+        -------
+        FourthOrderTensor
+
+        See Also
+        --------
+        triclinic : create a tensor from triclinic symmetry
+        orthorhombic : create a tensor from orthorhombic symmetry
+        """
+        diad_y = not (None in (S15, S25, S35, S46))
+        diad_z = not (None in (S16, S26, S36, S45))
+        if diad_y and diad_z:
+            raise KeyError('Ambiguous diad. Provide either S15, S25, S35 and S46; or S16, S26, S36 and S45')
+        elif diad_y:
+            return cls._fromCrystalSymmetry(symmetry='monoclinic', diad='y',
+                                           S11=S11, S12=S12, S13=S13, S22=S22, S23=S23, S33=S33, S44=S44, S55=S55,
+                                           S66=S66,
+                                           S15=S15, S25=S25, S35=S35, S46=S46, phase_name=phase_name, prefix='S')
+        elif diad_z:
+            return cls._fromCrystalSymmetry(symmetry='monoclinic', diad='z',
+                                           S11=S11, S12=S12, S13=S13, S22=S22, S23=S23, S33=S33, S44=S44, S55=S55,
+                                           S66=S66,
+                                           S16=S16, S26=S26, S36=S36, S45=S45, phase_name=phase_name, prefix='S')
+        else:
+            raise KeyError('For monoclinic symmetry, one should provide either S15, S25, S35 and S46, '
+                           'or S16, S26, S36 and S45.')
+
+    @classmethod
+    def triclinic(cls, S11=0., S12=0., S13=0., S14=0., S15=0., S16=0.,
+                  S22=0., S23=0., C24=0., S25=0., S26=0.,
+                  S33=0., C34=0., S35=0., S36=0.,
+                  S44=0., S45=0., S46=0.,
+                  S55=0., C56=0.,
+                  S66=0., phase_name=None):
+        """
+
+        Parameters
+        ----------
+        S11 , S12 , S13 , S14 , S15 , S16 , S22 , S23 , C24 , S25 , S26 , S33 , C34 , S35 , S36 , S44 , S45 , S46 , S55 , C56 , S66 : float
+            Components of the tensor
+        phase_name : str, optional
+            Name to display
+
+        Returns
+        -------
+        FourthOrderTensor
+
+        See Also
+        --------
+        monoclinic : create a tensor from monoclinic symmetry
+        orthorhombic : create a tensor from orthorhombic symmetry
+        """
+        matrix = np.array([[S11, S12, S13, S14, S15, S16],
+                           [S12, S22, S23, C24, S25, S26],
+                           [S13, S23, S33, C34, S35, S36],
+                           [S14, C24, C34, S44, S45, S46],
+                           [S15, S25, S35, S45, S55, C56],
+                           [S16, S26, S36, S46, C56, S66]])
+        return cls(matrix, phase_name=phase_name)

{elasticipy-4.1.1.dist-info → elasticipy-4.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elasticipy
-Version: 4.1.1
+Version: 4.2.0
 Summary: A Python library for elasticity tensor computations
 Author-email: Dorian Depriester <dorian.dep@gmail.com>
 License: MIT
@@ -12,7 +12,6 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 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.11
@@ -40,6 +39,7 @@ Dynamic: license-file
 [![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)
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/DorianDepriester/Elasticipy/HEAD?urlpath=%2Fdoc%2Ftree%2FElasticipy_for_the_Impatient.ipynb)
 
 # ![Elasticipy](docs/source/logo/logo_text.svg)
 

{elasticipy-4.1.1.dist-info → elasticipy-4.2.0.dist-info}/RECORD

@@ -10,14 +10,14 @@ Elasticipy/spherical_function.py,sha256=Mnb4Cj2eyMCtr7X3mesqESml3BMA_JYT2H3eTZO-
 Elasticipy/interfaces/FEPX.py,sha256=MleuKz3JvjhvECIcg2q1taV0J1TzoiTrrtLeRRYI9Hs,4234
 Elasticipy/interfaces/PRISMS.py,sha256=jAHFS2ybbAK2ZcqF9AmnlDTR2JZZMwlgy-FhQIINSAI,3835
 Elasticipy/tensors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-Elasticipy/tensors/elasticity.py,sha256=vgpPA1FkehKuvSnPq4KEvddXpPgka1wGsp3AdjAdMB8,65000
+Elasticipy/tensors/elasticity.py,sha256=MYJwbk_fjd3Zo8qdIkZ6atBuM5khEWXgPcFqnzACnwM,76393
 Elasticipy/tensors/fourth_order.py,sha256=ouptzPiWx5W6t9dYWfLY8lTVTj5ahnuB4mmBUIgLycs,23136
 Elasticipy/tensors/mapping.py,sha256=f-jwvCE2V3bgesIOyeC-vgqVCFJetlUviEAoaBE7yPA,1442
 Elasticipy/tensors/second_order.py,sha256=6jQiIfGgmW7OsBvhPEXeRXjIcuslqejFHmGjHdYaMsQ,55728
 Elasticipy/tensors/stress_strain.py,sha256=RysKDHe-PV2dpdrO7cNT1_UBP8bYYCbWxz3H9w9GuPo,3954
 Elasticipy/tensors/thermal_expansion.py,sha256=XZ9e8Sn9vsLGVh79TrBQoBOkXMg8qF3pShiPSzix4q0,8634
-elasticipy-4.1.1.dist-info/licenses/LICENSE,sha256=qNthTMSjVkIDM1_BREgVFQHdn1wVNQi9pwWVfTIazMA,1074
-elasticipy-4.1.1.dist-info/METADATA,sha256=3OJs1eydCV7Q_L-vQd57Q1c1x-CmSRst4L5S4QYZKF4,4487
-elasticipy-4.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-elasticipy-4.1.1.dist-info/top_level.txt,sha256=k4zSQzJR5P4vzlHlhWUaxNgvgloq4KIp8oca2X8gQOw,11
-elasticipy-4.1.1.dist-info/RECORD,,
+elasticipy-4.2.0.dist-info/licenses/LICENSE,sha256=qNthTMSjVkIDM1_BREgVFQHdn1wVNQi9pwWVfTIazMA,1074
+elasticipy-4.2.0.dist-info/METADATA,sha256=WhpptfQ8jWqIvdoG5ikCnkuhwpwAinRIj6mXFAy6J90,4605
+elasticipy-4.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+elasticipy-4.2.0.dist-info/top_level.txt,sha256=k4zSQzJR5P4vzlHlhWUaxNgvgloq4KIp8oca2X8gQOw,11
+elasticipy-4.2.0.dist-info/RECORD,,