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

{Elasticipy → elasticipy}/FourthOrderTensor.py

@@ -1,10 +1,10 @@
 import warnings
-from Elasticipy.tensors.elasticity import StiffnessTensor as NewStiffnessTensor
-from Elasticipy.tensors.elasticity import ComplianceTensor as NewComplianceTensor
+from elasticipy.tensors.elasticity import StiffnessTensor as NewStiffnessTensor
+from elasticipy.tensors.elasticity import ComplianceTensor as NewComplianceTensor
 
 warnings.warn(
-    "The module 'Elasticipy.FourthOrderTensor' is deprecated and will be removed in a future release. "
-    "Please use 'Elasticipy.tensors.elasticity' instead.",
+    "The module 'elasticipy.FourthOrderTensor' is deprecated and will be removed in a future release. "
+    "Please use 'elasticipy.tensors.elasticity' instead.",
     DeprecationWarning,
     stacklevel=2
 )

elasticipy/StressStrainTensors.py

@@ -0,0 +1,16 @@
+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 → elasticipy}/ThermalExpansion.py

@@ -1,9 +1,9 @@
 import warnings
-from Elasticipy.tensors.thermal_expansion import ThermalExpansionTensor as NewThermalExpansionTensor
+from elasticipy.tensors.thermal_expansion import ThermalExpansionTensor as NewThermalExpansionTensor
 
 warnings.warn(
-    "The module 'Elasticipy.ThermalExpansion' is deprecated and will be removed in a future release. "
-    "Please use 'Elasticipy.tensors.thermal_expansion' instead.",
+    "The module 'elasticipy.ThermalExpansion' is deprecated and will be removed in a future release. "
+    "Please use 'elasticipy.tensors.thermal_expansion' instead.",
     DeprecationWarning,
     stacklevel=2
 )

elasticipy/gui/__init__.py

@@ -0,0 +1,3 @@
+from .gui import crystal_elastic_plotter
+
+__all__ = ["crystal_elastic_plotter"]

elasticipy/gui/about.py

@@ -0,0 +1,49 @@
+from qtpy.QtWidgets import QVBoxLayout, QLabel, QPushButton
+from qtpy.QtGui import QPixmap
+from qtpy.QtCore import Qt
+
+def about(dialog, logo_path):
+    dialog.setWindowTitle("About elasticipy")
+    dialog.setFixedWidth(400)
+
+    layout = QVBoxLayout(dialog)
+
+    if logo_path.exists():
+        logo = QLabel()
+        pixmap = QPixmap(str(logo_path))
+        pixmap = pixmap.scaledToWidth(250, Qt.SmoothTransformation)
+        logo.setPixmap(pixmap)
+        logo.setAlignment(Qt.AlignCenter)
+        layout.addWidget(logo)
+
+    # --- Text ---
+    text = QLabel(
+        "A Python library for elasticity tensors computations<br><br>"
+        "© 2024–2025 Dorian Depriester, MIT Licence"
+    )
+    text.setAlignment(Qt.AlignCenter)
+    layout.addWidget(text)
+
+    # --- Link ---
+    link = QLabel(
+        '<a href="https://elasticipy.readthedocs.io/">'
+        'https://elasticipy.readthedocs.io/</a>'
+    )
+    link.setAlignment(Qt.AlignCenter)
+    link.setOpenExternalLinks(True)
+    layout.addWidget(link)
+
+    # --- Bug report ---
+    link = QLabel(
+        '<a href="https://github.com/DorianDepriester/Elasticipy/issues">'
+        'Report a bug</a>'
+    )
+    link.setAlignment(Qt.AlignCenter)
+    link.setOpenExternalLinks(True)
+    layout.addWidget(link)
+
+    # --- Close button ---
+    close_btn = QPushButton("Close")
+    close_btn.clicked.connect(dialog.close)
+    layout.addWidget(close_btn)
+    return dialog

{Elasticipy → elasticipy/gui}/gui.py

@@ -1,24 +1,35 @@
 import sys
-
 import numpy as np
 from qtpy.QtWidgets import (
-    QApplication, QMainWindow, QComboBox, QGridLayout, QLabel,
-    QLineEdit, QPushButton, QVBoxLayout, QHBoxLayout, QWidget, QFrame, QMessageBox
+    QApplication, QMainWindow, QComboBox, QGridLayout, QLineEdit, QWidget, QFrame, QMessageBox
 )
+from qtpy.QtGui import QIcon
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 from matplotlib.figure import Figure
 
-from Elasticipy.crystal_symmetries import SYMMETRIES
-from Elasticipy.tensors.elasticity import StiffnessTensor
+from elasticipy.crystal_symmetries import SYMMETRIES
+from elasticipy.gui.rotate_window import EulerBungeDialog
+from elasticipy.gui.about import about
+from elasticipy.tensors.elasticity import StiffnessTensor
+from pathlib import Path
+
+from scipy.spatial.transform import Rotation
 
 WHICH_OPTIONS = {'Mean': 'mean', 'Max': 'max', 'Min': 'min', 'Std. dev.': 'std'}
 
+# --- Logo ---
+here = Path(__file__).resolve().parent
+LOGO_PATH = here / ".." / "resources" / "logo_text.svg"
+ICON_PATH = here / ".." / "resources" / "favicon.png"
+
 class ElasticityGUI(QMainWindow):
     def __init__(self):
         super().__init__()
+        self.C_stiff = None
         self.coefficient_fields = {}
-        self.setWindowTitle("Elasticipy - GUI")
+        self.setWindowTitle("elasticipy - GUI")
         self.initUI()
+        self.C_invar= np.zeros(7)
 
     def selected_symmetry(self):
         symmetry_name = self.symmetry_selector.currentText()
@@ -53,6 +64,7 @@ class ElasticityGUI(QMainWindow):
 
         # Space Group selection
         self.point_group_selector = QComboBox()
+        self.point_group_selector.setMinimumWidth(140)
         self.point_group_selector.addItems(['', ''])
         self.point_group_selector.currentIndexChanged.connect(self.update_fields)
         selectors_layout.addWidget(QLabel("Point group:"))
@@ -65,6 +77,14 @@ class ElasticityGUI(QMainWindow):
         selectors_layout.addWidget(QLabel("Diad convention:"))
         selectors_layout.addWidget(self.diag_selector)
 
+        # About button
+        self.about_button = QPushButton("About")
+        self.about_button.setFixedHeight(24)
+        self.about_button.setMaximumWidth(60)
+        self.about_button.clicked.connect(self.show_about)
+        selectors_layout.addStretch()
+        selectors_layout.addWidget(self.about_button)
+
         # Add horizontal separator
         separator = QFrame()
         separator.setFrameShape(QFrame.HLine)
@@ -125,12 +145,96 @@ class ElasticityGUI(QMainWindow):
 
         # Plot button
         self.calculate_button = QPushButton("Plot")
+        self.calculate_button.setEnabled(False)
         self.calculate_button.clicked.connect(self.calculate_and_plot)
         left_panel_layout.addWidget(self.calculate_button)
 
+        self.euler_button = QPushButton("Apply rotation")
+        self.euler_button.setEnabled(False)
+        self.euler_button.setToolTip("Rotate stiffness tensor (Bunge ZXZ)")
+        self.euler_button.clicked.connect(self.open_euler_dialog)
+        left_panel_layout.addWidget(self.euler_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 (x1000)": [
+                ("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 +247,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 +264,7 @@ class ElasticityGUI(QMainWindow):
         self.plotting_selector.setCurrentText('Young modulus')
         self.which_selector.setEnabled(False)
 
+
     def update_fields(self):
         # Deactivate unused fields
         active_fields = self.selected_symmetry().required
@@ -193,42 +298,48 @@ class ElasticityGUI(QMainWindow):
             self.which_selector.setEnabled(True)
 
     def calculate_and_plot(self):
-        """Collect entries and compute the stiffness tensor"""
-        coefficients = np.zeros((6, 6))
-        for (i, j), field in self.coefficient_fields.items():
+        stiff = self.C_stiff
+        self.figure.clear()
+        requested_value = self.plotting_selector.currentText()
+        if requested_value == "Young modulus":
+            value = stiff.Young_modulus
+            plot_kwargs = {}
+        elif requested_value == 'Linear compressibility':
+            value = stiff.linear_compressibility
+            plot_kwargs = {}
+        else:
+            if requested_value == 'Shear modulus':
+                value = stiff.shear_modulus
+            else:
+                value = stiff.Poisson_ratio
+            plot_kwargs = {'which': WHICH_OPTIONS[self.which_selector.currentText()]}
+        if self.plot_style_selector.currentIndex() == 0:
+            value.plot3D(fig=self.figure, **plot_kwargs)
+        elif self.plot_style_selector.currentIndex() == 1:
+            value.plot_xyz_sections(fig=self.figure)
+        else:
+            value.plot_as_pole_figure(fig=self.figure, **plot_kwargs)
+        self.canvas.draw()
+        invariants = np.array(stiff.linear_invariants() + stiff.quadratic_invariants())
+        if not np.all(np.isclose(invariants, self.C_invar)):
+            self.C_invar = invariants
+            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()*1000:.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])*1000:.3f}")
+            self.result_labels["K"].setText(f"{stiff.bulk_modulus:.3f}")
             try:
-                coefficients[i, j] = float(field.text())
+                Z = stiff.Zener_ratio()
+                self.result_labels["Z"].setText(f"{stiff.Zener_ratio():.3f}")
             except ValueError:
-                coefficients[i, j] = 0
-        C = np.array(coefficients)
-        Csym = C + np.tril(C.T, -1) # Rebuild the lower triangular part
-
-        try:
-            stiff = StiffnessTensor(Csym)
-            self.figure.clear()
-            requested_value = self.plotting_selector.currentText()
-            if requested_value == "Young modulus":
-                value = stiff.Young_modulus
-                plot_kwargs = {}
-            elif requested_value == 'Linear compressibility':
-                value = stiff.linear_compressibility
-                plot_kwargs = {}
-            else:
-                if requested_value == 'Shear modulus':
-                    value = stiff.shear_modulus
-                else:
-                    value = stiff.Poisson_ratio
-                plot_kwargs = {'which': WHICH_OPTIONS[self.which_selector.currentText()]}
-            if self.plot_style_selector.currentIndex() == 0:
-                value.plot3D(fig=self.figure, **plot_kwargs)
-            elif self.plot_style_selector.currentIndex() == 1:
-                value.plot_xyz_sections(fig=self.figure)
-            else:
-                value.plot_as_pole_figure(fig=self.figure, **plot_kwargs)
-            self.canvas.draw()
-
-        except ValueError as inst:
-            QMessageBox.critical(self, "Singular stiffness", inst.__str__(), QMessageBox.Ok)
+                self.result_labels["Z"].setText("—")
+            self.result_labels["A"].setText(f"{stiff.universal_anisotropy:.3f}")
 
 
     def update_dependent_fields(self):
@@ -255,9 +366,74 @@ class ElasticityGUI(QMainWindow):
                     self.coefficient_fields[index].setText(f"{0.5*(C11-C12)}")
             except ValueError:
                 pass
+        coefficients = np.zeros((6, 6))
+        for (i, j), field in self.coefficient_fields.items():
+            try:
+                coefficients[i, j] = float(field.text())
+            except ValueError:
+                coefficients[i, j] = 0
+        Csym = coefficients + np.tril(coefficients.T, -1) # Rebuild the lower triangular part
+        try:
+            self.C_stiff = StiffnessTensor(Csym)
+            self.calculate_button.setEnabled(True)
+            self.euler_button.setToolTip("Plot directional dependence")
+            self.euler_button.setEnabled(True)
+            self.euler_button.setToolTip("Rotate stiffness tensor (Bunge ZXZ)")
+        except ValueError:
+            self.calculate_button.setEnabled(False)
+            error_msg = "The stiffness tensor is not definite positive!"
+            self.calculate_button.setToolTip(error_msg)
+            self.euler_button.setEnabled(False)
+            self.euler_button.setToolTip(error_msg)
+
+    def show_about(self):
+        dialog = QDialog(self)
+        dialog = about(dialog, LOGO_PATH)
+        dialog.exec_()
+
+    def open_euler_dialog(self):
+        if not hasattr(self, "euler_dialog"):
+            self.current_config = {'sym': self.symmetry_selector.currentText(),
+                              'pg': self.point_group_selector.currentText(),
+                              'diag': self.diag_selector.currentText()}
+            self.euler_dialog = EulerBungeDialog(self, C=self.C_stiff.matrix())
+            self.euler_dialog.anglesChanged.connect(self.update_from_euler)
+        self.euler_dialog.show()
+
+    def update_from_euler(self, phi1, Phi, phi2):
+        C0 = StiffnessTensor(self.euler_dialog.C)
+        rot = Rotation.from_euler(seq='ZXZ', angles=[phi1, Phi, phi2], degrees=True)
+        if np.any(np.array([phi1, Phi, phi2])) != 0.:
+            self.symmetry_selector.setCurrentText('Triclinic')
+            C_new = C0.rotate(rot).matrix()
+            for (i, j), field in self.coefficient_fields.items():
+                self.coefficient_fields[(i,j)].setText(f"{C_new[i,j]}")
+        else:
+            for (i, j), field in self.coefficient_fields.items():
+                self.coefficient_fields[(i,j)].setText(f"{self.euler_dialog.C[i,j]}")
+            self.symmetry_selector.setCurrentText(self.current_config['sym'])
+            self.point_group_selector.setCurrentText(self.current_config['pg'])
+            self.diag_selector.setCurrentText(self.current_config['diag'])
+        if self.euler_dialog.live_button.isChecked():
+            self.calculate_and_plot()
 
 def crystal_elastic_plotter():
     app = QApplication(sys.argv)
+    try:
+        icon = QIcon(str(ICON_PATH))
+    except Exception:
+        icon = QIcon()
+    app.setWindowIcon(icon)
     window = ElasticityGUI()
+    window.setWindowIcon(icon)
     window.show()
     sys.exit(app.exec_())
+
+
+from qtpy.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout,
+    QLabel, QPushButton
+)
+
+if __name__ == "__main__":
+    crystal_elastic_plotter()

elasticipy/gui/rotate_window.py

@@ -0,0 +1,79 @@
+import numpy as np
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import QDialog, QVBoxLayout, QHBoxLayout, QLabel, QSlider, QDoubleSpinBox, QPushButton, QCheckBox
+from qtpy.QtCore import Qt, Signal
+
+
+class EulerBungeDialog(QDialog):
+    anglesChanged = Signal(float, float, float)
+
+    def __init__(self, parent=None, C=np.zeros((6, 6))):
+        super().__init__(parent)
+        self.setWindowTitle("Euler angles (Bunge ZXZ)")
+        self._build_ui()
+        self.reset()
+        self.C = C
+
+    def _build_ui(self):
+        self.layout = QVBoxLayout(self)
+
+        self.sliders = []
+        self.spins = []
+
+        labels = ["φ₁ (deg)", "Φ (deg)", "φ₂ (deg)"]
+        ranges = [(0, 360), (0, 180), (0, 360)]
+
+        for label, (vmin, vmax) in zip(labels, ranges):
+            row = QHBoxLayout()
+
+            row.addWidget(QLabel(label))
+
+            slider = QSlider(Qt.Horizontal)
+            slider.setRange(vmin * 10, vmax * 10)
+            slider.setSingleStep(1)
+
+            spin = QDoubleSpinBox()
+            spin.setRange(vmin, vmax)
+            spin.setDecimals(1)
+            spin.setSingleStep(0.1)
+
+            slider.valueChanged.connect(
+                lambda v, s=spin: s.setValue(v / 10)
+            )
+            spin.valueChanged.connect(
+                lambda v, s=slider: s.setValue(int(v * 10))
+            )
+            spin.valueChanged.connect(self._emit_angles)
+
+            row.addWidget(slider, stretch=1)
+            row.addWidget(spin)
+
+            self.sliders.append(slider)
+            self.spins.append(spin)
+
+            self.layout.addLayout(row)
+
+        # Live update
+        self.live_button = QCheckBox("Live-update plotting")
+        self.layout.addWidget(self.live_button)
+
+        # Reset button
+        reset_button = QPushButton("Reset orientation")
+        reset_button.clicked.connect(self.reset)
+        self.layout.addWidget(reset_button)
+
+    def reset(self):
+        self._set_angles(0.0, 0.0, 0.0)
+        for slider in self.sliders:
+            slider.setValue(0)
+
+    def _set_angles(self, phi1, Phi, phi2):
+        for spin, val in zip(self.spins, (phi1, Phi, phi2)):
+            spin.blockSignals(True)
+            spin.setValue(val)
+            spin.blockSignals(False)
+        self._emit_angles()
+
+    def _emit_angles(self):
+        angles = [spin.value() for spin in self.spins]
+        self.anglesChanged.emit(*angles)

{Elasticipy → elasticipy}/interfaces/FEPX.py

@@ -1,6 +1,6 @@
-from Elasticipy.tensors.second_order import SymmetricSecondOrderTensor, SecondOrderTensor, \
+from elasticipy.tensors.second_order import SymmetricSecondOrderTensor, SecondOrderTensor, \
     SkewSymmetricSecondOrderTensor
-from Elasticipy.tensors.stress_strain import StressTensor, StrainTensor
+from elasticipy.tensors.stress_strain import StressTensor, StrainTensor
 import pandas as pd
 import numpy as np
 import os
@@ -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 → elasticipy}/interfaces/PRISMS.py

@@ -1,5 +1,5 @@
-from Elasticipy.tensors.second_order import SecondOrderTensor, SymmetricSecondOrderTensor
-from Elasticipy.tensors.stress_strain import StressTensor
+from elasticipy.tensors.second_order import SecondOrderTensor, SymmetricSecondOrderTensor
+from elasticipy.tensors.stress_strain import StressTensor
 import pandas as pd
 import numpy as np