Deploy SimSite - Simulation platform with FEniCS and Dang Van analysis

DangVan/__init__.py

@@ -0,0 +1 @@
+"""DangVan package for fatigue analysis."""

DangVan/dangvan.py

@@ -0,0 +1,223 @@
+"""
+Dang Van multiaxial fatigue criterion computation.
+
+Algorithm based on old/deviatoire.py and old/versDV.py:
+- For each time step, compute hydrostatic pressure sigma_H
+- For each time step, compute max shear stress tau_max by scanning all facets (theta, phi)
+- Plot (sigma_H, tau_max) cloud and criterion line: tau = b - a * sigma_H
+
+Inputs:
+- stress_series: list of stress tensors (Voigt 6: [sxx, syy, szz, sxy, sxz, syz])
+- a, b: Dang Van material parameters
+
+Outputs:
+- dict with points (sigma_H, tau_max) for plotting and safety assessment
+"""
+
+import math
+import numpy as np
+
+
+def tens_to_mat(tens):
+    """Convert Voigt 6-component tensor to 3x3 symmetric matrix.
+    
+    Voigt notation: [sxx, syy, szz, sxy, sxz, syz]
+    Matrix:
+        [[sxx, sxy, sxz],
+         [sxy, syy, syz],
+         [sxz, syz, szz]]
+    """
+    if len(tens) == 6:
+        sxx, syy, szz, sxy, sxz, syz = tens
+        return np.array([
+            [sxx, sxy, sxz],
+            [sxy, syy, syz],
+            [sxz, syz, szz]
+        ])
+    elif len(tens) == 3 and hasattr(tens[0], '__len__') and len(tens[0]) == 3:
+        # Already a 3x3 matrix
+        return np.array(tens)
+    else:
+        raise ValueError("Tensor must be Voigt 6-component or 3x3 matrix")
+
+
+def hydro(tens):
+    """Compute hydrostatic pressure sigma_H = (sxx + syy + szz) / 3."""
+    if hasattr(tens, '__len__'):
+        if len(tens) == 6:
+            return (tens[0] + tens[1] + tens[2]) / 3.0
+        elif len(tens) == 3 and hasattr(tens[0], '__len__'):
+            # 3x3 matrix
+            return (tens[0][0] + tens[1][1] + tens[2][2]) / 3.0
+    raise ValueError("Invalid tensor format")
+
+
+def normale(theta, phi):
+    """Return unit normal vector for facet defined by angles (theta, phi)."""
+    return np.array([
+        math.cos(theta) * math.sin(phi),
+        math.sin(theta) * math.sin(phi),
+        math.cos(phi)
+    ])
+
+
+def cont_tang(tens, vN):
+    """Compute tangential stress vector on facet with normal vN.
+    
+    Args:
+        tens: stress tensor (Voigt 6 or 3x3)
+        vN: unit normal vector
+    
+    Returns:
+        tangential stress vector
+    """
+    M = tens_to_mat(tens)
+    cont = M @ vN  # stress vector on facet
+    cN = np.dot(cont, vN)  # normal component
+    contT = cont - cN * vN  # tangential component
+    return contT
+
+
+def amplitude_tang_max(tens, pas_deg=2):
+    """Compute maximum tangential stress amplitude by scanning all facets.
+    
+    Args:
+        tens: stress tensor (Voigt 6 or 3x3)
+        pas_deg: angular step in degrees (default 2 for speed, use 1 for precision)
+    
+    Returns:
+        [max_tau, [theta_max, phi_max]]
+    """
+    maxi = 0.0
+    plan_max = [0.0, 0.0]
+    pas = math.pi / (180 / pas_deg)
+    
+    n_steps = int(180 / pas_deg) + 1
+    for i in range(n_steps):
+        theta = i * pas
+        for j in range(n_steps):
+            phi = j * pas
+            vN = normale(theta, phi)
+            contT = cont_tang(tens, vN)
+            norme = np.linalg.norm(contT)
+            if norme > maxi:
+                maxi = norme
+                plan_max = [theta, phi]
+    
+    return [maxi, plan_max]
+
+
+def compute_dang_van(stress_series, a, b, pas_deg=2):
+    """Compute Dang Van criterion for a stress tensor series.
+    
+    The Dang Van criterion states that fatigue failure occurs when:
+        tau_max + a * sigma_H > b
+    
+    This function computes for each time step:
+        - sigma_H: hydrostatic pressure
+        - tau_max: maximum shear stress (by scanning all facets)
+    
+    Args:
+        stress_series: list of stress tensors (Voigt 6: [sxx, syy, szz, sxy, sxz, syz])
+        a: slope parameter (typically ~0.3)
+        b: intercept parameter (fatigue limit in pure shear)
+        pas_deg: angular step in degrees for facet scanning (default 2)
+    
+    Returns:
+        dict with:
+            - points: list of {sigma_H, tau_max, dv} for each time step
+            - dv_max: maximum DV value
+            - safe: True if all points satisfy criterion
+            - margin: b - dv_max
+            - a, b: parameters used
+            - criterion_line: points for plotting the criterion line
+    """
+    if stress_series is None or len(stress_series) == 0:
+        raise ValueError("stress_series is required and must not be empty")
+    
+    try:
+        a = float(a)
+        b = float(b)
+    except Exception as exc:
+        raise ValueError("Parameters a and b must be floats") from exc
+    
+    points = []
+    dv_max = -float("inf")
+    index_max = -1
+    
+    for i, tens in enumerate(stress_series):
+        # Convert to list/array if needed
+        if hasattr(tens, 'tolist'):
+            tens = tens.tolist()
+        tens = [float(x) for x in tens]
+        
+        # Compute hydrostatic pressure
+        sigma_H = hydro(tens)
+        
+        # Compute max shear stress by scanning facets
+        tau_max, _ = amplitude_tang_max(tens, pas_deg)
+        
+        # Dang Van criterion value
+        dv = tau_max + a * sigma_H
+        
+        points.append({
+            "i": i,
+            "sigma_H": float(sigma_H),
+            "tau_max": float(tau_max),
+            "dv": float(dv)
+        })
+        
+        if dv > dv_max:
+            dv_max = dv
+            index_max = i
+    
+    # Determine if safe (all DV values <= b)
+    safe = dv_max <= b
+    
+    # Generate criterion line for plotting
+    # Line: tau = b - a * sigma_H
+    sigma_H_values = [p["sigma_H"] for p in points]
+    sigma_H_min = min(sigma_H_values) if sigma_H_values else 0
+    sigma_H_max_val = max(sigma_H_values) if sigma_H_values else 100
+    
+    # Extend range a bit for visualization
+    margin_range = (sigma_H_max_val - sigma_H_min) * 0.2 if sigma_H_max_val != sigma_H_min else 10
+    line_start = sigma_H_min - margin_range
+    line_end = sigma_H_max_val + margin_range
+    
+    criterion_line = [
+        {"sigma_H": float(line_start), "tau": float(b - a * line_start)},
+        {"sigma_H": float(line_end), "tau": float(b - a * line_end)}
+    ]
+    
+    return {
+        "points": points,
+        "dv_max": float(dv_max),
+        "index_max": int(index_max),
+        "safe": bool(safe),
+        "margin": float(b - dv_max),
+        "a": float(a),
+        "b": float(b),
+        "criterion_line": criterion_line
+    }
+
+
+if __name__ == "__main__":
+    # Test with sample data
+    sigma1 = 100
+    omega = 2 * math.pi
+    pas_temps = 0.01
+    fin = 1.0
+    
+    stress_series = []
+    for i in range(int(fin / pas_temps)):
+        t = i * pas_temps
+        tens = [sigma1 * math.cos(omega * t), 0, 0, 0, 0, 0]
+        stress_series.append(tens)
+    
+    result = compute_dang_van(stress_series, a=0.3, b=50)
+    
+    print(f"DV max: {result['dv_max']:.2f}")
+    print(f"Safe: {result['safe']}")
+    print(f"Margin: {result['margin']:.2f}")
+    print(f"Number of points: {len(result['points'])}")

Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV DEBIAN_FRONTEND=noninteractive
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY backend/ ./backend/
+COPY static/ ./static/
+COPY DangVan/ ./DangVan/
+
+# Create directories for results and database
+RUN mkdir -p /app/backend/simulation_results && chmod 777 /app/backend/simulation_results
+
+# Initialize database and collect static files
+WORKDIR /app/backend
+RUN python manage.py migrate --noinput
+RUN python manage.py collectstatic --noinput
+
+# HF Spaces uses port 7860
+EXPOSE 7860
+
+# Run with gunicorn
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "2", "--timeout", "120", "backend.wsgi:application"]

README.md

@@ -1,10 +1,35 @@
 ---
-title: Simulations Apps
-emoji: 🔥
-colorFrom: green
-colorTo: gray
+title: SimSite - Applications de Simulation
+emoji: 🔬
+colorFrom: blue
+colorTo: cyan
 sdk: docker
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# SimSite - Plateforme de Simulation Numerique
+
+Plateforme web regroupant plusieurs applications de simulation et d'analyse numerique.
+
+## Applications disponibles
+
+### 1. Simulation FEniCS
+Resolution d'equations aux derivees partielles (EDP) avec la methode des elements finis.
+- Equation de diffusion transitoire
+- Visualisation en temps reel
+- Animation de la solution
+
+### 2. Analyse Dang Van
+Critere de fatigue multiaxiale pour l'analyse de la tenue en fatigue des pieces mecaniques.
+- Import de donnees CSV/JSON
+- Diagramme de Dang Van interactif
+- Evaluation de la securite
+
+## Technologies
+- Backend: Django + Django REST Framework
+- Frontend: HTML/CSS/JS + Chart.js
+- Calcul: NumPy, Matplotlib, FEniCS (optionnel)
+
+## Utilisation
+Accedez a l'interface web et selectionnez l'application souhaitee depuis la page d'accueil.

backend/backend/asgi.py

@@ -0,0 +1,16 @@
+"""
+ASGI config for backend project.
+
+It exposes the ASGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/6.0/howto/deployment/asgi/
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'backend.settings')
+
+application = get_asgi_application()

backend/backend/settings.py

@@ -0,0 +1,98 @@
+"""
+Django settings for backend project.
+"""
+
+from pathlib import Path
+import sys
+import os
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+# Allow importing modules from the workspace root (e.g., DangVan)
+# In development: /root/simsite/DangVan
+# In Docker: /app/DangVan
+sys.path.insert(0, str(BASE_DIR.parent))  # /root/simsite or /app
+# Also add parent directories for development environment
+sys.path.append('/root')  # Development: allows 'from DangVan.dangvan import ...'
+sys.path.append('/app')   # Docker: allows 'from DangVan.dangvan import ...'
+
+SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY', 'django-insecure-dev-key-change-in-prod')
+
+DEBUG = os.environ.get('DEBUG', 'True') == 'True'
+
+ALLOWED_HOSTS = ['*']
+
+SECURE_CROSS_ORIGIN_OPENER_POLICY = None
+
+INSTALLED_APPS = [
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    'corsheaders',
+    'rest_framework',
+    'simulation',
+]
+
+MIDDLEWARE = [
+    'corsheaders.middleware.CorsMiddleware',
+    'django.middleware.security.SecurityMiddleware',
+    'whitenoise.middleware.WhiteNoiseMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+]
+
+CORS_ALLOW_ALL_ORIGINS = True
+
+ROOT_URLCONF = 'backend.urls'
+
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',
+        'DIRS': [BASE_DIR / 'static'],
+        'APP_DIRS': True,
+        'OPTIONS': {
+            'context_processors': [
+                'django.template.context_processors.debug',
+                'django.template.context_processors.request',
+                'django.contrib.auth.context_processors.auth',
+                'django.contrib.messages.context_processors.messages',
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = 'backend.wsgi.application'
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': BASE_DIR / 'db.sqlite3',
+    }
+}
+
+STATIC_URL = '/static/'
+STATIC_ROOT = BASE_DIR / 'staticfiles'
+STATICFILES_DIRS = [
+    BASE_DIR.parent / 'static',  # /root/simsite/static or /app/static
+]
+STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
+
+REST_FRAMEWORK = {
+    'DEFAULT_RENDERER_CLASSES': [
+        'rest_framework.renderers.JSONRenderer',
+    ],
+    'DEFAULT_PARSER_CLASSES': [
+        'rest_framework.parsers.JSONParser',
+    ],
+    'DEFAULT_AUTHENTICATION_CLASSES': [],
+    'DEFAULT_PERMISSION_CLASSES': [
+        'rest_framework.permissions.AllowAny',
+    ],
+}

backend/backend/urls.py

@@ -0,0 +1,30 @@
+"""
+URL configuration for backend project.
+"""
+from django.contrib import admin
+from django.urls import path, include, re_path
+from django.conf import settings
+from django.conf.urls.static import static
+from rest_framework.routers import DefaultRouter
+from simulation.views import SimulationViewSet, DangVanView
+import os
+
+
+def serve_react_app(request):
+    index_path = os.path.join(settings.BASE_DIR.parent, 'static', 'index.html')
+    with open(index_path, 'rb') as f:
+        return HttpResponse(f.read(), content_type='text/html')
+
+
+from django.http import HttpResponse
+
+
+router = DefaultRouter()
+router.register(r'simulations', SimulationViewSet, basename='simulation')
+
+urlpatterns = [
+    path('admin/', admin.site.urls),
+    path('api/', include(router.urls)),
+    path('api/dangvan/', DangVanView.as_view()),
+    re_path(r'^.*$', serve_react_app),
+]

backend/backend/wsgi.py

@@ -0,0 +1,16 @@
+"""
+WSGI config for backend project.
+
+It exposes the WSGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/6.0/howto/deployment/wsgi/
+"""
+
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'backend.settings')
+
+application = get_wsgi_application()

backend/manage.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+"""Django's command-line utility for administrative tasks."""
+import os
+import sys
+
+
+def main():
+    """Run administrative tasks."""
+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'backend.settings')
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == '__main__':
+    main()

backend/simulation/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

backend/simulation/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class SimulationConfig(AppConfig):
+    name = 'simulation'

backend/simulation/fenics_runner.py

@@ -0,0 +1,156 @@
+"""
+Module pour exécuter des simulations FEniCS.
+Exemple : Équation de diffusion avec termes source.
+"""
+import os
+import json
+from datetime import datetime
+import numpy as np
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+
+try:
+    import fenics as fe
+    FENICS_AVAILABLE = True
+except ImportError:
+    FENICS_AVAILABLE = False
+    fe = None
+
+
+def run_simulation(params):
+    """
+    Exécute une simulation FEniCS basée sur les paramètres fournis.
+    
+    Paramètres attendus dans params:
+    - mesh_resolution: résolution du maillage (entier)
+    - diffusion_coefficient: coefficient de diffusion D (float)
+    - source_term: terme source Q (float)
+    - time_final: temps final de simulation (float)
+    - num_steps: nombre de pas de temps (int)
+    
+    Retourne:
+    - dict avec résultats et chemins de fichiers
+    """
+    
+    resolution = params.get('mesh_resolution', 32)
+    D = params.get('diffusion_coefficient', 0.1)
+    Q = params.get('source_term', 1.0)
+    T = params.get('time_final', 1.0)
+    num_steps = params.get('num_steps', 50)
+    
+    dt = T / num_steps
+    
+    if FENICS_AVAILABLE:
+        mesh = fe.UnitSquareMesh(resolution, resolution)
+        V = fe.FunctionSpace(mesh, 'P', 1)
+        
+        u = fe.TrialFunction(V)
+        v = fe.TestFunction(V)
+        
+        u_n = fe.Function(V)
+        u_n.interpolate(fe.Constant(0.0))
+        
+        F = u*v*fe.dx + D*dt*fe.dot(fe.grad(u), fe.grad(v))*fe.dx - (u_n + dt*Q)*v*fe.dx
+        a, L = fe.lhs(F), fe.rhs(F)
+        
+        u = fe.Function(V)
+        
+        results = []
+        
+        for n in range(num_steps):
+            fe.solve(a == L, u)
+            u_n.assign(u)
+            
+            if n % 10 == 0:
+                max_val = np.max(u.vector())
+                mean_val = np.mean(u.vector())
+                results.append({
+                    'step': n,
+                    'time': (n+1)*dt,
+                    'max': float(max_val),
+                    'mean': float(mean_val)
+                })
+        
+        final_max = float(np.max(u.vector()))
+        final_mean = float(np.mean(u.vector()))
+    else:
+        final_max = D * Q * T * 0.5
+        final_mean = D * Q * T * 0.25
+        results = []
+        
+        for n in range(num_steps):
+            t = (n + 1) * dt
+            results.append({
+                'step': n,
+                'time': t,
+                'max': float(D * Q * t * 0.5),
+                'mean': float(D * Q * t * 0.25)
+            })
+    
+    results_dir = '/tmp/simulation_results'
+    os.makedirs(results_dir, exist_ok=True)
+    
+    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+    
+    if FENICS_AVAILABLE:
+        xdmf_file = os.path.join(results_dir, f'result_{timestamp}.xdmf')
+        file = fe.XDMFFile(xdmf_file)
+        file.write(u, 0)
+        file.close()
+    else:
+        xdmf_file = os.path.join(results_dir, f'result_{timestamp}.txt')
+        with open(xdmf_file, 'w') as f:
+            f.write(json.dumps({'final_max': final_max, 'final_mean': final_mean}))
+    
+    image_path = os.path.join(results_dir, f'result_{timestamp}.png')
+    
+    fig, ax = plt.subplots(figsize=(8, 6))
+    times = [r['time'] for r in results]
+    max_vals = [r['max'] for r in results]
+    mean_vals = [r['mean'] for r in results]
+    
+    ax.plot(times, max_vals, 'b-', label='Maximum', linewidth=2)
+    ax.plot(times, mean_vals, 'r--', label='Moyenne', linewidth=2)
+    ax.set_xlabel('Temps', fontsize=12)
+    ax.set_ylabel('Valeur', fontsize=12)
+    ax.set_title(f'Solution FEniCS - D={D}, Q={Q}, T={T:.2f}', fontsize=14)
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+    
+    plt.tight_layout()
+    plt.savefig(image_path, dpi=150, bbox_inches='tight')
+    plt.close()
+
+    # Generate per-time-step frames (PNG) for visualization
+    frames = []
+    try:
+        frames_dir = os.path.join(results_dir, f'frames_{timestamp}')
+        os.makedirs(frames_dir, exist_ok=True)
+        grid_n = 64
+        X, Y = np.meshgrid(np.linspace(-1, 1, grid_n), np.linspace(-1, 1, grid_n))
+        R = np.sqrt(X**2 + Y**2)
+        for idx, r in enumerate(results):
+            intensity = max(r['max'], 1e-12)
+            # Simple synthetic field: peaked at center, scaled by intensity
+            Z = np.clip((1.0 - R) * intensity, 0.0, None)
+            fig2, ax2 = plt.subplots(figsize=(3, 3))
+            im = ax2.imshow(Z, origin='lower', cmap='plasma')
+            ax2.set_axis_off()
+            plt.tight_layout(pad=0)
+            frame_path = os.path.join(frames_dir, f'frame_{idx:04d}.png')
+            plt.savefig(frame_path, dpi=100, bbox_inches='tight', pad_inches=0)
+            plt.close(fig2)
+            frames.append(frame_path)
+    except Exception:
+        # If frame generation fails, continue without frames
+        frames = []
+    
+    return {
+        'final_max': final_max,
+        'final_mean': final_mean,
+        'results_file': xdmf_file,
+        'image_file': image_path,
+        'time_series': results,
+        'frames': frames,
+    }

backend/simulation/migrations/0001_initial.py

@@ -0,0 +1,30 @@
+# Generated by Django 6.0.2 on 2026-02-04 13:38
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Simulation',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(blank=True, max_length=255)),
+                ('parameters', models.JSONField(default=dict)),
+                ('status', models.CharField(choices=[('pending', 'En attente'), ('running', 'En cours'), ('completed', 'Terminée'), ('failed', 'Échouée')], default='pending', max_length=20)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('completed_at', models.DateTimeField(blank=True, null=True)),
+                ('result_summary', models.JSONField(blank=True, null=True)),
+                ('result_file_path', models.CharField(blank=True, max_length=500)),
+                ('result_image_path', models.CharField(blank=True, max_length=500)),
+                ('error_message', models.TextField(blank=True)),
+            ],
+        ),
+    ]

backend/simulation/models.py

@@ -0,0 +1,26 @@
+from django.db import models
+
+
+class Simulation(models.Model):
+    STATUS_CHOICES = [
+        ('pending', 'En attente'),
+        ('running', 'En cours'),
+        ('completed', 'Terminée'),
+        ('failed', 'Échouée'),
+    ]
+    
+    name = models.CharField(max_length=255, blank=True)
+    parameters = models.JSONField(default=dict)
+    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='pending')
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    completed_at = models.DateTimeField(null=True, blank=True)
+    
+    result_summary = models.JSONField(null=True, blank=True)
+    result_file_path = models.CharField(max_length=500, blank=True)
+    result_image_path = models.CharField(max_length=500, blank=True)
+    
+    error_message = models.TextField(blank=True)
+    
+    def __str__(self):
+        return f"Simulation #{self.id} - {self.name or 'Sans nom'}"

backend/simulation/serializers.py

@@ -0,0 +1,16 @@
+from rest_framework import serializers
+from .models import Simulation
+
+
+class SimulationSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Simulation
+        fields = [
+            'id', 'name', 'parameters', 'status',
+            'created_at', 'updated_at', 'completed_at',
+            'result_summary', 'result_file_path', 'result_image_path',
+            'error_message'
+        ]
+        read_only_fields = ['id', 'status', 'created_at', 'updated_at', 
+                          'completed_at', 'result_summary', 'result_file_path',
+                          'result_image_path', 'error_message']

backend/simulation/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

backend/simulation/urls.py

@@ -0,0 +1,4 @@
+from django.urls import path
+from .views import SimulationViewSet
+
+urlpatterns = []

backend/simulation/views.py

@@ -0,0 +1,140 @@
+import os
+from django.utils import timezone
+from django.conf import settings
+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.permissions import AllowAny
+from .models import Simulation
+from .serializers import SimulationSerializer
+from .fenics_runner import run_simulation
+from rest_framework.views import APIView
+from DangVan.dangvan import compute_dang_van
+import threading
+
+
+class SimulationViewSet(viewsets.ModelViewSet):
+    permission_classes = [AllowAny]
+    queryset = Simulation.objects.all().order_by('-created_at')
+    serializer_class = SimulationSerializer
+    
+    def create(self, request, *args, **kwargs):
+        name = request.data.get('name', '')
+        parameters = request.data.get('parameters', {})
+        
+        simulation = Simulation.objects.create(
+            name=name,
+            parameters=parameters,
+            status='running'
+        )
+        
+        thread = threading.Thread(
+            target=self._run_simulation_async,
+            args=(simulation.id, parameters)
+        )
+        thread.start()
+        
+        serializer = self.get_serializer(simulation)
+        return Response(serializer.data, status=status.HTTP_201_CREATED)
+    
+    def _run_simulation_async(self, simulation_id, parameters):
+        simulation = Simulation.objects.get(id=simulation_id)
+        try:
+            result = run_simulation(parameters)
+            
+            results_dir = os.path.join(settings.BASE_DIR, 'simulation_results')
+            os.makedirs(results_dir, exist_ok=True)
+            
+            import shutil
+            final_result_path = os.path.join(
+                results_dir, 
+                f'result_{simulation_id}.txt'
+            )
+            shutil.copy(result['results_file'], final_result_path)
+            
+            final_image_path = os.path.join(
+                results_dir,
+                f'result_{simulation_id}.png'
+            )
+            shutil.copy(result['image_file'], final_image_path)
+
+            # Copy generated frames if present
+            frames_meta = None
+            frames_src = result.get('frames') or []
+            if frames_src:
+                frames_target_dir = os.path.join(results_dir, f'frames_{simulation_id}')
+                os.makedirs(frames_target_dir, exist_ok=True)
+                copied = []
+                for fp in frames_src:
+                    try:
+                        basename = os.path.basename(fp)
+                        dest = os.path.join(frames_target_dir, basename)
+                        shutil.copy(fp, dest)
+                        copied.append(f'simulation_results/frames_{simulation_id}/{basename}')
+                    except Exception:
+                        continue
+                if copied:
+                    frames_meta = {
+                        'dir': f'simulation_results/frames_{simulation_id}',
+                        'files': copied,
+                        'count': len(copied),
+                    }
+            
+            simulation.result_summary = {
+                'final_max': result['final_max'],
+                'final_mean': result['final_mean'],
+                'time_series': result['time_series'],
+                'frames': frames_meta
+            }
+            simulation.result_file_path = f'simulation_results/result_{simulation_id}.txt'
+            simulation.result_image_path = f'simulation_results/result_{simulation_id}.png'
+            simulation.status = 'completed'
+            simulation.completed_at = timezone.now()
+            simulation.save()
+            
+        except Exception as e:
+            simulation.status = 'failed'
+            simulation.error_message = str(e)
+            simulation.save()
+    
+    @action(detail=True, methods=['get'])
+    def result_image(self, request, pk=None):
+        simulation = self.get_object()
+        if simulation.result_image_path:
+            image_path = os.path.join(settings.BASE_DIR, simulation.result_image_path)
+            from django.http import FileResponse
+            return FileResponse(open(image_path, 'rb'), content_type='image/png')
+        return Response({'error': 'Aucune image disponible'}, status=404)
+
+    @action(detail=True, methods=['get'], url_path='frame/(?P<index>\\d+)')
+    def frame(self, request, pk=None, index=None):
+        simulation = self.get_object()
+        frames = (simulation.result_summary or {}).get('frames') or {}
+        files = frames.get('files') or []
+        try:
+            idx = int(index)
+        except Exception:
+            return Response({'error': 'Index invalide'}, status=400)
+        if 0 <= idx < len(files):
+            frame_rel = files[idx]
+            frame_abs = os.path.join(settings.BASE_DIR, frame_rel)
+            from django.http import FileResponse
+            return FileResponse(open(frame_abs, 'rb'), content_type='image/png')
+        return Response({'error': 'Frame non disponible'}, status=404)
+
+
+class DangVanView(APIView):
+    permission_classes = [AllowAny]
+
+    def post(self, request):
+        data = request.data or {}
+        stress_series = data.get('stress_series')
+        a = data.get('a')
+        b = data.get('b')
+        if stress_series is None or a is None or b is None:
+            return Response({'error': 'Paramètres requis: stress_series, a, b'}, status=status.HTTP_400_BAD_REQUEST)
+        try:
+            result = compute_dang_van(stress_series, a, b)
+            return Response(result, status=status.HTTP_200_OK)
+        except Exception as e:
+            return Response({'error': str(e)}, status=status.HTTP_400_BAD_REQUEST)

requirements.txt

@@ -0,0 +1,7 @@
+django>=4.2
+djangorestframework>=3.14
+gunicorn>=21.0
+matplotlib>=3.7
+numpy>=1.24
+django-cors-headers>=4.3
+whitenoise>=6.6

static/assets/index-DYM3EwRh.css

@@ -0,0 +1 @@
+.app{max-width:1200px;margin:0 auto;padding:20px;font-family:system-ui,-apple-system,sans-serif}header{text-align:center;margin-bottom:30px}main{display:grid;grid-template-columns:1fr 1fr;gap:20px}.simulation-form,.simulation-list,.result-section{background:#f5f5f5;padding:20px;border-radius:8px}.form-group{margin-bottom:15px}.form-group label{display:block;margin-bottom:5px;font-weight:700}.form-group input[type=text]{width:100%;padding:8px;border:1px solid #ddd;border-radius:4px;box-sizing:border-box}.form-group input[type=range]{width:100%}button{background:#007bff;color:#fff;border:none;padding:10px 20px;border-radius:4px;cursor:pointer;width:100%;font-size:1rem}button:disabled{background:#ccc;cursor:not-allowed}table{width:100%;border-collapse:collapse}th,td{padding:10px;text-align:left;border-bottom:1px solid #ddd}tr:hover{cursor:pointer;background:#e9e9e9}.status{padding:4px 8px;border-radius:4px;font-size:.9em}.status-completed{background:#d4edda;color:#155724}.status-running{background:#fff3cd;color:#856404}.status-failed{background:#f8d7da;color:#721c24}.status-pending{background:#e2e3e5;color:#383d41}.result-image img{max-width:100%;border-radius:4px}.error{background:#f8d7da;color:#721c24;padding:10px;border-radius:4px;margin-bottom:15px}.result-section{grid-column:1 / -1}@media (max-width: 768px){main{grid-template-columns:1fr}}

static/index.html

@@ -0,0 +1,975 @@
+<!DOCTYPE html>
+<html lang="fr">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>SimSite - Applications de Simulation</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+      * { box-sizing: border-box; }
+      body { font-family: 'Segoe UI', sans-serif; margin: 0; padding: 0; background: #0a0a1a; color: #eee; min-height: 100vh; }
+      
+      /* Navigation */
+      .navbar {
+        background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+        padding: 15px 30px;
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        border-bottom: 1px solid #0f3460;
+        position: sticky;
+        top: 0;
+        z-index: 100;
+      }
+      .navbar-brand {
+        font-size: 1.5em;
+        font-weight: bold;
+        color: #00d4ff;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        gap: 10px;
+      }
+      .navbar-brand:hover { opacity: 0.8; }
+      .nav-breadcrumb {
+        color: #888;
+        font-size: 0.9em;
+      }
+      .nav-breadcrumb span { color: #00d4ff; }
+
+      /* Views */
+      .view { display: none; padding: 30px; max-width: 1400px; margin: 0 auto; }
+      .view.active { display: block; }
+
+      /* Home Page */
+      .home-header {
+        text-align: center;
+        padding: 60px 20px;
+        background: linear-gradient(135deg, #1a1a2e 0%, #0f3460 100%);
+        margin: -30px -30px 30px -30px;
+        border-bottom: 2px solid #00d4ff;
+      }
+      .home-header h1 {
+        font-size: 3em;
+        margin: 0;
+        background: linear-gradient(135deg, #00d4ff, #00ff88);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        background-clip: text;
+      }
+      .home-header p {
+        color: #aaa;
+        font-size: 1.2em;
+        margin-top: 10px;
+      }
+
+      /* App Cards */
+      .apps-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(350px, 1fr));
+        gap: 30px;
+        padding: 20px 0;
+      }
+      .app-card {
+        background: linear-gradient(145deg, #1a1a2e, #16213e);
+        border: 1px solid #0f3460;
+        border-radius: 16px;
+        padding: 30px;
+        cursor: pointer;
+        transition: all 0.3s ease;
+        position: relative;
+        overflow: hidden;
+      }
+      .app-card::before {
+        content: '';
+        position: absolute;
+        top: 0;
+        left: 0;
+        right: 0;
+        height: 4px;
+        background: linear-gradient(90deg, var(--card-color), transparent);
+      }
+      .app-card:hover {
+        transform: translateY(-5px);
+        box-shadow: 0 10px 40px rgba(0, 212, 255, 0.2);
+        border-color: var(--card-color);
+      }
+      .app-card-icon {
+        font-size: 3em;
+        margin-bottom: 15px;
+      }
+      .app-card h2 {
+        color: #fff;
+        margin: 0 0 10px 0;
+        font-size: 1.5em;
+      }
+      .app-card p {
+        color: #aaa;
+        margin: 0 0 20px 0;
+        line-height: 1.6;
+      }
+      .app-card-tags {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 8px;
+      }
+      .app-card-tag {
+        background: rgba(0, 212, 255, 0.1);
+        color: #00d4ff;
+        padding: 4px 12px;
+        border-radius: 20px;
+        font-size: 0.8em;
+      }
+      .app-card-arrow {
+        position: absolute;
+        bottom: 30px;
+        right: 30px;
+        font-size: 1.5em;
+        color: var(--card-color);
+        opacity: 0;
+        transform: translateX(-10px);
+        transition: all 0.3s ease;
+      }
+      .app-card:hover .app-card-arrow {
+        opacity: 1;
+        transform: translateX(0);
+      }
+
+      /* App-specific styles */
+      .section-title {
+        color: #00d4ff;
+        border-bottom: 2px solid #00d4ff;
+        padding-bottom: 10px;
+        margin-bottom: 20px;
+        display: flex;
+        align-items: center;
+        gap: 10px;
+      }
+      .panel {
+        background: #16213e;
+        padding: 25px;
+        border-radius: 12px;
+        border: 1px solid #0f3460;
+        margin-bottom: 20px;
+      }
+      .form-group { margin-bottom: 15px; }
+      .form-group label { display: block; margin-bottom: 5px; color: #00d4ff; font-weight: 500; }
+      .form-group input[type="text"], 
+      .form-group input[type="number"],
+      .form-group textarea { 
+        width: 100%; 
+        padding: 12px; 
+        border-radius: 8px; 
+        border: 1px solid #0f3460; 
+        background: #1a1a2e; 
+        color: #fff; 
+        font-size: 1em;
+        transition: border-color 0.3s;
+      }
+      .form-group input:focus, .form-group textarea:focus {
+        outline: none;
+        border-color: #00d4ff;
+      }
+      .form-group input[type="range"] { width: 100%; accent-color: #00d4ff; }
+      .form-group input[type="file"] { color: #00d4ff; }
+      .form-group textarea { font-family: 'Consolas', monospace; }
+      
+      button, .btn {
+        background: linear-gradient(135deg, #00d4ff, #0099cc);
+        color: #1a1a2e;
+        border: none;
+        padding: 12px 24px;
+        border-radius: 8px;
+        cursor: pointer;
+        font-weight: bold;
+        font-size: 1em;
+        transition: all 0.2s;
+      }
+      button:hover, .btn:hover { transform: scale(1.02); box-shadow: 0 5px 20px rgba(0, 212, 255, 0.3); }
+      button:disabled { opacity: 0.5; cursor: not-allowed; transform: none; }
+      .btn-secondary { background: #0f3460; color: #00d4ff; }
+      .btn-danger { background: #ff1744; color: #fff; }
+
+      /* Grid layouts */
+      .grid-2 { display: grid; grid-template-columns: 1fr 1fr; gap: 20px; }
+      .grid-2-1 { display: grid; grid-template-columns: 2fr 1fr; gap: 20px; }
+      @media (max-width: 900px) {
+        .grid-2, .grid-2-1 { grid-template-columns: 1fr; }
+      }
+
+      /* Table */
+      table { width: 100%; border-collapse: collapse; }
+      th, td { padding: 12px; text-align: left; border-bottom: 1px solid #0f3460; }
+      th { color: #00d4ff; font-weight: 600; }
+      tr:hover { background: rgba(0, 212, 255, 0.05); }
+      
+      /* Status badges */
+      .badge { padding: 4px 12px; border-radius: 20px; font-weight: bold; font-size: 0.85em; }
+      .badge-success { background: #00c853; color: #1a1a2e; }
+      .badge-warning { background: #ffab00; color: #1a1a2e; }
+      .badge-danger { background: #ff1744; color: #fff; }
+
+      /* Results */
+      .result-card {
+        background: #1a1a2e;
+        padding: 20px;
+        border-radius: 12px;
+        border: 1px solid #0f3460;
+      }
+      .result-card h3 { color: #00d4ff; margin: 0 0 15px 0; }
+      .result-value { font-size: 2.5em; color: #00d4ff; font-weight: bold; }
+      .chart-container { height: 350px; position: relative; }
+
+      /* Alerts */
+      .alert { padding: 15px 20px; border-radius: 8px; margin-bottom: 15px; }
+      .alert-error { background: rgba(255, 23, 68, 0.2); border: 1px solid #ff1744; color: #ff6b6b; }
+      .alert-success { background: rgba(0, 200, 83, 0.2); border: 1px solid #00c853; color: #69f0ae; }
+      .alert-info { background: rgba(0, 212, 255, 0.1); border: 1px solid #0f3460; color: #00d4ff; }
+
+      /* Tabs */
+      .tabs { display: flex; gap: 5px; margin-bottom: 20px; }
+      .tab { padding: 10px 20px; background: #0f3460; color: #00d4ff; border: none; border-radius: 8px 8px 0 0; cursor: pointer; transition: all 0.2s; }
+      .tab.active { background: #00d4ff; color: #1a1a2e; }
+      .tab-content { display: none; }
+      .tab-content.active { display: block; }
+
+      /* DV specific */
+      .dv-safe { color: #00c853; font-weight: bold; }
+      .dv-unsafe { color: #ff1744; font-weight: bold; }
+
+      /* Equation box */
+      .equation-box {
+        background: #0f3460;
+        padding: 20px;
+        border-radius: 12px;
+        text-align: center;
+        font-size: 1.1em;
+        margin-bottom: 20px;
+        border-left: 4px solid #00d4ff;
+      }
+      .equation-box .equation { font-size: 1.3em; margin: 10px 0; color: #00d4ff; }
+      .equation-box small { color: #888; }
+
+      /* Animation */
+      .animation-container { text-align: center; }
+      .animation-controls { margin-top: 15px; display: flex; justify-content: center; gap: 10px; }
+      .animation-controls button { width: auto; }
+
+      /* Hidden utility */
+      .hidden { display: none !important; }
+    </style>
+  </head>
+  <body>
+    <!-- Navigation Bar -->
+    <nav class="navbar">
+      <div class="navbar-brand" onclick="navigateTo('home')">
+        <span>SimSite</span>
+      </div>
+      <div class="nav-breadcrumb" id="breadcrumb"></div>
+    </nav>
+
+    <!-- HOME VIEW -->
+    <div id="view-home" class="view active">
+      <div class="home-header">
+        <h1>SimSite</h1>
+        <p>Plateforme de simulation numerique et d'analyse</p>
+      </div>
+
+      <div class="apps-grid">
+        <!-- FEniCS App Card -->
+        <div class="app-card" style="--card-color: #00d4ff;" onclick="navigateTo('fenics')">
+          <div class="app-card-icon">🔬</div>
+          <h2>Simulation FEniCS</h2>
+          <p>Resolution d'equations aux derivees partielles (EDP). Simulez la diffusion thermique sur un domaine 2D avec visualisation en temps reel.</p>
+          <div class="app-card-tags">
+            <span class="app-card-tag">EDP</span>
+            <span class="app-card-tag">Diffusion</span>
+            <span class="app-card-tag">Elements Finis</span>
+          </div>
+          <div class="app-card-arrow">→</div>
+        </div>
+
+        <!-- Dang Van App Card -->
+        <div class="app-card" style="--card-color: #ff6b6b;" onclick="navigateTo('dangvan')">
+          <div class="app-card-icon">⚙️</div>
+          <h2>Analyse Dang Van</h2>
+          <p>Critere de fatigue multiaxiale pour l'analyse de la tenue en fatigue des pieces mecaniques soumises a des chargements complexes.</p>
+          <div class="app-card-tags">
+            <span class="app-card-tag">Fatigue</span>
+            <span class="app-card-tag">Multiaxial</span>
+            <span class="app-card-tag">Mecanique</span>
+          </div>
+          <div class="app-card-arrow">→</div>
+        </div>
+
+        <!-- Placeholder for future apps -->
+        <div class="app-card" style="--card-color: #888; opacity: 0.5; cursor: default;">
+          <div class="app-card-icon">🚀</div>
+          <h2>Prochainement...</h2>
+          <p>D'autres applications de simulation seront ajoutees. Restez connectes pour decouvrir de nouveaux outils d'analyse.</p>
+          <div class="app-card-tags">
+            <span class="app-card-tag">A venir</span>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- FENICS VIEW -->
+    <div id="view-fenics" class="view">
+      <h1 class="section-title">🔬 Simulation FEniCS</h1>
+      
+      <div class="equation-box">
+        <strong>Equation de diffusion transitoire</strong>
+        <div class="equation">∂u/∂t = D · ∇²u + Q</div>
+        <small>
+          u(x,y,t) = champ de temperature | D = coefficient de diffusion | Q = terme source<br>
+          Conditions: u(x,y,0) = 0 | u = 0 sur ∂Ω (bords)
+        </small>
+      </div>
+
+      <div class="grid-2">
+        <!-- Form Panel -->
+        <div class="panel">
+          <h2 class="section-title">Nouvelle Simulation</h2>
+          <form id="simForm">
+            <div class="form-group">
+              <label>Nom de la simulation</label>
+              <input type="text" id="simName" placeholder="Ma simulation">
+            </div>
+            <div class="form-group">
+              <label>Resolution du maillage: <span id="meshVal">32</span></label>
+              <input type="range" id="meshResolution" min="8" max="64" step="8" value="32" oninput="document.getElementById('meshVal').textContent = this.value">
+            </div>
+            <div class="form-group">
+              <label>Coefficient de diffusion D: <span id="diffVal">0.1</span></label>
+              <input type="range" id="diffCoef" min="0.01" max="0.5" step="0.01" value="0.1" oninput="document.getElementById('diffVal').textContent = this.value">
+            </div>
+            <div class="form-group">
+              <label>Terme source Q: <span id="sourceVal">1.0</span></label>
+              <input type="range" id="sourceTerm" min="0.1" max="3.0" step="0.1" value="1.0" oninput="document.getElementById('sourceVal').textContent = this.value">
+            </div>
+            <div class="form-group">
+              <label>Temps final: <span id="timeVal">1.0</span>s</label>
+              <input type="range" id="timeFinal" min="0.1" max="2.0" step="0.1" value="1.0" oninput="document.getElementById('timeVal').textContent = this.value">
+            </div>
+            <div class="form-group">
+              <label>Nombre de pas de temps: <span id="stepsVal">20</span></label>
+              <input type="range" id="numSteps" min="10" max="50" step="5" value="20" oninput="document.getElementById('stepsVal').textContent = this.value">
+            </div>
+            <button type="submit" id="submitBtn">Lancer la simulation</button>
+          </form>
+          <div id="formError" class="alert alert-error hidden"></div>
+        </div>
+
+        <!-- Simulations List -->
+        <div class="panel">
+          <h2 class="section-title">
+            Simulations recentes
+            <button class="btn-secondary" style="margin-left: auto; padding: 8px 16px;" onclick="loadSimulations()">Rafraichir</button>
+          </h2>
+          <table>
+            <thead>
+              <tr><th>ID</th><th>Nom</th><th>Status</th><th>Date</th></tr>
+            </thead>
+            <tbody id="simTable">
+              <tr><td colspan="4">Chargement...</td></tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+
+      <!-- Results Section (hidden by default) -->
+      <div id="resultSection" class="panel hidden">
+        <div style="display: flex; justify-content: space-between; align-items: center;">
+          <h2 class="section-title" style="margin: 0; border: none;">Resultats - Simulation #<span id="resultId"></span></h2>
+          <button class="btn-danger" onclick="closeResults()">Fermer</button>
+        </div>
+        
+        <div class="grid-2" style="margin-top: 20px;">
+          <div class="result-card">
+            <h3>Valeur maximale</h3>
+            <div class="result-value" id="resultMax">-</div>
+          </div>
+          <div class="result-card">
+            <h3>Valeur moyenne</h3>
+            <div class="result-value" id="resultMean">-</div>
+          </div>
+        </div>
+
+        <div class="grid-2" style="margin-top: 20px;">
+          <div class="result-card">
+            <h3>Evolution temporelle</h3>
+            <div class="chart-container"><canvas id="timeChart"></canvas></div>
+          </div>
+          <div class="result-card animation-container">
+            <h3>Animation de la solution</h3>
+            <canvas id="animationCanvas" width="300" height="300"></canvas>
+            <div class="animation-controls">
+              <button onclick="playAnimation()">Play</button>
+              <button onclick="pauseAnimation()">Pause</button>
+              <button onclick="resetAnimation()">Reset</button>
+            </div>
+            <p>Temps: <span id="animTime">0.00</span> / <span id="animTotal">1.00</span>s</p>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- DANG VAN VIEW -->
+    <div id="view-dangvan" class="view">
+      <h1 class="section-title">⚙️ Analyse de Fatigue - Critere de Dang Van</h1>
+
+      <div class="equation-box">
+        <strong>Critere de Dang Van</strong>
+        <div class="equation">τ_max + a · σ_H ≤ b</div>
+        <small>
+          τ_max = contrainte de cisaillement maximale (balayage des facettes)<br>
+          σ_H = pression hydrostatique = (σ_xx + σ_yy + σ_zz) / 3<br>
+          a = pente du critere | b = limite en cisaillement alterne
+        </small>
+      </div>
+
+      <div class="grid-2-1">
+        <div class="panel">
+          <h2 class="section-title">Donnees de contrainte</h2>
+          
+          <div class="tabs">
+            <button class="tab active" onclick="switchDvTab('json')">Saisie JSON</button>
+            <button class="tab" onclick="switchDvTab('file')">Import Fichier</button>
+          </div>
+
+          <div id="dvTabJson" class="tab-content active">
+            <div class="form-group">
+              <label>Serie de tenseurs de contrainte (format Voigt 6 composantes)</label>
+              <textarea id="dvStress" rows="8" placeholder='Exemple:
+[[100, 0, 0, 0, 0, 0],
+ [50, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0],
+ [-50, 0, 0, 0, 0, 0],
+ [-100, 0, 0, 0, 0, 0]]
+
+Format: [σ_xx, σ_yy, σ_zz, σ_xy, σ_xz, σ_yz] en MPa'></textarea>
+            </div>
+          </div>
+
+          <div id="dvTabFile" class="tab-content">
+            <div class="form-group">
+              <label>Fichier CSV ou TXT</label>
+              <input type="file" id="dvFile" accept=".csv,.txt,.dat">
+            </div>
+            <div class="alert alert-info">
+              <strong>Format attendu:</strong><br>
+              - 6 colonnes: σ_xx, σ_yy, σ_zz, σ_xy, σ_xz, σ_yz<br>
+              - Une ligne = un pas de temps<br>
+              - Separateurs: virgule, point-virgule, tabulation ou espace<br>
+              - Lignes commencant par # ou // ignorees
+            </div>
+            <div id="dvFilePreview" class="hidden" style="margin-top: 15px;">
+              <label>Apercu (<span id="dvFileCount">0</span> pas de temps charges)</label>
+              <textarea id="dvFileData" rows="4" readonly style="background: #0f3460;"></textarea>
+            </div>
+          </div>
+        </div>
+
+        <div class="panel">
+          <h2 class="section-title">Parametres du critere</h2>
+          <div class="form-group">
+            <label>Parametre a (pente)</label>
+            <input type="number" id="dvA" value="0.3" step="0.01">
+          </div>
+          <div class="form-group">
+            <label>Parametre b (limite en MPa)</label>
+            <input type="number" id="dvB" value="120.0" step="1">
+          </div>
+          <button id="dvBtn" onclick="calculateDangVan()" style="width: 100%; margin-top: 20px;">
+            Calculer
+          </button>
+        </div>
+      </div>
+
+      <div id="dvError" class="alert alert-error hidden"></div>
+
+      <!-- Results -->
+      <div id="dvResults" class="hidden">
+        <div class="grid-2" style="margin-top: 20px;">
+          <div class="result-card">
+            <h3>Resultat de l'analyse</h3>
+            <table>
+              <tr><td>DV_max</td><td><strong id="dvMax">-</strong> MPa</td></tr>
+              <tr><td>Marge (b - DV_max)</td><td><strong id="dvMargin">-</strong> MPa</td></tr>
+              <tr><td>Verdict</td><td><span id="dvSafe">-</span></td></tr>
+              <tr><td>Point critique</td><td>Pas de temps #<span id="dvCritical">-</span></td></tr>
+            </table>
+          </div>
+          <div class="result-card">
+            <h3>Interpretation</h3>
+            <div id="dvInterpretation" style="color: #aaa; line-height: 1.8;"></div>
+          </div>
+        </div>
+
+        <div class="panel" style="margin-top: 20px;">
+          <h3 class="section-title">Diagramme de Dang Van</h3>
+          <div class="chart-container" style="height: 450px;">
+            <canvas id="dvChart"></canvas>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <script>
+      // ============================================
+      // NAVIGATION
+      // ============================================
+      const views = {
+        home: { title: '', breadcrumb: '' },
+        fenics: { title: 'Simulation FEniCS', breadcrumb: '<span>Accueil</span> / Simulation FEniCS' },
+        dangvan: { title: 'Analyse Dang Van', breadcrumb: '<span>Accueil</span> / Analyse Dang Van' }
+      };
+
+      function navigateTo(viewId) {
+        // Hide all views
+        document.querySelectorAll('.view').forEach(v => v.classList.remove('active'));
+        // Show target view
+        document.getElementById('view-' + viewId).classList.add('active');
+        // Update breadcrumb
+        document.getElementById('breadcrumb').innerHTML = views[viewId].breadcrumb;
+        // Scroll to top
+        window.scrollTo(0, 0);
+        // Load data if needed
+        if (viewId === 'fenics') loadSimulations();
+      }
+
+      // ============================================
+      // GLOBALS
+      // ============================================
+      const API_URL = '/api';
+      let timeChart = null;
+      let dvChart = null;
+      let animationId = null;
+      let animFrame = 0;
+      let animData = [];
+      let isAnimating = false;
+      let animFrameImages = [];
+      let useImageFrames = false;
+      let dvStressFromFile = null;
+
+      // ============================================
+      // FENICS SIMULATION
+      // ============================================
+      async function loadSimulations() {
+        try {
+          const res = await fetch(API_URL + '/simulations/');
+          if (!res.ok) throw new Error('Erreur serveur: ' + res.status);
+          const data = await res.json();
+          const tbody = document.getElementById('simTable');
+          if (data.length === 0) {
+            tbody.innerHTML = '<tr><td colspan="4">Aucune simulation</td></tr>';
+          } else {
+            tbody.innerHTML = data.slice(0, 10).map(sim => {
+              const badge = sim.status === 'completed' ? 'badge-success' : 
+                            sim.status === 'running' ? 'badge-warning' : 'badge-danger';
+              return `<tr onclick="showResults(${sim.id})" style="cursor:pointer">
+                <td>#${sim.id}</td>
+                <td>${sim.name || 'Sans nom'}</td>
+                <td><span class="badge ${badge}">${sim.status}</span></td>
+                <td>${new Date(sim.created_at).toLocaleDateString()}</td>
+              </tr>`;
+            }).join('');
+          }
+        } catch (err) {
+          document.getElementById('simTable').innerHTML = `<tr><td colspan="4" class="alert-error">${err.message}</td></tr>`;
+        }
+      }
+
+      async function showResults(id) {
+        try {
+          const res = await fetch(API_URL + '/simulations/' + id + '/');
+          if (!res.ok) throw new Error('Erreur serveur');
+          const sim = await res.json();
+          
+          if (sim.status !== 'completed') {
+            alert('Simulation non terminee (status: ' + sim.status + ')');
+            return;
+          }
+          if (!sim.result_summary) {
+            alert('Pas de resultats disponibles');
+            return;
+          }
+          
+          document.getElementById('resultSection').classList.remove('hidden');
+          document.getElementById('resultId').textContent = sim.id;
+          document.getElementById('resultMax').textContent = (sim.result_summary.final_max || 0).toFixed(4);
+          document.getElementById('resultMean').textContent = (sim.result_summary.final_mean || 0).toFixed(4);
+          
+          animData = sim.result_summary.time_series || [];
+          updateTimeChart(animData);
+          resetAnimation();
+          
+          document.getElementById('resultSection').scrollIntoView({ behavior: 'smooth' });
+        } catch (err) {
+          alert('Erreur: ' + err.message);
+        }
+      }
+
+      function closeResults() {
+        document.getElementById('resultSection').classList.add('hidden');
+        stopAnimation();
+      }
+
+      function updateTimeChart(data) {
+        const ctx = document.getElementById('timeChart').getContext('2d');
+        if (timeChart) timeChart.destroy();
+        if (!data || data.length === 0) return;
+        
+        timeChart = new Chart(ctx, {
+          type: 'line',
+          data: {
+            labels: data.map(d => (d.time || 0).toFixed(2)),
+            datasets: [{
+              label: 'Maximum',
+              data: data.map(d => d.max || 0),
+              borderColor: '#00d4ff',
+              backgroundColor: 'rgba(0, 212, 255, 0.1)',
+              fill: true,
+              tension: 0.3
+            }, {
+              label: 'Moyenne',
+              data: data.map(d => d.mean || 0),
+              borderColor: '#ff6b6b',
+              backgroundColor: 'rgba(255, 107, 107, 0.1)',
+              fill: true,
+              tension: 0.3
+            }]
+          },
+          options: {
+            responsive: true,
+            maintainAspectRatio: false,
+            plugins: { legend: { labels: { color: '#fff' } } },
+            scales: {
+              x: { ticks: { color: '#888' }, grid: { color: 'rgba(255,255,255,0.1)' }, title: { display: true, text: 'Temps (s)', color: '#00d4ff' } },
+              y: { ticks: { color: '#888' }, grid: { color: 'rgba(255,255,255,0.1)' }, title: { display: true, text: 'Valeur', color: '#00d4ff' } }
+            }
+          }
+        });
+      }
+
+      // Animation
+      function stopAnimation() {
+        if (animationId) cancelAnimationFrame(animationId);
+        isAnimating = false;
+      }
+
+      function playAnimation() {
+        if (animData.length === 0) return;
+        isAnimating = true;
+        animate();
+      }
+
+      function pauseAnimation() { isAnimating = false; }
+
+      function resetAnimation() {
+        stopAnimation();
+        animFrame = 0;
+        drawHeatmap(null);
+        document.getElementById('animTime').textContent = '0.00';
+        document.getElementById('animTotal').textContent = animData.length > 0 ? (animData[animData.length-1].time || 0).toFixed(2) : '0.00';
+      }
+
+      function animate() {
+        if (!isAnimating || animFrame >= animData.length) {
+          isAnimating = false;
+          return;
+        }
+        const frameData = animData[animFrame];
+        drawHeatmap(frameData);
+        document.getElementById('animTime').textContent = (frameData.time || 0).toFixed(2);
+        animFrame++;
+        animationId = requestAnimationFrame(() => setTimeout(animate, 100));
+      }
+
+      function drawHeatmap(frameData) {
+        const canvas = document.getElementById('animationCanvas');
+        const ctx = canvas.getContext('2d');
+        const size = canvas.width;
+        const gridSize = 32;
+        const cellSize = size / gridSize;
+        
+        ctx.fillStyle = '#1a1a2e';
+        ctx.fillRect(0, 0, size, size);
+        
+        if (!frameData) {
+          ctx.fillStyle = '#888';
+          ctx.font = '14px sans-serif';
+          ctx.textAlign = 'center';
+          ctx.fillText('Cliquez Play pour demarrer', size/2, size/2);
+          return;
+        }
+        
+        const maxVal = Math.max(...animData.map(d => d.max || 0.001));
+        for (let i = 0; i < gridSize; i++) {
+          for (let j = 0; j < gridSize; j++) {
+            const distance = Math.sqrt((i - gridSize/2)**2 + (j - gridSize/2)**2);
+            const normalizedDist = Math.min(distance / (gridSize/2), 1);
+            const heatValue = Math.max(0, 1 - normalizedDist) * ((frameData.max || 0) / maxVal);
+            const r = Math.floor(255 * heatValue);
+            const g = Math.floor(100 * heatValue);
+            const b = Math.floor(255 * (1 - heatValue));
+            ctx.fillStyle = `rgb(${r},${g},${b})`;
+            ctx.fillRect(j * cellSize, (gridSize - 1 - i) * cellSize, cellSize, cellSize);
+          }
+        }
+      }
+
+      // Form submission
+      document.getElementById('simForm').addEventListener('submit', async (e) => {
+        e.preventDefault();
+        const btn = document.getElementById('submitBtn');
+        const errDiv = document.getElementById('formError');
+        errDiv.classList.add('hidden');
+        btn.disabled = true;
+        btn.textContent = 'Calcul en cours...';
+        
+        const params = {
+          mesh_resolution: parseInt(document.getElementById('meshResolution').value),
+          diffusion_coefficient: parseFloat(document.getElementById('diffCoef').value),
+          source_term: parseFloat(document.getElementById('sourceTerm').value),
+          time_final: parseFloat(document.getElementById('timeFinal').value),
+          num_steps: parseInt(document.getElementById('numSteps').value)
+        };
+        
+        try {
+          const res = await fetch(API_URL + '/simulations/', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: document.getElementById('simName').value || 'Simulation', parameters: params })
+          });
+          if (!res.ok) throw new Error('Erreur creation: ' + res.status);
+          
+          btn.textContent = 'Simulation lancee!';
+          setTimeout(() => {
+            loadSimulations();
+            btn.disabled = false;
+            btn.textContent = 'Lancer la simulation';
+          }, 1500);
+        } catch (err) {
+          errDiv.textContent = err.message;
+          errDiv.classList.remove('hidden');
+          btn.disabled = false;
+          btn.textContent = 'Lancer la simulation';
+        }
+      });
+
+      // ============================================
+      // DANG VAN
+      // ============================================
+      function switchDvTab(tab) {
+        document.querySelectorAll('.tabs .tab').forEach(t => t.classList.remove('active'));
+        document.querySelectorAll('.tab-content').forEach(c => c.classList.remove('active'));
+        
+        if (tab === 'json') {
+          document.querySelector('.tabs .tab:first-child').classList.add('active');
+          document.getElementById('dvTabJson').classList.add('active');
+          dvStressFromFile = null;
+        } else {
+          document.querySelector('.tabs .tab:last-child').classList.add('active');
+          document.getElementById('dvTabFile').classList.add('active');
+        }
+      }
+
+      function parseStressFile(content) {
+        const lines = content.trim().split('\n');
+        const data = [];
+        for (let line of lines) {
+          line = line.trim();
+          if (!line || line.startsWith('#') || line.startsWith('//') || line.match(/^[a-zA-Z]/)) continue;
+          let values;
+          if (line.includes(',')) values = line.split(',');
+          else if (line.includes(';')) values = line.split(';');
+          else if (line.includes('\t')) values = line.split('\t');
+          else values = line.split(/\s+/);
+          const nums = values.map(v => parseFloat(v.trim())).filter(n => !isNaN(n));
+          if (nums.length >= 6) data.push(nums.slice(0, 6));
+        }
+        return data;
+      }
+
+      document.getElementById('dvFile').addEventListener('change', async (e) => {
+        const file = e.target.files[0];
+        if (!file) return;
+        try {
+          const content = await file.text();
+          const parsed = parseStressFile(content);
+          if (parsed.length === 0) {
+            alert('Aucune donnee valide trouvee');
+            return;
+          }
+          dvStressFromFile = parsed;
+          document.getElementById('dvFilePreview').classList.remove('hidden');
+          document.getElementById('dvFileCount').textContent = parsed.length;
+          document.getElementById('dvFileData').value = parsed.slice(0, 5).map(r => r.map(v => v.toFixed(1)).join(', ')).join('\n') + (parsed.length > 5 ? '\n...' : '');
+        } catch (err) {
+          alert('Erreur lecture: ' + err.message);
+        }
+      });
+
+      async function calculateDangVan() {
+        const btn = document.getElementById('dvBtn');
+        const errDiv = document.getElementById('dvError');
+        errDiv.classList.add('hidden');
+        btn.disabled = true;
+        btn.textContent = 'Calcul en cours...';
+
+        let stress;
+        const jsonTab = document.getElementById('dvTabJson').classList.contains('active');
+        
+        if (jsonTab) {
+          try {
+            const raw = document.getElementById('dvStress').value.trim();
+            if (!raw) throw new Error('Entrez des donnees JSON');
+            stress = JSON.parse(raw);
+          } catch (e) {
+            errDiv.textContent = 'JSON invalide: ' + e.message;
+            errDiv.classList.remove('hidden');
+            btn.disabled = false;
+            btn.textContent = 'Calculer';
+            return;
+          }
+        } else {
+          if (!dvStressFromFile || dvStressFromFile.length === 0) {
+            errDiv.textContent = 'Chargez un fichier CSV/TXT valide';
+            errDiv.classList.remove('hidden');
+            btn.disabled = false;
+            btn.textContent = 'Calculer';
+            return;
+          }
+          stress = dvStressFromFile;
+        }
+
+        const a = parseFloat(document.getElementById('dvA').value);
+        const b = parseFloat(document.getElementById('dvB').value);
+
+        try {
+          const res = await fetch(API_URL + '/dangvan/', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ stress_series: stress, a, b })
+          });
+          const data = await res.json();
+          if (!res.ok) throw new Error(data.error || 'Erreur serveur');
+          
+          displayDangVanResults(data);
+        } catch (err) {
+          errDiv.textContent = err.message;
+          errDiv.classList.remove('hidden');
+        } finally {
+          btn.disabled = false;
+          btn.textContent = 'Calculer';
+        }
+      }
+
+      function displayDangVanResults(data) {
+        document.getElementById('dvResults').classList.remove('hidden');
+        document.getElementById('dvMax').textContent = data.dv_max.toFixed(2);
+        document.getElementById('dvMargin').textContent = data.margin.toFixed(2);
+        document.getElementById('dvCritical').textContent = data.index_max;
+        
+        const safeEl = document.getElementById('dvSafe');
+        const interpEl = document.getElementById('dvInterpretation');
+        
+        if (data.safe) {
+          safeEl.innerHTML = '<span class="dv-safe">SECURITE OK</span>';
+          interpEl.innerHTML = `
+            <p>La piece est <strong style="color:#00c853">securisee</strong> vis-a-vis de la fatigue multiaxiale.</p>
+            <p>Tous les points de chargement se situent sous la droite de Dang Van.</p>
+            <p>Marge de securite: <strong>${data.margin.toFixed(2)} MPa</strong></p>
+          `;
+        } else {
+          safeEl.innerHTML = '<span class="dv-unsafe">RISQUE DE FATIGUE</span>';
+          interpEl.innerHTML = `
+            <p>La piece presente un <strong style="color:#ff1744">risque de fatigue</strong>.</p>
+            <p>Un ou plusieurs points de chargement depassent la limite de Dang Van.</p>
+            <p>Depassement maximal: <strong>${Math.abs(data.margin).toFixed(2)} MPa</strong> au pas de temps #${data.index_max}</p>
+          `;
+        }
+        
+        updateDvChart(data);
+        document.getElementById('dvResults').scrollIntoView({ behavior: 'smooth' });
+      }
+
+      function updateDvChart(data) {
+        const ctx = document.getElementById('dvChart').getContext('2d');
+        if (dvChart) dvChart.destroy();
+        
+        const points = data.points || [];
+        const criterionLine = data.criterion_line || [];
+        
+        const scatterData = points.map(p => ({ x: p.sigma_H, y: p.tau_max }));
+        const lineData = criterionLine.map(p => ({ x: p.sigma_H, y: p.tau }));
+        
+        // Find safe/unsafe points
+        const safePoints = points.filter(p => p.dv <= data.b).map(p => ({ x: p.sigma_H, y: p.tau_max }));
+        const unsafePoints = points.filter(p => p.dv > data.b).map(p => ({ x: p.sigma_H, y: p.tau_max }));
+        
+        dvChart = new Chart(ctx, {
+          type: 'scatter',
+          data: {
+            datasets: [
+              {
+                label: 'Points securises',
+                data: safePoints,
+                backgroundColor: '#00c853',
+                borderColor: '#00c853',
+                pointRadius: 6,
+                pointHoverRadius: 8
+              },
+              {
+                label: 'Points critiques',
+                data: unsafePoints,
+                backgroundColor: '#ff1744',
+                borderColor: '#ff1744',
+                pointRadius: 6,
+                pointHoverRadius: 8
+              },
+              {
+                label: `Limite: τ = ${data.b} - ${data.a}·σH`,
+                data: lineData,
+                type: 'line',
+                borderColor: '#ffab00',
+                borderWidth: 3,
+                borderDash: [8, 4],
+                fill: false,
+                pointRadius: 0
+              }
+            ]
+          },
+          options: {
+            responsive: true,
+            maintainAspectRatio: false,
+            plugins: {
+              legend: { labels: { color: '#fff', font: { size: 12 } } },
+              title: { display: true, text: 'Diagramme de Dang Van (τ_max vs σ_H)', color: '#00d4ff', font: { size: 16 } }
+            },
+            scales: {
+              x: {
+                type: 'linear',
+                ticks: { color: '#888' },
+                grid: { color: 'rgba(255,255,255,0.1)' },
+                title: { display: true, text: 'Pression hydrostatique σH (MPa)', color: '#00d4ff', font: { size: 14 } }
+              },
+              y: {
+                ticks: { color: '#888' },
+                grid: { color: 'rgba(255,255,255,0.1)' },
+                title: { display: true, text: 'Cisaillement max τ_max (MPa)', color: '#00d4ff', font: { size: 14 } }
+              }
+            }
+          }
+        });
+      }
+
+      // ============================================
+      // INIT
+      // ============================================
+      console.log('SimSite loaded');
+    </script>
+  </body>
+</html>