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

Elasticipy/gui.py

@@ -128,9 +128,84 @@ class ElasticityGUI(QMainWindow):
         self.calculate_button.clicked.connect(self.calculate_and_plot)
         left_panel_layout.addWidget(self.calculate_button)
 
+        # Add horizontal separator
+        separator = QFrame()
+        separator.setFrameShape(QFrame.HLine)
+        separator.setFrameShadow(QFrame.Sunken)
+        left_panel_layout.addWidget(separator)
+
+        ############################################
+        # Numeric results
+        ############################################
+        self.result_labels = {}
+        RESULT_GROUPS = {
+            "Young modulus": [
+                ("E_mean", "Mean"),
+                ("E_voigt", "Voigt"),
+                ("E_reuss", "Reuss"),
+                ("E_hill", "Hill"),
+            ],
+            "Shear modulus": [
+                ("G_mean", "Mean"),
+                ("G_voigt", "Voigt"),
+                ("G_reuss", "Reuss"),
+                ("G_hill", "Hill"),
+            ],
+            "Poisson ratio": [
+                ("nu_mean", "Mean"),
+                ("nu_voigt", "Voigt"),
+                ("nu_reuss", "Reuss"),
+                ("nu_hill", "Hill"),
+            ],
+            "Linear compressibility": [
+                ("Beta_mean", "Mean"),
+                ("Beta_voigt", "Voigt"),
+                ("Beta_reuss", "Reuss"),
+                ("Beta_hill", "Hill"),
+            ],
+            "Other": [
+                ("K", "Bulk modulus"),
+                ("Z", "Zener ratio"),
+                ("A", "Univ. anisotropy factor"),
+            ]
+        }
+
+        ############################################
+        # Numeric results (grouped)
+        ############################################
+        self.result_labels = {}
+        for group_name, items in RESULT_GROUPS.items():
+
+            # Group title
+            group_label = QLabel(group_name + ":")
+            group_label.setStyleSheet("font-weight: bold; margin-top: 6px;")
+            left_panel_layout.addWidget(group_label)
+
+            # Indented layout
+            indent_layout = QVBoxLayout()
+            indent_layout.setContentsMargins(15, 0, 0, 0)
+
+            for key, label_text in items:
+                row = QHBoxLayout()
+
+                label_name = QLabel(f"{label_text}:")
+                label_value = QLabel("—")
+                label_value.setMinimumWidth(100)
+                label_value.setStyleSheet("font-family: Consolas, Courier;")
+
+                self.result_labels[key] = label_value
+
+                row.addWidget(label_name)
+                row.addStretch()
+                row.addWidget(label_value)
+
+                indent_layout.addLayout(row)
+
+            left_panel_layout.addLayout(indent_layout)
+
         # Fill space
         left_panel_layout.addStretch()
-        bottom_layout.addLayout(left_panel_layout)
+        bottom_layout.addLayout(left_panel_layout,1)
 
         ############################################
         # Plotting area
@@ -143,7 +218,7 @@ class ElasticityGUI(QMainWindow):
 
         self.figure = Figure()
         self.canvas = FigureCanvas(self.figure)
-        bottom_layout.addWidget(self.canvas)
+        bottom_layout.addWidget(self.canvas,4)
 
         #######################################################################################
         # Main widget
@@ -160,6 +235,8 @@ class ElasticityGUI(QMainWindow):
         self.plotting_selector.setCurrentText('Young modulus')
         self.which_selector.setEnabled(False)
 
+        self.C_matrix = np.zeros((6, 6))
+
     def update_fields(self):
         # Deactivate unused fields
         active_fields = self.selected_symmetry().required
@@ -226,6 +303,25 @@ class ElasticityGUI(QMainWindow):
             else:
                 value.plot_as_pole_figure(fig=self.figure, **plot_kwargs)
             self.canvas.draw()
+            if not np.all(self.C_matrix == Csym):
+                self.result_labels["E_mean"].setText(f"{stiff.Young_modulus.mean():.3f}")
+                self.result_labels["G_mean"].setText(f"{stiff.shear_modulus.mean():.3f}")
+                self.result_labels["nu_mean"].setText(f"{stiff.Poisson_ratio.mean():.3f}")
+                self.result_labels["Beta_mean"].setText(f"{stiff.linear_compressibility.mean():.3f}")
+                for method in ['voigt', 'reuss', 'hill']:
+                    C = stiff.average(method=method)
+                    self.result_labels[f"E_{method}"].setText(f"{C.Young_modulus.eval([1,0,0]):.3f}")
+                    self.result_labels[f"G_{method}"].setText(f"{C.shear_modulus.eval([1, 0, 0],[0,1,0]):.3f}")
+                    self.result_labels[f"nu_{method}"].setText(f"{C.Poisson_ratio.eval([1, 0, 0], [0, 1, 0]):.3f}")
+                    self.result_labels[f"Beta_{method}"].setText(f"{C.linear_compressibility.eval([1, 0, 0]):.3f}")
+                self.result_labels["K"].setText(f"{stiff.bulk_modulus:.3f}")
+                try:
+                    Z = stiff.Zener_ratio()
+                    self.result_labels["Z"].setText(f"{stiff.Zener_ratio():.3f}")
+                except ValueError:
+                    self.result_labels["Z"].setText("—")
+                self.result_labels["A"].setText(f"{stiff.universal_anisotropy:.3f}")
+                self.C_matrix = Csym
 
         except ValueError as inst:
             QMessageBox.critical(self, "Singular stiffness", inst.__str__(), QMessageBox.Ok)
@@ -261,3 +357,6 @@ def crystal_elastic_plotter():
     window = ElasticityGUI()
     window.show()
     sys.exit(app.exec_())
+
+if __name__ == "__main__":
+    crystal_elastic_plotter()

Elasticipy/interfaces/FEPX.py

@@ -90,14 +90,14 @@ def from_results_folder(folder, dtype=None):
           - SecondOrderTensor
           - SymmetricSecondOrderTensor
           - SkewSymmetricSecondOrderTensor
-          - stressTensor
-          - strainTensor
+          - 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.
+        of time increment n is the number of elements in the mesh.
     """
     dir_path = Path(folder)
     folder_name = dir_path.name

Elasticipy/plasticity.py

@@ -37,11 +37,47 @@ class IsotropicHardening:
                 ' current strain: {}'.format(self.plastic_strain))
 
     def flow_stress(self, strain, **kwargs):
+        """
+        Compute the stress from the cumulative plastic strain
+
+        Parameters
+        ----------
+        strain : float
+            Equivalent Plastic strain
+        kwargs
+            Additional arguments passed to the function
+
+        Returns
+        -------
+        float or np.ndarray
+
+        Examples
+        --------
+        As an example, we consider a Jonhson-Cook model:
+
+        >>> from Elasticipy.plasticity import JohnsonCook
+        >>> JC = JohnsonCook(A=792, B=510, n=0.26)
+        >>> print(JC)
+        Johnson-Cook plasticity model
+         type: Isotropic
+         criterion: von Mises
+         current strain: 0.0
+
+        >>> JC.flow_stress(0.0) # Check that the yield stress = A
+        792.0
+
+        In order to get the full tensile curve in 0 to 10% strain range:
+
+        >>> import numpy as np
+        >>> JC.flow_stress(np.linspace(0,0.1,5)) # Check that the yield stress = B
+        array([ 792.        ,  987.44950657, 1026.04662195, 1052.067513  ,
+               1072.26584567])
+        """
         pass
 
     def apply_strain(self, strain, **kwargs):
         """
-        Apply strain to the current JC model.
+        Apply strain to the current plasticity model.
 
         This function updates the internal variable to store hardening state.
 
@@ -59,6 +95,38 @@ class IsotropicHardening:
         See Also
         --------
         flow_stress : compute the flow stress, given a cumulative equivalent strain
+
+        Examples
+        --------
+        As an example, we consider the Johnson-Cook plasticity model:
+
+        >>> from Elasticipy.plasticity import JohnsonCook
+        >>> JC = JohnsonCook(A=792, B=510, n=0.26)
+        >>> print(JC)
+        Johnson-Cook plasticity model
+         type: Isotropic
+         criterion: von Mises
+         current strain: 0.0
+
+        >>> stress = JC.apply_strain(0.1)
+        >>> print(stress)
+        1072.2658456673885
+        >>> print(JC)
+        Johnson-Cook plasticity model
+         type: Isotropic
+         criterion: von Mises
+         current strain: 0.1
+
+        Obvisously, the applied strain is cumulative:
+
+        >>> stress = JC.apply_strain(0.1)
+        >>> print(stress)
+        1127.612381818713
+        >>> print(JC)
+        Johnson-Cook plasticity model
+         type: Isotropic
+         criterion: von Mises
+         current strain: 0.2
         """
         if isinstance(strain, float):
             self.plastic_strain += np.abs(strain)
@@ -68,10 +136,112 @@ class IsotropicHardening:
             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 compute_strain_increment(self, stress, criterion='von Mises', apply_strain=True, **kwargs):
+        """
+        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.
+        apply_strain : bool, optional
+            If true, the plasticity 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'.
+        kwargs
+            Keyword arguments passed to the model
+
+        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
+
+        Examples
+        --------
+        As an example, we consider the Johnson-Cook plasticity model:
+
+        >>> from Elasticipy.plasticity import JohnsonCook
+        >>> JC = JohnsonCook(A=792, B=510, n=0.26)
+
+        The yield stress is equal to A here. So consider a tensile stress whose magnitude below A:
+
+        >>> from Elasticipy.tensors.stress_strain import StressTensor
+        >>> sigma = StressTensor.tensile([1,0,0], 700)
+        >>> strain_inc = JC.compute_strain_increment(sigma)
+        >>> print(strain_inc)
+        Strain tensor
+        [[ 0.  0.  0.]
+         [ 0. -0.  0.]
+         [ 0.  0. -0.]]
+
+        whereas if the stress is larger than A:
+
+        >>> sigma = StressTensor.tensile([1,0,0], 800)
+        >>> strain_inc = JC.compute_strain_increment(sigma)
+        >>> print(strain_inc)
+        Strain tensor
+        [[ 1.14733854e-07  0.00000000e+00  0.00000000e+00]
+         [ 0.00000000e+00 -5.73669268e-08  0.00000000e+00]
+         [ 0.00000000e+00  0.00000000e+00 -5.73669268e-08]]
+
+        Check out that the JC model has been updated:
+
+        >>> print(JC)
+        Johnson-Cook plasticity model
+         type: Isotropic
+         criterion: von Mises
+         current strain: 1.1473385353505149e-07
+
+        Therefore, the yield stress has increased because of hardening. For instance, if we apply the same stress has
+        before, we get:
+
+        >>> JC.compute_strain_increment(sigma)
+        Strain tensor
+        [[ 0.  0.  0.]
+         [ 0. -0.  0.]
+         [ 0.  0. -0.]]
+        """
 
     def reset_strain(self):
+        """
+        Update the internal variable so that the plastic strain is reset to zero.
+
+        Returns
+        -------
+        None
+
+        Examples
+        --------
+        As an example, we consider the Johnson-Cook plasticity model:
+
+        >>> from Elasticipy.plasticity import JohnsonCook
+        >>> JC = JohnsonCook(A=792, B=510, n=0.26)
+
+        First apply a strain increment:
+
+        >>> stress = JC.apply_strain(0.1)
+        >>> print(JC)
+        Johnson-Cook plasticity model
+         type: Isotropic
+         criterion: von Mises
+         current strain: 0.1
+
+        If one wants to reset the JC, without recreating it:
+
+        >>> stress = JC.reset_strain()
+        >>> print(JC)
+        Johnson-Cook plasticity model
+         type: Isotropic
+         criterion: von Mises
+         current strain: 0.0
+        """
         self.plastic_strain = 0.0
 
 
@@ -153,6 +323,7 @@ class JohnsonCook(IsotropicHardening):
             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
@@ -177,35 +348,7 @@ class JohnsonCook(IsotropicHardening):
 
         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.criterion.eq_stress(stress)
         else:
@@ -242,9 +385,6 @@ class JohnsonCook(IsotropicHardening):
             return strain_increment
 
     def reset_strain(self):
-        """
-        Reinitialize the plastic strain to 0
-        """
         self.plastic_strain = 0.0
 
 
@@ -351,7 +491,12 @@ class DruckerPrager(PlasticityCriterion):
         -----
         The pressure-dependent DG plasticity criterion assumes that the equivalent stress is defined as:
 
+        .. math::
+
+            \\alpha I_1 + \\sqrt{J_2}
 
+        where :math:`I_1` is the first invariant of the stress tensor, and :math:`J_2` is the second invariant of the
+        deviatoric stress tensor.
         """
         self.alpha = alpha
 

Elasticipy/spherical_function.py

@@ -237,6 +237,23 @@ class SphericalFunction:
         See Also
         --------
         eval_spherical : evaluate the function along a given direction given using the spherical coordinates
+
+        Examples
+        --------
+        As an example of spherical function, we consider the Young modulus estimated from a stiffness tensor:
+
+        >>> from Elasticipy.tensors.elasticity import StiffnessTensor
+        >>> E = StiffnessTensor.cubic(C11=110, C12=54, C44=60).Young_modulus
+
+        The Young modulus along x direction is:
+
+        >>> E.eval([1,0,0])
+        74.4390243902439
+
+        The Young moduli along a set a directions can be evaluated at once. E.g. along x, y and z:
+
+        >>> E.eval([[1,0,0], [0,1,0], [0,0,1]])
+        array([74.43902439, 74.43902439, 74.43902439])
         """
         u_vec = np.atleast_2d(u)
         norm = np.linalg.norm(u_vec, axis=1)
@@ -244,11 +261,20 @@ class SphericalFunction:
             raise ValueError('The input vector cannot be zeros')
         u_vec = (u_vec.T / norm).T
         values = self.fun(u_vec)
-        if isinstance(u, list) and np.array(u).shape == (3,):
+        if isinstance(u, list) and np.array(u).shape == (3,) and isinstance(values, np.ndarray):
             return values[0]
         else:
             return values
 
+    def __eq__(self, other):
+        if type(other) is self.__class__:
+            n_evals = 10000
+            _, a_evals = self.evaluate_on_spherical_grid(n_evals)
+            _, b_evals = other.evaluate_on_spherical_grid(n_evals)
+            return np.allclose(a_evals, b_evals)
+        else:
+            return False
+
     def eval_spherical(self, *args, degrees=False):
         """
         Evaluate value along a given (set of) direction(s) defined by its (their) spherical coordinates.
@@ -269,7 +295,18 @@ class SphericalFunction:
 
         See Also
         --------
-        eval : evaluate the function along a direction given by its cartesian coordinates
+        eval : evaluate the function along a direction given by its cartesian
+
+        Examples
+        --------
+        >>> from Elasticipy.tensors.elasticity import StiffnessTensor
+        >>> E = StiffnessTensor.cubic(C11=110, C12=54, C44=60).Young_modulus
+
+        In spherical coordinates, the x direction is defined by theta=90° and phi=0. Therefore, the Young modulus along
+        x direction is:
+
+        >>> E.eval_spherical([0, 90], degrees=True)
+        74.4390243902439
         """
         angles = np.atleast_2d(args)
         if degrees:
@@ -277,7 +314,9 @@ class SphericalFunction:
         phi, theta = angles.T
         u = sph2cart(phi, theta)
         values = self.eval(u)
-        if (np.array(args).shape == (2,) or np.array(args).shape == (1, 2)) and not isinstance(args, np.ndarray):
+        if ((np.array(args).shape == (2,) or np.array(args).shape == (1, 2))
+                and not isinstance(args, np.ndarray)
+                and isinstance(values, np.ndarray)):
             return values[0]
         else:
             return values
@@ -735,7 +774,7 @@ class HyperSphericalFunction(SphericalFunction):
             the latitude angle from Z axis (theta==0 -> u = Z axis), and psi is the angle defining the orientation of
             the second direction (v) in the plane orthogonal to u, as illustrated below:
 
-            .. image:: ../../docs/_static/images/HyperSphericalCoordinates.png
+            .. image:: ../../../docs/_static/images/HyperSphericalCoordinates.png
 
 
         degrees : bool, default False