Deploy Dang Van fatigue analysis app to Hugging Face Spaces

Features:
- Gradio web interface with École Centrale Lyon styling
- Real-time Dang Van criterion calculations
- Interactive visualizations and parameter controls
- Data export capabilities (CSV and PNG)
- Support for uniaxial and torsion loading

Files:
- app.py: Main Gradio application
- versDV.py: Dang Van calculation functions
- deviatoire.py: Deviatoric stress calculations
- requirements.txt: Python dependencies

README.md

@@ -1,13 +1,115 @@
----
-title: DangVan
-emoji: 🏃
-colorFrom: purple
-colorTo: indigo
-sdk: gradio
-sdk_version: 6.3.0
-app_file: app.py
-pinned: false
-license: mit
+# Critère de Dang Van - Analyse de Fatigue
+**École Centrale Lyon**
+
+![École Centrale Lyon](https://images.seeklogo.com/logo-png/48/2/ecole-centrale-de-lyon-logo-png_seeklogo-481949.png)
+
+## Description
+
+Cette application web interactive permet d'analyser le comportement en fatigue des matériaux selon le critère de Dang Van. Développée à l'École Centrale Lyon, elle visualise le domaine de sécurité défini par ce critère pour différents types de chargements complexes.
+
+## 🎯 Objectifs
+
+- **Analyse multiaxiale de fatigue** : Appliquer le critère de Dang Van pour prédire l'apparition de fissures
+- **Visualisation interactive** : Génération de diagrammes de Dang Van en temps réel
+- **Comparaison de chargements** : Étude comparative entre traction-compression et torsion
+- **Export de données** : Téléchargement des résultats au format CSV et PNG
+
+## 🧮 Fonctionnalités
+
+### Calcul et Analyse
+- **Génération de tenseurs** : Création de tenseurs de contraintes pour différents chargements
+- **Calcul de pression hydrostatique** : Détermination de la composante sphérique du tenseur
+- **Amplitude de cisaillement maximale** : Recherche du cisaillement maximal sur toutes les facettes
+- **Critère de Dang Van** : Application du critère multiaxial de fatigue
+
+### Visualisation
+- **Diagrammes interactifs** : Graphiques de pression hydrostatique vs amplitude de cisaillement
+- **Personnalisation** : Options de thèmes, de grille et de taille de points
+- **Résultats statistiques** : Métriques détaillées sur les calculs effectués
+
+### Export
+- **Données brutes** : Export CSV des données de traction-compression et torsion
+- **Graphiques** : Téléchargement des diagrammes en haute résolution PNG
+
+## 🚀 Déploiement
+
+Cette application est optimisée pour le déploiement sur **Hugging Face Spaces** avec Gradio.
+
+### Installation locale
+
+```bash
+# Cloner le dépôt
+git clone <repository-url>
+cd APP_DangVan
+
+# Installer les dépendances
+pip install -r requirements.txt
+
+# Lancer l'application
+python app_gradio.py
+```
+
+### Déploiement sur Hugging Face Spaces
+
+1. **Créer un nouvel Espace** sur [Hugging Face](https://huggingface.co/spaces)
+2. **Choisir Gradio SDK** 
+3. **Uploader les fichiers** du projet
+4. **L'application se déploie automatiquement**
+
+## 📋 Structure du projet
+
+```
+APP_DangVan/
+├── app_gradio.py          # Application Gradio principale
+├── versDV.py             # Fonctions de calcul Dang Van
+├── deviatoire.py         # Calculs de déviateurs
+├── requirements.txt      # Dépendances Python
+├── README.md            # Documentation
+└── .streamlit/          # Configuration Streamlit (non utilisé pour Gradio)
+```
+
+## 👥 Équipe
+
+**Étudiants :**
+- Kevin TONGUE
+- Paul LORTHIOIR
+
+**Encadrement :**
+- Éric FEULVACH
+- Françoise FAUVIN
+
+**UE :** Projet de recherche et innovation  
+**Thème :** Analyse en fatigue de structures industrielles soumises à des chargements complexes  
+**Date :** 2026
+
+## 📚 Théorie du critère de Dang Van
+
+Le critère de Dang Van est un critère multiaxial de fatigue à haute durée de vie qui s'exprime sous la forme :
+
+$$\\tau_{a,max} + \\alpha p_h \\leq \\beta$$
+
+où :
+- $\\tau_{a,max}$ est l'amplitude maximale de cisaillement
+- $p_h$ est la pression hydrostatique
+- $\\alpha$ et $\\beta$ sont des constantes matériau
+
+Ce critère permet de prendre en compte l'effet de la pression hydrostatique sur l'endurance en fatigue des matériaux métalliques.
+
+## 🛠️ Technologies utilisées
+
+- **Python** : Langage de programmation principal
+- **Gradio** : Interface web interactive
+- **NumPy** : Calculs numériques
+- **Matplotlib** : Visualisation graphique
+- **SciPy** : Calculs scientifiques avancés
+- **Pandas** : Manipulation de données
+
+## 📝 Licence
+
+Projet académique - École Centrale Lyon  
+Mécanique des Matériaux | UE: Fatigue et Fissuration  
+© 2024 - Tous droits réservés
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+**École Centrale Lyon** | Laboratoire de Mécanique des Matériaux | Projet de recherche et innovation

app.py

@@ -0,0 +1,344 @@
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+import versDV as dv
+import deviatoire as dev
+from math import pi
+import pandas as pd
+import io
+import base64
+
+# CSS personnalisé avec les couleurs de l'école
+css = """
+/* Palette de couleurs Centrale Lyon (version rouge) */
+:root {
+    --primary-red: #D52B1E;
+    --secondary-red: #B22222;
+    --accent-red: #8B0000;
+    --light-gray: #F5F5F5;
+    --dark-gray: #333333;
+}
+
+.gradio-container {
+    font-family: 'Arial', sans-serif;
+}
+
+.main-header {
+    background: linear-gradient(90deg, var(--primary-red) 0%, var(--secondary-red) 100%);
+    padding: 1.5rem;
+    border-radius: 0 0 10px 10px;
+    color: white;
+    text-align: center;
+    margin-bottom: 2rem;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+}
+
+.centrale-title {
+    font-family: 'Georgia', serif;
+    font-weight: 700;
+    margin-bottom: 0.5rem;
+}
+
+.centrale-subtitle {
+    font-family: 'Arial', sans-serif;
+    font-size: 1.2rem;
+    opacity: 0.9;
+}
+
+.centrale-card {
+    border-left: 4px solid var(--accent-red);
+    padding: 1rem;
+    background-color: var(--light-gray);
+    border-radius: 0 8px 8px 0;
+    margin: 1rem 0;
+}
+
+.footer {
+    background-color: var(--dark-gray);
+    color: white;
+    padding: 1rem;
+    text-align: center;
+    margin-top: 2rem;
+    border-radius: 8px 8px 0 0;
+    font-size: 0.9rem;
+}
+"""
+
+def create_header():
+    """Crée le header HTML avec le style Centrale Lyon"""
+    return f"""
+    <div class="main-header">
+        <h1 class="centrale-title">ÉCOLE CENTRALE LYON</h1>
+        <h2 class="centrale-subtitle">Analyse de Fatigue - Critère de Dang Van</h2>
+    </div>
+    """
+
+def create_info_panel():
+    """Crée le panneau d'informations"""
+    return """
+    <div class="centrale-card">
+        <h3>📝 À propos du critère de Dang Van</h3>
+        <p>Le critère de Dang Van est un critère multiaxial de fatigue à haute durée de vie. 
+        Il permet de prendre en compte l'effet de la pression hydrostatique sur l'endurance 
+        en fatigue des matériaux métalliques. Cette application visualise le domaine de 
+        sécurité défini par ce critère pour différents types de chargements.</p>
+        
+        <h4>👥 Équipe</h4>
+        <p><strong>Étudiants :</strong> Kevin TONGUE, Paul LORTHIOIR</p>
+        <p><strong>Enseignants :</strong> Éric FEULVACH, Françoise FAUVIN</p>
+        <p><strong>UE :</strong> Projet de recherche et innovation</p>
+        <p><strong>Thème :</strong> Analyse en fatigue de structures industrielles soumises à des chargements complexes</p>
+        <p><strong>Date :</strong> 2026</p>
+    </div>
+    """
+
+def calculate_dang_van(sigma1, omega, fin, pasTemps, point_size, show_grid, theme):
+    """
+    Fonction principale de calcul pour le critère de Dang Van
+    """
+    try:
+        # Configuration du style selon le thème choisi
+        if theme == "Moderne":
+            plt.style.use('seaborn-v0_8-darkgrid')
+        elif theme == "Scientifique":
+            plt.style.use('seaborn-v0_8-paper')
+        else:
+            plt.style.use('default')
+        
+        # Calcul des points pour chargement uniaxial
+        points_uniaxial = dv.nuage(sigma1, omega, pasTemps, fin)
+        
+        # Calcul des points pour torsion
+        points_torsion = dv.nuageOrt(sigma1, omega, pasTemps, fin)
+        
+        # Préparation de la figure
+        fig, ax = plt.subplots(figsize=(10, 6))
+        
+        # Tracé des points
+        scatter1 = ax.scatter(
+            points_uniaxial[:, 0],
+            points_uniaxial[:, 1],
+            s=point_size,
+            alpha=0.7,
+            label='Traction-Compression',
+            edgecolors='white',
+            linewidth=1
+        )
+
+        scatter2 = ax.scatter(
+            points_torsion[:, 0],
+            points_torsion[:, 1],
+            s=point_size,
+            alpha=0.7,
+            label='Torsion',
+            edgecolors='white',
+            linewidth=1
+        )
+        
+        # Configuration des axes et titres
+        ax.set_xlabel("Pression hydrostatique (MPa)", fontsize=12, fontweight='bold')
+        ax.set_ylabel("Amplitude de cisaillement max (MPa)", fontsize=12, fontweight='bold')
+        ax.set_title("Diagramme de Dang Van - École Centrale Lyon", 
+                    fontsize=14, fontweight='bold', pad=20)
+        
+        if show_grid:
+            ax.grid(True, linestyle='--', alpha=0.3)
+        
+        ax.legend(loc='best', frameon=True, fancybox=True, shadow=True)
+        
+        # Ajustement des limites
+        xlim_min = min(points_uniaxial[:, 0].min(), points_torsion[:, 0].min()) - 10
+        xlim_max = max(points_uniaxial[:, 0].max(), points_torsion[:, 0].max()) + 10
+        ylim_max = max(points_uniaxial[:, 1].max(), points_torsion[:, 1].max()) + 10
+        ax.set_xlim(xlim_min, xlim_max)
+        ax.set_ylim(0, ylim_max)
+        
+        # Sauvegarde de la figure
+        buf = io.BytesIO()
+        fig.savefig(buf, format='png', dpi=300, bbox_inches='tight')
+        buf.seek(0)
+        plot_url = f"data:image/png;base64,{base64.b64encode(buf.read()).decode()}"
+        plt.close(fig)
+        
+        # Calcul des statistiques
+        stats_uniaxial = len(points_uniaxial)
+        stats_torsion = len(points_torsion)
+        mean_hydro = np.mean(points_uniaxial[:, 0])
+        max_shear = max(points_uniaxial[:, 1].max(), points_torsion[:, 1].max())
+        
+        # Création des DataFrames pour l'export
+        df_uniaxial = pd.DataFrame(points_uniaxial, columns=['Pression_hydrostatique', 'Cisaillement_max'])
+        df_torsion = pd.DataFrame(points_torsion, columns=['Pression_hydrostatique', 'Cisaillement_max'])
+        
+        # Analyse du critère
+        alpha_est = 0.5
+        beta_est = points_uniaxial[:, 1].max() + alpha_est * points_uniaxial[:, 0].mean()
+        
+        analysis_text = f"""
+        ### Analyse du critère de Dang Van
+        
+        Le critère de Dang Van s'exprime sous la forme :
+        
+        τ_a,max + α × p_h ≤ β
+        
+        où :
+        - τ_a,max est l'amplitude maximale de cisaillement
+        - p_h est la pression hydrostatique
+        - α et β sont des constantes matériau
+        
+        **Paramètres estimés :**
+        - α ≈ {alpha_est:.3f}
+        - β ≈ {beta_est:.1f} MPa
+        """
+        
+        stats_text = f"""
+        ### 📊 Résultats statistiques
+        
+        **Points uniaxiaux :** {stats_uniaxial} (σ₁={sigma1}MPa)
+        **Points torsion :** {stats_torsion} (ω={omega:.2f} rad/s)
+        **Pression hydro. moyenne :** {mean_hydro:.1f} MPa (Uniaxial)
+        **Cisaillement max :** {max_shear:.1f} MPa
+        """
+        
+        return (
+            plot_url,
+            stats_text,
+            analysis_text,
+            df_uniaxial.head(20).to_html(classes='table table-striped'),
+            df_torsion.head(20).to_html(classes='table table-striped'),
+            df_uniaxial.to_csv(index=False),
+            df_torsion.to_csv(index=False),
+            buf.getvalue()
+        )
+        
+    except Exception as e:
+        error_msg = f"Erreur lors du calcul : {str(e)}"
+        return None, error_msg, "", "", "", "", "", None
+
+# Interface Gradio
+with gr.Blocks(title="Critère de Dang Van - École Centrale Lyon") as demo:
+    gr.HTML(create_header())
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 🔧 Paramètres d'étude")
+            
+            sigma1 = gr.Slider(
+                minimum=10,
+                maximum=200,
+                value=100,
+                step=5,
+                label="Amplitude σ₁ (MPa)",
+                info="Amplitude de contrainte en traction-compression"
+            )
+            
+            omega = gr.Slider(
+                minimum=0.1,
+                maximum=10.0,
+                value=2*pi,
+                step=0.1,
+                label="ω (rad/s)",
+                info="Fréquence angulaire du chargement"
+            )
+            
+            fin = gr.Slider(
+                minimum=0.1,
+                maximum=2.0,
+                value=1.0,
+                step=0.1,
+                label="Temps final"
+            )
+            
+            pasTemps = gr.Slider(
+                minimum=0.001,
+                maximum=0.1,
+                value=0.01,
+                step=0.001,
+                label="Pas de temps"
+            )
+            
+            gr.Markdown("### 📊 Options d'affichage")
+            point_size = gr.Slider(10, 100, 30, label="Taille des points")
+            show_grid = gr.Checkbox(True, label="Afficher la grille")
+            theme = gr.Dropdown(
+                ["Classique", "Moderne", "Scientifique"],
+                value="Classique",
+                label="Thème du graphique"
+            )
+            
+            calculate_btn = gr.Button(
+                "🚀 Lancer le calcul et la visualisation",
+                variant="primary",
+                size="lg"
+            )
+            
+        with gr.Column(scale=2):
+            gr.Markdown("### Objectif de l'étude")
+            gr.HTML("""
+            <div class="centrale-card">
+                <p>Cette application permet d'analyser le comportement en fatigue des matériaux selon le critère de Dang Van. 
+                Le critère permet de prédire l'apparition de fissures de fatigue en considérant simultanément la pression 
+                hydrostatique et l'amplitude de cisaillement.</p>
+            </div>
+            """)
+            
+            plot_output = gr.HTML()
+            
+            with gr.Tabs():
+                with gr.TabItem("📈 Statistiques"):
+                    stats_output = gr.Markdown()
+                
+                with gr.TabItem("📄 Analyse"):
+                    analysis_output = gr.Markdown()
+                
+                with gr.TabItem("💾 Export des données"):
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("**Données Traction-Compression**")
+                            uniaxial_table = gr.HTML()
+                        with gr.Column():
+                            gr.Markdown("**Données Torsion**")
+                            torsion_table = gr.HTML()
+                    
+                    with gr.Row():
+                        uniaxial_csv = gr.File(label="CSV Traction-Compression")
+                        torsion_csv = gr.File(label="CSV Torsion")
+                        plot_download = gr.File(label="Graphique PNG")
+    
+    # Informations
+    gr.HTML(create_info_panel())
+    
+    # Footer
+    gr.HTML("""
+    <div class="footer">
+        <p><strong>École Centrale Lyon</strong> | Mécanique des Matériaux | UE: Fatigue et Fissuration</p>
+        <p style="font-size: 0.8rem; opacity: 0.8;">
+            Rapport technique - © 2024 - Tous droits réservés
+        </p>
+    </div>
+    """)
+    
+    # Gestion des événements
+    calculate_btn.click(
+        fn=calculate_dang_van,
+        inputs=[sigma1, omega, fin, pasTemps, point_size, show_grid, theme],
+        outputs=[
+            plot_output,
+            stats_output,
+            analysis_output,
+            uniaxial_table,
+            torsion_table,
+            uniaxial_csv,
+            torsion_csv,
+            plot_download
+        ]
+    )
+
+# Lancement de l'application
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        css=css
+    )

app_gradio.py

@@ -0,0 +1,344 @@
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+import versDV as dv
+import deviatoire as dev
+from math import pi
+import pandas as pd
+import io
+import base64
+
+# CSS personnalisé avec les couleurs de l'école
+css = """
+/* Palette de couleurs Centrale Lyon (version rouge) */
+:root {
+    --primary-red: #D52B1E;
+    --secondary-red: #B22222;
+    --accent-red: #8B0000;
+    --light-gray: #F5F5F5;
+    --dark-gray: #333333;
+}
+
+.gradio-container {
+    font-family: 'Arial', sans-serif;
+}
+
+.main-header {
+    background: linear-gradient(90deg, var(--primary-red) 0%, var(--secondary-red) 100%);
+    padding: 1.5rem;
+    border-radius: 0 0 10px 10px;
+    color: white;
+    text-align: center;
+    margin-bottom: 2rem;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+}
+
+.centrale-title {
+    font-family: 'Georgia', serif;
+    font-weight: 700;
+    margin-bottom: 0.5rem;
+}
+
+.centrale-subtitle {
+    font-family: 'Arial', sans-serif;
+    font-size: 1.2rem;
+    opacity: 0.9;
+}
+
+.centrale-card {
+    border-left: 4px solid var(--accent-red);
+    padding: 1rem;
+    background-color: var(--light-gray);
+    border-radius: 0 8px 8px 0;
+    margin: 1rem 0;
+}
+
+.footer {
+    background-color: var(--dark-gray);
+    color: white;
+    padding: 1rem;
+    text-align: center;
+    margin-top: 2rem;
+    border-radius: 8px 8px 0 0;
+    font-size: 0.9rem;
+}
+"""
+
+def create_header():
+    """Crée le header HTML avec le style Centrale Lyon"""
+    return f"""
+    <div class="main-header">
+        <h1 class="centrale-title">ÉCOLE CENTRALE LYON</h1>
+        <h2 class="centrale-subtitle">Analyse de Fatigue - Critère de Dang Van</h2>
+    </div>
+    """
+
+def create_info_panel():
+    """Crée le panneau d'informations"""
+    return """
+    <div class="centrale-card">
+        <h3>📝 À propos du critère de Dang Van</h3>
+        <p>Le critère de Dang Van est un critère multiaxial de fatigue à haute durée de vie. 
+        Il permet de prendre en compte l'effet de la pression hydrostatique sur l'endurance 
+        en fatigue des matériaux métalliques. Cette application visualise le domaine de 
+        sécurité défini par ce critère pour différents types de chargements.</p>
+        
+        <h4>👥 Équipe</h4>
+        <p><strong>Étudiants :</strong> Kevin TONGUE, Paul LORTHIOIR</p>
+        <p><strong>Enseignants :</strong> Éric FEULVACH, Françoise FAUVIN</p>
+        <p><strong>UE :</strong> Projet de recherche et innovation</p>
+        <p><strong>Thème :</strong> Analyse en fatigue de structures industrielles soumises à des chargements complexes</p>
+        <p><strong>Date :</strong> 2026</p>
+    </div>
+    """
+
+def calculate_dang_van(sigma1, omega, fin, pasTemps, point_size, show_grid, theme):
+    """
+    Fonction principale de calcul pour le critère de Dang Van
+    """
+    try:
+        # Configuration du style selon le thème choisi
+        if theme == "Moderne":
+            plt.style.use('seaborn-v0_8-darkgrid')
+        elif theme == "Scientifique":
+            plt.style.use('seaborn-v0_8-paper')
+        else:
+            plt.style.use('default')
+        
+        # Calcul des points pour chargement uniaxial
+        points_uniaxial = dv.nuage(sigma1, omega, pasTemps, fin)
+        
+        # Calcul des points pour torsion
+        points_torsion = dv.nuageOrt(sigma1, omega, pasTemps, fin)
+        
+        # Préparation de la figure
+        fig, ax = plt.subplots(figsize=(10, 6))
+        
+        # Tracé des points
+        scatter1 = ax.scatter(
+            points_uniaxial[:, 0],
+            points_uniaxial[:, 1],
+            s=point_size,
+            alpha=0.7,
+            label='Traction-Compression',
+            edgecolors='white',
+            linewidth=1
+        )
+
+        scatter2 = ax.scatter(
+            points_torsion[:, 0],
+            points_torsion[:, 1],
+            s=point_size,
+            alpha=0.7,
+            label='Torsion',
+            edgecolors='white',
+            linewidth=1
+        )
+        
+        # Configuration des axes et titres
+        ax.set_xlabel("Pression hydrostatique (MPa)", fontsize=12, fontweight='bold')
+        ax.set_ylabel("Amplitude de cisaillement max (MPa)", fontsize=12, fontweight='bold')
+        ax.set_title("Diagramme de Dang Van - École Centrale Lyon", 
+                    fontsize=14, fontweight='bold', pad=20)
+        
+        if show_grid:
+            ax.grid(True, linestyle='--', alpha=0.3)
+        
+        ax.legend(loc='best', frameon=True, fancybox=True, shadow=True)
+        
+        # Ajustement des limites
+        xlim_min = min(points_uniaxial[:, 0].min(), points_torsion[:, 0].min()) - 10
+        xlim_max = max(points_uniaxial[:, 0].max(), points_torsion[:, 0].max()) + 10
+        ylim_max = max(points_uniaxial[:, 1].max(), points_torsion[:, 1].max()) + 10
+        ax.set_xlim(xlim_min, xlim_max)
+        ax.set_ylim(0, ylim_max)
+        
+        # Sauvegarde de la figure
+        buf = io.BytesIO()
+        fig.savefig(buf, format='png', dpi=300, bbox_inches='tight')
+        buf.seek(0)
+        plot_url = f"data:image/png;base64,{base64.b64encode(buf.read()).decode()}"
+        plt.close(fig)
+        
+        # Calcul des statistiques
+        stats_uniaxial = len(points_uniaxial)
+        stats_torsion = len(points_torsion)
+        mean_hydro = np.mean(points_uniaxial[:, 0])
+        max_shear = max(points_uniaxial[:, 1].max(), points_torsion[:, 1].max())
+        
+        # Création des DataFrames pour l'export
+        df_uniaxial = pd.DataFrame(points_uniaxial, columns=['Pression_hydrostatique', 'Cisaillement_max'])
+        df_torsion = pd.DataFrame(points_torsion, columns=['Pression_hydrostatique', 'Cisaillement_max'])
+        
+        # Analyse du critère
+        alpha_est = 0.5
+        beta_est = points_uniaxial[:, 1].max() + alpha_est * points_uniaxial[:, 0].mean()
+        
+        analysis_text = f"""
+        ### Analyse du critère de Dang Van
+        
+        Le critère de Dang Van s'exprime sous la forme :
+        
+        τ_a,max + α × p_h ≤ β
+        
+        où :
+        - τ_a,max est l'amplitude maximale de cisaillement
+        - p_h est la pression hydrostatique
+        - α et β sont des constantes matériau
+        
+        **Paramètres estimés :**
+        - α ≈ {alpha_est:.3f}
+        - β ≈ {beta_est:.1f} MPa
+        """
+        
+        stats_text = f"""
+        ### 📊 Résultats statistiques
+        
+        **Points uniaxiaux :** {stats_uniaxial} (σ₁={sigma1}MPa)
+        **Points torsion :** {stats_torsion} (ω={omega:.2f} rad/s)
+        **Pression hydro. moyenne :** {mean_hydro:.1f} MPa (Uniaxial)
+        **Cisaillement max :** {max_shear:.1f} MPa
+        """
+        
+        return (
+            plot_url,
+            stats_text,
+            analysis_text,
+            df_uniaxial.head(20).to_html(classes='table table-striped'),
+            df_torsion.head(20).to_html(classes='table table-striped'),
+            df_uniaxial.to_csv(index=False),
+            df_torsion.to_csv(index=False),
+            buf.getvalue()
+        )
+        
+    except Exception as e:
+        error_msg = f"Erreur lors du calcul : {str(e)}"
+        return None, error_msg, "", "", "", "", "", None
+
+# Interface Gradio
+with gr.Blocks(title="Critère de Dang Van - École Centrale Lyon") as demo:
+    gr.HTML(create_header())
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 🔧 Paramètres d'étude")
+            
+            sigma1 = gr.Slider(
+                minimum=10,
+                maximum=200,
+                value=100,
+                step=5,
+                label="Amplitude σ₁ (MPa)",
+                info="Amplitude de contrainte en traction-compression"
+            )
+            
+            omega = gr.Slider(
+                minimum=0.1,
+                maximum=10.0,
+                value=2*pi,
+                step=0.1,
+                label="ω (rad/s)",
+                info="Fréquence angulaire du chargement"
+            )
+            
+            fin = gr.Slider(
+                minimum=0.1,
+                maximum=2.0,
+                value=1.0,
+                step=0.1,
+                label="Temps final"
+            )
+            
+            pasTemps = gr.Slider(
+                minimum=0.001,
+                maximum=0.1,
+                value=0.01,
+                step=0.001,
+                label="Pas de temps"
+            )
+            
+            gr.Markdown("### 📊 Options d'affichage")
+            point_size = gr.Slider(10, 100, 30, label="Taille des points")
+            show_grid = gr.Checkbox(True, label="Afficher la grille")
+            theme = gr.Dropdown(
+                ["Classique", "Moderne", "Scientifique"],
+                value="Classique",
+                label="Thème du graphique"
+            )
+            
+            calculate_btn = gr.Button(
+                "🚀 Lancer le calcul et la visualisation",
+                variant="primary",
+                size="lg"
+            )
+            
+        with gr.Column(scale=2):
+            gr.Markdown("### Objectif de l'étude")
+            gr.HTML("""
+            <div class="centrale-card">
+                <p>Cette application permet d'analyser le comportement en fatigue des matériaux selon le critère de Dang Van. 
+                Le critère permet de prédire l'apparition de fissures de fatigue en considérant simultanément la pression 
+                hydrostatique et l'amplitude de cisaillement.</p>
+            </div>
+            """)
+            
+            plot_output = gr.HTML()
+            
+            with gr.Tabs():
+                with gr.TabItem("📈 Statistiques"):
+                    stats_output = gr.Markdown()
+                
+                with gr.TabItem("📄 Analyse"):
+                    analysis_output = gr.Markdown()
+                
+                with gr.TabItem("💾 Export des données"):
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("**Données Traction-Compression**")
+                            uniaxial_table = gr.HTML()
+                        with gr.Column():
+                            gr.Markdown("**Données Torsion**")
+                            torsion_table = gr.HTML()
+                    
+                    with gr.Row():
+                        uniaxial_csv = gr.File(label="CSV Traction-Compression")
+                        torsion_csv = gr.File(label="CSV Torsion")
+                        plot_download = gr.File(label="Graphique PNG")
+    
+    # Informations
+    gr.HTML(create_info_panel())
+    
+    # Footer
+    gr.HTML("""
+    <div class="footer">
+        <p><strong>École Centrale Lyon</strong> | Mécanique des Matériaux | UE: Fatigue et Fissuration</p>
+        <p style="font-size: 0.8rem; opacity: 0.8;">
+            Rapport technique - © 2024 - Tous droits réservés
+        </p>
+    </div>
+    """)
+    
+    # Gestion des événements
+    calculate_btn.click(
+        fn=calculate_dang_van,
+        inputs=[sigma1, omega, fin, pasTemps, point_size, show_grid, theme],
+        outputs=[
+            plot_output,
+            stats_output,
+            analysis_output,
+            uniaxial_table,
+            torsion_table,
+            uniaxial_csv,
+            torsion_csv,
+            plot_download
+        ]
+    )
+
+# Lancement de l'application
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        css=css
+    )

deviatoire.py

@@ -0,0 +1,99 @@
+import numpy as np
+from math import *
+import versDV as dv
+# def deviateur(tens):
+    
+#     p = dv.hydro(tens)
+#     res = []
+#     for i in range(3):
+#         res.append(tens[i]-p)
+#     for i in range(3,6):
+#         res.append(tens[i])
+#     return np.array(res)
+
+
+def deviateur(tens):
+    """
+    cette fonction se base sur les fonctions initialement écrites dans versDV.py pour calculer le tenseur déviateur
+    1. on convertit le tenseur en matrice 3x3
+    2. on calcule la pression hydrostatique
+    3. on soustrait la pression hydrostatique à la matrice
+    4. on reconvertit la matrice déviateur en tenseur
+    5. on retourne le tenseur déviateur
+    """
+    dev=dv.tens_to_mat(tens)-np.eye(3)*dv.hydro(tens)
+    return dv.mat_to_tens(dev)
+
+# def hydro(tens):
+#     p = 0
+#     for i in range(3):
+#         p = p + tens[i]
+#     return p/3
+
+# def genereTens(sigma1,omega,pasTemps,fin):
+#     tens = np.array([sigma1,0,0,0,0,0])
+#     for i in range(int(fin/pasTemps)):
+#         t = (i+1)*pasTemps
+#         ligne = np.array([sigma1*cos(omega*t),0,0,0,0,0])
+#         tens = np.vstack((tens, ligne))
+#     # omega est la pulsation, vous pouvez choisir 2*pi par exemple
+#     # sigma1 est fixe, par exemple 100 MPa
+#     # cette fonction doit générer une matrice de 6 colonnes, chaque ligne étant le tenseur à un instant du cycle, et de la forme [sigma1*cos(omega*t),0,0,0,0,0]
+#     return tens
+
+# def CalculMatDev(matTens):
+#     resDev = matTens[:,[0,1,3,4,5]]
+#     taille = resDev.shape
+#     nLig = taille[0]
+#     for i in range(nLig):
+#         pH = hydro(matTens[i])
+#         for j in range(3):
+#             resDev[i][j] = resDev[i][j]-pH
+#     return resDev
+def CalculMatDev(matTens):
+    return np.array([deviateur(matTens[i]) for i in range(matTens.shape[0])])   
+def normeTresca(tens):
+    TensM=dv.tens_to_mat(tens)
+    valP = np.linalg.eigvals(TensM)
+    max = float(np.max(valP))
+    min = float(np.min(valP))
+    return abs(max-min)
+
+def diametre(matTens):
+    """calcul la distance maximale entre deux lignes (des déviateurs) au sens de la norme de Tresca) et retourne les deux points extrêmes, """
+    
+    matDev=CalculMatDev(matTens)
+    point1=np.zeros(5)
+    point2=np.zeros(5)
+    maxDist=0
+    for i in range(matDev.shape[0]-1):
+        point1 = matDev[i]
+        for j in range(i+1,matDev.shape[0]):
+            point2 = matDev[j]
+            dist=normeTresca(matDev[i]-matDev[j])
+            if dist>maxDist:
+                    maxDist=dist
+                    point1=matDev[i]
+                    point2=matDev[j]
+    return maxDist, point1, point2
+    
+
+def recentre(matDev):
+    """retourne une matrice de tenseurs déviateurs recentrée par Centre qui est un tenseur."""
+#    taille = matDev.shape
+#   nLig = taille[0]
+#    for i in range(nLig):
+#        ligne = matDev[i] - Centre 
+#        matCentre = np.vstack((matCentre, ligne))
+    points = diametre(matDev)
+    Centre = (points[1] + points[2])/2
+    return matDev - Centre
+
+# class Deviateur:
+
+
+
+# matTens = dv.genereTens(100,2*pi,0.1,1)
+# res = CalculMatDev(matTens)
+
+# trace le nuage de points J2(matDev)(t),p(t))

requirements.txt

@@ -0,0 +1,5 @@
+numpy
+matplotlib
+scipy
+gradio
+pandas

versDV.py

@@ -0,0 +1,342 @@
+# Cellule 1 : Installation des packages (optionnel)
+# !pip install numpy matplotlib
+
+# Cellule 2 : Import des bibliothèques
+import numpy as np
+import matplotlib.pyplot as plt
+from math import *
+import cmath
+import scipy.special as sp
+
+# Cellule 3 : Fonction normale
+def normale(theta,phi):
+    # retourne le vecteur unitaire définit par (cos(theta)*sin(phi),sin(theta)*sin(phi),cos(phi))
+    vN = np.array([cos(theta)*sin(phi),sin(theta)*sin(phi),cos(phi)])
+    return vN.T
+
+# Cellule 4 : Fonction tens_to_mat
+def tens_to_mat(liste):
+    if isinstance(liste,list):
+        liste = np.array(liste)
+    res = np.array([[liste[0],liste[3],liste[4]],
+                    [liste[3],liste[1],liste[5]],
+                    [liste[4],liste[5],liste[2]]])
+    return res
+
+# Cellule 5 : Fonction contTang
+def mat_to_tens(mat):
+    res = np.array([mat[0,0],mat[1,1],mat[2,2],mat[0,1],mat[0,2],mat[1,2]])
+    return res
+def contTang(tens,vN):
+    # calcul le vecteur contrainte tangentiell sur une facette de normale vN
+    M = tens_to_mat(tens)  # vecteur contrainte
+    cont = M@vN  # contrainte normale
+    cN = cont@vN
+    contT = cont-cN*vN
+    return contT
+
+# Cellule 6 : Fonction hydro
+def hydro(tens):
+    # cette fonction doit retourner la pression hydrostatique associée à ce tenseur (c'est pour un instant du cycle !)
+    if isinstance(tens, np.ndarray):
+        if tens.ndim == 2 and tens.shape == (3, 3):
+            return np.trace(tens) / 3
+        elif tens.ndim == 1:
+            if len(tens) == 6:
+                return (tens[0] + tens[1] + tens[2]) / 3
+            elif len(tens) == 3:
+                return np.sum(tens) / 3
+            else:
+                raise ValueError("Vector must be of length 3 or 6")
+        elif tens.ndim == 2:
+            # assume array of vectors
+            if tens.shape[1] not in [3, 6]:
+                raise ValueError("Each row must be length 3 or 6")
+            res = []
+            for i in range(tens.shape[0]):
+                row = tens[i]
+                if tens.shape[1] == 6:
+                    p = (row[0] + row[1] + row[2]) / 3
+                else:  # 3
+                    p = np.sum(row) / 3
+                res.append(p)
+            return np.array(res)
+        else:
+            raise ValueError("Unsupported tensor shape")
+    else:
+        # if list, convert
+        tens = np.array(tens)
+        return hydro(tens)
+
+# Cellule 7 : Fonction genereTens
+def genereTens(sigma1,omega,pasTemps,fin):
+    tens = np.array([sigma1,0,0,0,0,0])
+    for i in range(int(fin/pasTemps)):
+        t = (i+1)*pasTemps
+        ligne = np.array([sigma1*cos(omega*t),0,0,0,0,0])
+        tens = np.vstack((tens, ligne))
+    # omega est la pulsation, vous pouvez choisir 2*pi par exemple
+    # sigma1 est fixe, par exemple 100 MPa
+    # cette fonction doit générer une matrice de 6 colonnes, chaque ligne étant le tenseur à un instant du cycle, et de la forme [sigma1*cos(omega*t),0,0,0,0,0]
+    return tens
+def genereTensOrt(sigma1,omega,pasTemps,fin):
+    tens = np.array([0,0,0,sigma1,0,0])
+    for i in range(int(fin/pasTemps)):
+        t = (i+1)*pasTemps
+        ligne = np.array([0,0,0,sigma1*cos(omega*t),0,0])
+        tens = np.vstack((tens, ligne))
+    # omega est la pulsation, vous pouvez choisir 2*pi par exemple
+    # sigma1 est fixe, par exemple 100 MPa
+    # cette fonction doit générer une matrice de 6 colonnes, chaque ligne étant le tenseur à un instant du cycle, et de la forme [sigma1*cos(omega*t),0,0,0,0,0]
+    return tens
+
+# Cellule 8 : Test de genereTens
+# genereTens(100,2*pi,0.01,1)
+
+# Cellule 9 : Fonction amplitudeTangMax
+def amplitudeTangMax(tens):
+    # cette fonction doit retourner pour UN instant une liste de deux éléments : 
+    # le premier élément est la valeur max_n (norme de contTang) et le deuxième les angles du plan associés
+    # il faut balayer les facettes !
+    maxi = 0
+    theta = 0
+    planMax = [0,0]
+    phi = 0
+    pasTheta = pi/180
+    pasPhi = pi/180
+    vect_norm = normale(theta,phi)
+    
+    for i in range(180+1):
+        theta = i*pasTheta
+        for j in range(180+1):
+            phi = j*pasPhi
+            # on construit le vecteur normal
+            vect_norm = normale(theta,phi)
+            # on calcule la contrainte tangentielle
+            contT = contTang(tens,vect_norm)
+            # on calcule sa norme
+            norme = np.linalg.norm(contT)
+            # si elle est plus grande que maxi, elle devient maxi
+            if norme > maxi:
+                maxi = norme
+                planMax = [theta,phi]
+            # on actualise planMax
+    # on retourne [maxi,planMax]
+    return [maxi,planMax]
+
+# Cellule 10 : Fonction nuage
+def nuage(sigma1,omega,pasTemps,fin):
+    """
+    Le but de la fonction est de tracer les contraintes tangentielles maximales en fonction de la 
+    pression hydrostatique
+    """
+    points = np.array([0,0])
+    tensTot = genereTens(sigma1,omega,pasTemps,fin)
+    for t in range(int(fin/pasTemps)+1):
+        tens = tensTot[t]
+        cisMax,_ = amplitudeTangMax(tens)
+        hydros = hydro(tens)
+        ligne = np.array([hydros,cisMax])
+        points = np.vstack((points, ligne))
+    return points
+
+
+
+def nuageOrt(sigma1,omega,pasTemps,fin):
+    """
+    Le but de la fonction est de tracer les contraintes tangentielles maximales en fonction de la 
+    pression hydrostatique
+    """
+    points = np.array([0,0])
+    tensTot = genereTensOrt(sigma1,omega,pasTemps,fin)
+    for t in range(int(fin/pasTemps)+1):
+        tens = tensTot[t]
+        cisMax,_ = amplitudeTangMax(tens)
+        hydros = hydro(tens)
+        ligne = np.array([hydros,cisMax])
+        points = np.vstack((points, ligne))
+    return points
+
+# Cellule 11 : Fonction traceNuage
+def traceNuage(points):
+    plt.scatter(points[:, 0], points[:, 1])
+    plt.xlabel("pression hydrostatique")
+    plt.ylabel("amplitude de cisaillement max")
+    plt.title("Nuage de points")
+    plt.savefig('dangvan_nuage.png')
+    plt.show()
+
+# Cellule 12 : Exécution et visualisation
+# points = nuage(100,2*pi,0.01,1)
+# traceNuage(points)
+
+# # Tracer le diagramme de Dang Van avec les deux cas et la limite
+# points_uniaxial = nuage(100, 2*pi, 0.01, 1)
+# points_torsion = nuageOrt(50, 2*pi, 0.01, 1)  # tau_a = 50 for torsion
+
+# plt.figure()
+# plt.scatter(points_uniaxial[:, 0], points_uniaxial[:, 1], label='Traction-Compression')
+# plt.scatter(points_torsion[:, 0], points_torsion[:, 1], label='Torsion')
+
+# # Limite de fatigue : ligne droite reliant les maxima
+# max_uniaxial = np.max(points_uniaxial[:, 1])
+# max_torsion = np.max(points_torsion[:, 1])
+
+# # Pour Dang Van, la ligne limite est tau = beta - alpha * p
+# # Ici, simplifié : ligne de (0, max_torsion) à (max_p_uniaxial, 0) ou quelque chose
+# # En pratique, alpha ≈ 0.3, beta ≈ max_torsion
+# alpha = 0.3
+# beta = max_torsion
+# p_max = np.max(points_uniaxial[:, 0])
+# p_line = np.linspace(0, p_max, 100)
+# tau_line = beta - alpha * p_line
+# plt.plot(p_line, tau_line, 'r-', label='Limite de fatigue')
+
+# plt.xlabel("Pression hydrostatique")
+# plt.ylabel("Amplitude de cisaillement max")
+# plt.title("Diagramme de Dang Van")
+# plt.legend()
+# plt.grid(True)
+# plt.savefig('dangvan_limite.png')
+# plt.show()
+
+
+
+class DangVan:
+    @staticmethod
+    def normale(theta, phi):
+        # retourne le vecteur unitaire définit par (cos(theta)*sin(phi),sin(theta)*sin(phi),cos(phi))
+        vN = np.array([cos(theta)*sin(phi), sin(theta)*sin(phi), cos(phi)])
+        return vN.T
+
+    @staticmethod
+    def tens_to_mat(liste):
+        if isinstance(liste, list):
+            liste = np.array(liste)
+        res = np.array([[liste[0], liste[3], liste[4]],
+                        [liste[3], liste[1], liste[5]],
+                        [liste[4], liste[5], liste[2]]])
+        return res
+
+    @staticmethod
+    def contTang(tens, vN):
+        # calcul le vecteur contrainte tangentiell sur une facette de normale vN
+        M = DangVan.tens_to_mat(tens)  # vecteur contrainte
+        cont = M @ vN  # contrainte normale
+        cN = cont @ vN
+        contT = cont - cN * vN
+        return contT
+
+    @staticmethod
+    def hydro(tens):
+        # cette fonction doit retourner la pression hydrostatique associée à ce tenseur (c'est pour un instant du cycle !)
+        if isinstance(tens, np.ndarray):
+            if tens.ndim == 2 and tens.shape == (3, 3):
+                return np.trace(tens) / 3
+            elif tens.ndim == 1:
+                if len(tens) == 6:
+                    return (tens[0] + tens[1] + tens[2]) / 3
+                elif len(tens) == 3:
+                    return np.sum(tens) / 3
+                else:
+                    raise ValueError("Vector must be of length 3 or 6")
+            else:
+                raise ValueError("Unsupported tensor shape for single tensor")
+        else:
+            tens = np.array(tens)
+            return DangVan.hydro(tens)
+
+    @staticmethod
+    def genereTens(sigma1, omega, pasTemps, fin):
+        tens = np.array([sigma1, 0, 0, 0, 0, 0])
+        for i in range(int(fin / pasTemps)):
+            t = (i + 1) * pasTemps
+            ligne = np.array([sigma1 * cos(omega * t), 0, 0, 0, 0, 0])
+            tens = np.vstack((tens, ligne))
+        # omega est la pulsation, vous pouvez choisir 2*pi par exemple
+        # sigma1 est fixe, par exemple 100 MPa
+        # cette fonction doit générer une matrice de 6 colonnes, chaque ligne étant le tenseur à un instant du cycle, et de la forme [sigma1*cos(omega*t),0,0,0,0,0]
+        return tens
+
+    @staticmethod
+    def genereTensOrt(sigma1, omega, pasTemps, fin):
+        tens = np.array([0, 0, 0, sigma1, 0, 0])
+        for i in range(int(fin / pasTemps)):
+            t = (i + 1) * pasTemps
+            ligne = np.array([0, 0, 0, sigma1 * cos(omega * t), 0, 0])
+            tens = np.vstack((tens, ligne))
+        # omega est la pulsation, vous pouvez choisir 2*pi par exemple
+        # sigma1 est fixe, par exemple 100 MPa
+        # cette fonction doit générer une matrice de 6 colonnes, chaque ligne étant le tenseur à un instant du cycle, et de la forme [sigma1*cos(omega*t),0,0,0,0,0]
+        return tens
+
+    @staticmethod
+    def amplitudeTangMax(tens):
+        # cette fonction doit retourner pour UN instant une liste de deux éléments :
+        # le premier élément est la valeur max_n (norme de contTang) et le deuxième les angles du plan associés
+        # il faut balayer les facettes !
+        maxi = 0
+        theta = 0
+        planMax = [0, 0]
+        phi = 0
+        pasTheta = pi / 180
+        pasPhi = pi / 180
+        vect_norm = DangVan.normale(theta, phi)
+
+        for i in range(180 + 1):
+            theta = i * pasTheta
+            for j in range(180 + 1):
+                phi = j * pasPhi
+                # on construit le vecteur normal
+                vect_norm = DangVan.normale(theta, phi)
+                # on calcule la contrainte tangentielle
+                contT = DangVan.contTang(tens, vect_norm)
+                # on calcule sa norme
+                norme = np.linalg.norm(contT)
+                # si elle est plus grande que maxi, elle devient maxi
+                if norme > maxi:
+                    maxi = norme
+                    planMax = [theta, phi]
+                # on actualise planMax
+        # on retourne [maxi,planMax]
+        return [maxi, planMax]
+
+    @staticmethod
+    def nuage(sigma1, omega, pasTemps, fin):
+        """
+        Le but de la fonction est de tracer les contraintes tangentielles maximales en fonction de la
+        pression hydrostatique
+        """
+        points = np.array([0, 0])
+        tensTot = DangVan.genereTens(sigma1, omega, pasTemps, fin)
+        for t in range(int(fin / pasTemps)+1):
+            tens = tensTot[t]
+            cisMax, _ = DangVan.amplitudeTangMax(tens)
+            hydros = DangVan.hydro(tens)
+            ligne = np.array([hydros, cisMax])
+            points = np.vstack((points, ligne))
+        return points
+
+    @staticmethod
+    def nuageOrt(sigma1, omega, pasTemps, fin):
+        """
+        Le but de la fonction est de tracer les contraintes tangentielles maximales en fonction de la
+        pression hydrostatique
+        """
+        points = np.array([0, 0])
+        tensTot = DangVan.genereTensOrt(sigma1, omega, pasTemps, fin)
+        for t in range(int(fin / pasTemps)+1):
+            tens = tensTot[t]
+            cisMax, _ = DangVan.amplitudeTangMax(tens)
+            hydros = DangVan.hydro(tens)
+            ligne = np.array([hydros, cisMax])
+            points = np.vstack((points, ligne))
+        return points
+
+    @staticmethod
+    def traceNuage(points):
+        plt.scatter(points[:, 0], points[:, 1])
+        plt.xlabel("pression hydrostatique")
+        plt.ylabel("amplitude de cisaillement max")
+        plt.title("Nuage de points")
+        plt.show()