Add Django simulation server with Docker config

.dockerignore

@@ -0,0 +1,37 @@
+__pycache__
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+.env
+.venv
+env/
+venv/
+ENV/
+.git
+.gitignore
+.pytest_cache
+.coverage
+htmlcov/
+*.log
+.DS_Store
+.vscode
+*.sqlite3
+db.sqlite3
+media/
+staticfiles/

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV DEBIAN_FRONTEND=noninteractive
+
+WORKDIR /root/bookshop
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+RUN python manage.py migrate --run-syncdb 2>/dev/null || true
+
+EXPOSE 7860
+
+CMD ["sh", "-c", "redis-server --daemonize yes && python manage.py runserver 0.0.0.0:7860"]

Dockerfile.hfspaces

@@ -0,0 +1,23 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV DEBIAN_FRONTEND=noninteractive
+ENV HF_HUB_DISABLE_XDG=1
+
+WORKDIR /root/bookshop
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY simulationserver/requirements.txt .
+RUN pip install --no-cache-dir -r simulationserver/requirements.txt
+
+COPY . .
+
+RUN python manage.py migrate --run-syncdb 2>/dev/null || true
+
+EXPOSE 7860
+
+CMD ["sh", "-c", "python manage.py runserver 0.0.0.0:7860"]

HF_SPACES_README.md

@@ -0,0 +1,132 @@
+# Simulation Server - HuggingFace Spaces Deployment
+
+## Overview
+
+This project is a Django web application for running numerical simulations with asynchronous processing via Celery and Redis.
+
+## HuggingFace Spaces Configuration
+
+### Option 1: Using Gradio Interface (Recommended)
+
+Create a new file `simulations/gradio_app.py`:
+
+```python
+import gradio as gr
+import requests
+
+def run_simulation(method, **params):
+    response = requests.post(
+        "http://localhost:8000/api/runs/",
+        json={"method": method, "parameters": params}
+    )
+    return response.json()
+
+# Create Gradio interface...
+```
+
+### Option 2: Using Docker (Full Features)
+
+1. **Create a new Space on HuggingFace**
+   - Go to https://huggingface.co/new-space
+   - Choose "Docker" as the SDK
+   - Set hardware to "CPU" or "GPU" as needed
+
+2. **Push your code to HuggingFace**
+   ```bash
+   git add .
+   git commit -m "Add HuggingFace deployment"
+   git remote add hf https://huggingface.co/username/space-name
+   git push hf main
+   ```
+
+3. **Create `HF_Dockerfile`** in your repository root:
+   ```dockerfile
+   FROM python:3.11-slim
+   
+   ENV PYTHONDONTWRITEBYTECODE=1
+   ENV PYTHONUNBUFFERED=1
+   
+   WORKDIR /root/bookshop
+   
+   RUN apt-get update && apt-get install -y --no-install-recommends gcc
+   RUN rm -rf /var/lib/apt/lists/*
+   
+   COPY simulationserver/requirements.txt .
+   RUN pip install --no-cache-dir -r simulationserver/requirements.txt
+   
+   COPY . .
+   
+   EXPOSE 7860
+   
+   CMD ["python", "manage.py", "runserver", "0.0.0.0:7860"]
+   ```
+
+4. **Update `simulationserver/settings.py`** for HuggingFace:
+   ```python
+   # Use environment variables
+   SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY', 'your-secret-key')
+   DEBUG = os.environ.get('DEBUG', 'False').lower() in ('true', '1')
+   ```
+
+## Important Notes for HuggingFace Spaces
+
+### Limitations
+- **No persistent Redis**: Celery workers won't work with persistent queues
+- **No background tasks**: Jobs are limited to the container lifetime
+- **Ephemeral storage**: Files are lost when the space restarts
+
+### Recommended: Use Synchronous Mode
+
+For HuggingFace Spaces, modify `simulations/tasks.py` to run synchronously:
+
+```python
+def run_simulation_sync(method_slug, params):
+    """Run simulation synchronously for HuggingFace Spaces."""
+    method_func = SIMULATION_METHODS.get(method_slug)
+    if not method_func:
+        raise ValueError(f"Méthode inconnue: {method_slug}")
+    
+    result = None
+    for progress in method_func(params):
+        yield progress
+        if progress >= 100:
+            break
+    return result
+```
+
+### Alternative: Use External Redis
+
+For full Celery support, use an external Redis service:
+
+```python
+CELERY_BROKER_URL = os.environ.get('REDIS_URL', 'redis://localhost:6379/0')
+```
+
+## Local Development with Docker
+
+```bash
+# Build and run
+docker build -t simulation-server .
+docker run -p 8000:8000 simulation-server
+
+# With docker-compose
+docker-compose up -d
+```
+
+## Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `DJANGO_SECRET_KEY` | Django secret key | `django-insecure-...` |
+| `DEBUG` | Debug mode | `True` |
+| `CELERY_BROKER_URL` | Redis broker URL | `redis://localhost:6379/0` |
+
+## API Endpoints
+
+- `GET /` - Homepage
+- `GET /methods/` - List simulation methods
+- `GET /run/create/` - Create new simulation
+- `GET /runs/` - List simulation history
+- `GET /run/{id}/` - View simulation results
+- `POST /api/runs/` - Create simulation via API
+- `GET /api/runs/{id}/` - Get simulation status via API

README.md

@@ -3,12 +3,10 @@ title: Simulations
 emoji: 🐠
 colorFrom: red
 colorTo: indigo
-sdk: gradio
-sdk_version: 6.3.0
-app_file: app.py
+sdk: docker
+sdk_version: latest
+app_file: Dockerfile
 pinned: false
 license: mit
-short_description: simulations models
+short_description: Numerical simulations with Django + Celery + Redis
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

bookshop_old/asgi.py

@@ -0,0 +1,16 @@
+"""
+ASGI config for bookshop 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', 'bookshop.settings')
+
+application = get_asgi_application()

bookshop_old/settings.py

@@ -0,0 +1,128 @@
+"""
+Django settings for bookshop project.
+
+Generated by 'django-admin startproject' using Django 6.0.1.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/6.0/topics/settings/
+
+For the full list of settings and their values, see
+https://docs.djangoproject.com/en/6.0/ref/settings/
+"""
+
+from pathlib import Path
+import sys
+from pathlib import Path
+import os
+sys.path.insert(0, str(Path.home() / 'django-polls'))
+
+# Build paths inside the project like this: BASE_DIR / 'subdir'.
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+
+# Quick-start development settings - unsuitable for production
+# See https://docs.djangoproject.com/en/6.0/howto/deployment/checklist/
+
+# SECURITY WARNING: keep the secret key used in production secret!
+SECRET_KEY = 'django-insecure-2#632)2^e*@ga!x@$mj^6=u7dj)2t#gq^t8)2t3!1jr0o(9he0'
+
+# SECURITY WARNING: don't run with debug turned on in production!
+DEBUG = True
+
+ALLOWED_HOSTS = ['testserver.com', 'testserver','localhost', ]
+
+INTERNAL_IPS = [
+    "127.0.0.1",
+]
+
+
+# Application definition
+
+INSTALLED_APPS = [
+    'django_polls.apps.PollsConfig',
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    'debug_toolbar',
+]
+
+MIDDLEWARE = [
+    'django.middleware.security.SecurityMiddleware',
+    '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',
+    'debug_toolbar.middleware.DebugToolbarMiddleware',
+]
+
+ROOT_URLCONF = 'bookshop.urls'
+
+TEMPLATES = [
+    {
+        "BACKEND": "django.template.backends.django.DjangoTemplates",
+        "DIRS": [BASE_DIR / "templates"],
+        "APP_DIRS": True,
+        "OPTIONS": {
+            "context_processors": [
+                "django.template.context_processors.request",
+                "django.contrib.auth.context_processors.auth",
+                "django.contrib.messages.context_processors.messages",
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = 'bookshop.wsgi.application'
+
+
+# Database
+# https://docs.djangoproject.com/en/6.0/ref/settings/#databases
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': BASE_DIR / 'db.sqlite3',
+    }
+}
+
+
+# Password validation
+# https://docs.djangoproject.com/en/6.0/ref/settings/#auth-password-validators
+
+AUTH_PASSWORD_VALIDATORS = [
+    {
+        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
+    },
+]
+
+
+# Internationalization
+# https://docs.djangoproject.com/en/6.0/topics/i18n/
+
+LANGUAGE_CODE = 'en-us'
+
+TIME_ZONE = 'UTC'
+
+USE_I18N = True
+
+USE_TZ = True
+
+
+# Static files (CSS, JavaScript, Images)
+# https://docs.djangoproject.com/en/6.0/howto/static-files/
+
+STATIC_URL = 'static/'

bookshop_old/templates/admin/base_site.html

@@ -0,0 +1,13 @@
+{% extends "admin/base.html" %}
+
+{% block title %}{% if subtitle %}{{ subtitle }} | {% endif %}{{ title }} | {{ site_title|default:_('Polls Administration') }}{% endblock %}
+
+{% block branding %}
+<div id="site-name"><a href="{% url 'admin:index' %}">{{ site_header|default:_('Polls Administration') }}</a></div>
+{% if user.is_anonymous %}
+  {% include "admin/color_theme_toggle.html" %}
+{% endif %}
+{% endblock %}  
+
+{% block nav-global %}{% endblock %}
+

bookshop_old/templates/admin/index.html

@@ -0,0 +1,36 @@
+{% extends "admin/index.html" %}
+{% load i18n admin_static %}
+
+{% block bodyclass %}{{ block.super }} app-polls model-question change-list{% endblock %}
+
+{% if not is_popup %}
+{% block breadcrumbs %}
+<div class="breadcrumbs">
+<a href="{% url 'admin:index' %}">{% trans 'Home' %}</a>
+&gt; <a href="{% url 'admin:app_list' app_label='polls' %}">Polls</a>
+&gt; {% trans 'Questions' %}
+</div>
+{% endblock %}
+{% endif %}
+
+{% block content %}
+<div id="content-main">
+    <h1>{% trans 'Recent Questions' %}</h1>
+    {% if latest_question_list %}
+    <table>
+        <tr>
+            <th>Question</th>
+            <th>Published</th>
+        </tr>
+        {% for question in latest_question_list %}
+        <tr>
+            <td><a href="{% url 'admin:polls_question_change' question.id %}">{{ question.question_text }}</a></td>
+            <td>{{ question.pub_date|date:"SHORT_DATE_FORMAT" }}</td>
+        </tr>
+        {% endfor %}
+    </table>
+    {% else %}
+    <p>{% trans 'No questions have been published yet.' %}</p>
+    {% endif %}
+</div>
+{% endblock %}

bookshop_old/urls.py

@@ -0,0 +1,25 @@
+"""
+URL configuration for bookshop project.
+
+The `urlpatterns` list routes URLs to views. For more information please see:
+    https://docs.djangoproject.com/en/6.0/topics/http/urls/
+Examples:
+Function views
+    1. Add an import:  from my_app import views
+    2. Add a URL to urlpatterns:  path('', views.home, name='home')
+Class-based views
+    1. Add an import:  from other_app.views import Home
+    2. Add a URL to urlpatterns:  path('', Home.as_view(), name='home')
+Including another URLconf
+    1. Import the include() function: from django.urls import include, path
+    2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
+"""
+from django.contrib import admin
+from django.urls import path,include
+from debug_toolbar.toolbar import debug_toolbar_urls
+
+urlpatterns = [
+    path('admin/', admin.site.urls),
+    path('polls/', include('django_polls.urls')),
+   
+] + debug_toolbar_urls()

bookshop_old/wsgi.py

@@ -0,0 +1,16 @@
+"""
+WSGI config for bookshop 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', 'bookshop.settings')
+
+application = get_wsgi_application()

docker-compose.yml

@@ -0,0 +1,41 @@
+version: '3.8'
+
+services:
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+
+  web:
+    build: .
+    ports:
+      - "8000:8000"
+    volumes:
+      - .:/root/bookshop
+      - media_data:/root/bookshop/media
+    environment:
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/0
+      - DEBUG=0
+    depends_on:
+      - redis
+
+  celery:
+    build: .
+    volumes:
+      - .:/root/bookshop
+      - media_data:/root/bookshop/media
+    environment:
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/0
+      - DEBUG=0
+    command: celery -A simulationserver worker --loglevel=info --concurrency=2
+    depends_on:
+      - redis
+      - web
+
+volumes:
+  redis_data:
+  media_data:

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', 'simulationserver.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()

requirements.txt

@@ -0,0 +1,7 @@
+Django>=4.2,<5.0
+djangorestframework>=3.14,<4.0
+celery>=5.3,<6.0
+redis>=4.5,<6.0
+numpy>=1.24,<2.0
+matplotlib>=3.7,<4.0
+reportlab>=4.0,<5.0

simulations/admin.py

@@ -0,0 +1,22 @@
+from django.contrib import admin
+from .models import SimulationMethod, SimulationRun
+
+
+@admin.register(SimulationMethod)
+class SimulationMethodAdmin(admin.ModelAdmin):
+    list_display = ['name', 'slug', 'is_active', 'created_at']
+    list_filter = ['is_active', 'created_at']
+    search_fields = ['name', 'description']
+    prepopulated_fields = {'slug': ('name',)}
+
+
+@admin.register(SimulationRun)
+class SimulationRunAdmin(admin.ModelAdmin):
+    list_display = ['id', 'method', 'status', 'progress', 'created_at', 'completed_at']
+    list_filter = ['status', 'method', 'created_at']
+    search_fields = ['name']
+    raw_id_fields = ['method']
+    readonly_fields = [
+        'status', 'progress', 'logs', 'result_data',
+        'error_message', 'started_at', 'completed_at'
+    ]

simulations/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class SimulationsConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'simulations'
+    verbose_name = 'Simulations Numériques'

simulations/gradio_app.py

@@ -0,0 +1,144 @@
+import gradio as gr
+import json
+import time
+from simulations.tasks import SIMULATION_METHODS
+
+def get_method_schema(method_slug):
+    """Get parameter schema for a simulation method."""
+    from simulations.models import SimulationMethod
+    try:
+        method = SimulationMethod.objects.get(slug=method_slug)
+        return method.parameters_schema
+    except SimulationMethod.DoesNotExist:
+        return {}
+
+def create_param_inputs(method_slug):
+    """Create Gradio input components based on method parameters."""
+    schema = get_method_schema(method_slug)
+    inputs = []
+    for param_name, param_info in schema.get('properties', {}).items():
+        default = param_info.get('default', 100)
+        min_val = param_info.get('minimum', 0)
+        max_val = param_info.get('maximum', 1000)
+        step = param_info.get('step', 1)
+        inputs.append(
+            gr.Slider(
+                minimum=min_val,
+                maximum=max_val,
+                value=default,
+                step=step,
+                label=param_info.get('title', param_name)
+            )
+        )
+    return inputs
+
+def run_simulation_gradio(method_slug, *args):
+    """Run simulation and return results."""
+    from simulations.models import SimulationMethod, SimulationRun
+
+    try:
+        method = SimulationMethod.objects.get(slug=method_slug)
+    except SimulationMethod.DoesNotExist:
+        return f"Erreur: Méthode '{method_slug}' non trouvée"
+
+    params = {}
+    schema = get_method_schema(method_slug)
+    properties = schema.get('properties', {})
+
+    for i, (param_name, param_info) in enumerate(properties.items()):
+        if i < len(args):
+            params[param_name] = args[i]
+
+    run = SimulationRun.objects.create(
+        method=method,
+        name=f"Gradio - {method.name}",
+        parameters=params
+    )
+
+    method_func = SIMULATION_METHODS.get(method_slug)
+    if not method_func:
+        return f"Erreur: Méthode '{method_slug}' non implémentée"
+
+    try:
+        gen = method_func(params)
+        result = None
+        for progress in gen:
+            yield f"Progression: {progress}%"
+        result = progress if 'progress' in dir() else {}
+
+        run.set_success(result or {})
+        run.refresh_from_db()
+
+        output = f"Simulation terminée!\n\n"
+        output += f"Méthode: {method.name}\n"
+        output += f"ID: {run.id}\n\n"
+
+        if run.result_data:
+            output += "Résultats:\n"
+            for key, value in run.result_data.items():
+                if isinstance(value, (int, float)):
+                    output += f"  {key}: {value:.4f}\n"
+                elif isinstance(value, list) and len(value) < 10:
+                    output += f"  {key}: {value}\n"
+                else:
+                    output += f"  {key}: [{type(value).__name__}]\n"
+
+        if run.plot_file:
+            output += f"\nGraphique: {run.plot_file.url}"
+
+        return output
+
+    except Exception as e:
+        run.set_failure(str(e))
+        return f"Erreur: {str(e)}"
+
+def update_inputs(method_slug):
+    return create_param_inputs(method_slug)
+
+def create_gradio_app():
+    """Create the Gradio interface."""
+    with gr.Blocks(title="Simulation Numérique") as app:
+        gr.Markdown("# Simulation Numérique")
+        gr.Markdown("Sélectionnez une méthode et configurez les paramètres.")
+
+        with gr.Row():
+            with gr.Column():
+                method_dropdown = gr.Dropdown(
+                    choices=list(SIMULATION_METHODS.keys()),
+                    value='monte-carlo-pi',
+                    label="Méthode de simulation"
+                )
+
+                param_container = gr.Column()
+                with param_container:
+                    initial_inputs = create_param_inputs('monte-carlo-pi')
+
+                run_button = gr.Button("Lancer la simulation", variant="primary")
+
+            with gr.Column():
+                output = gr.Textbox(
+                    label="Résultat",
+                    lines=20,
+                    interactive=False
+                )
+
+        def on_method_change(method_slug):
+            return create_param_inputs(method_slug)
+
+        method_dropdown.change(
+            fn=on_method_change,
+            inputs=method_dropdown,
+            outputs=param_container
+        )
+
+        run_button.click(
+            fn=run_simulation_gradio,
+            inputs=[method_dropdown] + initial_inputs,
+            outputs=output
+        )
+
+    return app
+
+if __name__ == "__main__":
+    app = create_gradio_app()
+    app.launch()

simulations/management/commands/init_simulation_methods.py

@@ -0,0 +1,205 @@
+from django.core.management.base import BaseCommand
+from simulations.models import SimulationMethod
+
+
+class Command(BaseCommand):
+    help = 'Initialise les méthodes de simulation par défaut'
+
+    def handle(self, *args, **options):
+        methods = [
+            {
+                'name': 'Monte Carlo - Estimation de Pi',
+                'slug': 'monte-carlo-pi',
+                'description': 'Estimation de Pi par la méthode de Monte Carlo.',
+                'theory': '''
+## Monte Carlo pour Pi
+
+1. Générer N points aléatoires dans un carré
+2. Compter les points dans le cercle
+3. π ≈ 4 × points_cercle / N
+                '''.strip(),
+                'parameters_schema': {
+                    'type': 'object',
+                    'properties': {
+                        'n_points': {'type': 'integer', 'minimum': 100, 'maximum': 10000000},
+                        'seed': {'type': 'integer'}
+                    },
+                    'required': ['n_points']
+                },
+                'default_parameters': {'n_points': 10000, 'seed': 42}
+            },
+            {
+                'name': 'Diffusion 1D',
+                'slug': 'diffusion-1d',
+                'description': 'Résolution de l\'équation de diffusion en 1D par schéma explicite.',
+                'theory': '''
+## Diffusion 1D
+
+∂u/∂t = D × ∂²u/∂x²
+
+Schéma explicite avec stabilité si D×dt/dx² ≤ 0.5
+                '''.strip(),
+                'parameters_schema': {
+                    'type': 'object',
+                    'properties': {
+                        'length': {'type': 'number', 'minimum': 0.1, 'maximum': 100},
+                        'time': {'type': 'number', 'minimum': 0.01, 'maximum': 1000},
+                        'nx': {'type': 'integer', 'minimum': 10, 'maximum': 10000},
+                        'nt': {'type': 'integer', 'minimum': 10, 'maximum': 100000},
+                        'diffusion_coef': {'type': 'number', 'minimum': 0.001, 'maximum': 10}
+                    }
+                },
+                'default_parameters': {'length': 1.0, 'time': 0.1, 'nx': 50, 'nt': 100, 'diffusion_coef': 1.0}
+            },
+            {
+                'name': 'Résolution Système Linéaire',
+                'slug': 'linear-solve',
+                'description': 'Résolution de Ax = b par décomposition LU.',
+                'theory': '''
+## Système Linéaire
+
+Résolution de Ax = b avec décomposition LU.
+                '''.strip(),
+                'parameters_schema': {
+                    'type': 'object',
+                    'properties': {
+                        'size': {'type': 'integer', 'minimum': 10, 'maximum': 5000},
+                        'seed': {'type': 'integer'}
+                    }
+                },
+                'default_parameters': {'size': 100, 'seed': 42}
+            },
+            {
+                'name': 'Conduction Thermique',
+                'slug': 'heat-conduction',
+                'description': 'Simulation de conduction thermique avec différentes méthodes theta (Newton, finite_difference).',
+                'theory': '''
+## Conduction Thermique
+
+Évolution de la température avec le temps:
+T[n+1] = (1 - (1-θ)×k×dt)×T[n] / (1+θ×k×dt) - k×dt×Ts / (1+θ×k×dt)
+
+- θ = 0: Explicite
+- θ = 0.5: Crank-Nicolson
+- θ = 1: Implicite
+                '''.strip(),
+                'parameters_schema': {
+                    'type': 'object',
+                    'properties': {
+                        'T_initial': {'type': 'number', 'minimum': 0, 'maximum': 1000},
+                        'T_surface': {'type': 'number', 'minimum': 0, 'maximum': 1000},
+                        'conductivity': {'type': 'number', 'minimum': 0.001, 'maximum': 10},
+                        'dt': {'type': 'number', 'minimum': 0.0001, 'maximum': 1},
+                        'N': {'type': 'integer', 'minimum': 100, 'maximum': 10000},
+                        'theta': {'type': 'number', 'minimum': 0, 'maximum': 1.2}
+                    }
+                },
+                'default_parameters': {'T_initial': 100.0, 'T_surface': 20.0, 'conductivity': 0.1, 'dt': 0.001, 'N': 1000, 'theta': 0.5}
+            },
+            {
+                'name': 'Flux de Trafic',
+                'slug': 'traffic-flow',
+                'description': 'Modèle de trafic 1D avec choc (red light) - numerical-mooc.',
+                'theory': '''
+## Modèle de Trafic
+
+LWR (Lighthill-Whitham-Richards):
+∂ρ/∂t + ∂F/∂x = 0, avec F = ρ × u_max × (1 - ρ/ρ_max)
+
+Condition initiale: choc à x=3.0 (rouge)
+                '''.strip(),
+                'parameters_schema': {
+                    'type': 'object',
+                    'properties': {
+                        'nx': {'type': 'integer', 'minimum': 10, 'maximum': 500},
+                        'nt': {'type': 'integer', 'minimum': 50, 'maximum': 1000},
+                        'length': {'type': 'number', 'minimum': 1, 'maximum': 100},
+                        'time': {'type': 'number', 'minimum': 0.1, 'maximum': 10},
+                        'u_max': {'type': 'number', 'minimum': 0.1, 'maximum': 10},
+                        'rho_max': {'type': 'number', 'minimum': 0.5, 'maximum': 2}
+                    }
+                },
+                'default_parameters': {'nx': 100, 'nt': 200, 'length': 10.0, 'time': 2.0, 'u_max': 1.0, 'rho_max': 1.0}
+            },
+            {
+                'name': 'Phugoid - Trajectoire de Vol',
+                'slug': 'phugoid',
+                'description': 'Trajectoire de vol phugoid (mouvement oscillatoire d\'un planeur) - numerical-mooc.',
+                'theory': '''
+## Phugoid
+
+Mouvement ondulatoire d'un aircraft autour de sa trajectoire de trim.
+
+Paramètres:
+- zt: Hauteur de trim
+- z0: Hauteur initiale  
+- θ0: Angle d'assiette initial
+                '''.strip(),
+                'parameters_schema': {
+                    'type': 'object',
+                    'properties': {
+                        'zt': {'type': 'number', 'minimum': 0.1, 'maximum': 10},
+                        'z0': {'type': 'number', 'minimum': 0.1, 'maximum': 20},
+                        'theta0': {'type': 'number', 'minimum': -45, 'maximum': 45},
+                        'N': {'type': 'integer', 'minimum': 100, 'maximum': 10000}
+                    }
+                },
+                'default_parameters': {'zt': 1.0, 'z0': 2.0, 'theta0': 5.0, 'N': 1000}
+            },
+            {
+                'name': 'Elasticité - DangVan',
+                'slug': 'elasticity-dangvan',
+                'description': 'Calcul du tenseur deviatoire et critères de Tresca/Von Mises (DangVan).',
+                'theory': '''
+## Tenseur Deviatoire
+
+σ deviatorique = σ - (tr(σ)/3) × I
+
+Critères:
+- Tresca: max(σi) - min(σi)
+- Von Mises: √(3/2 × Σ sij²)
+                '''.strip(),
+                'parameters_schema': {
+                    'type': 'object',
+                    'properties': {
+                        'tensor': {'type': 'array', 'items': {'type': 'number'}, 'minItems': 9, 'maxItems': 9}
+                    }
+                },
+                'default_parameters': {'tensor': [100, 0, 0, 0, 50, 0, 0, 0, 30]}
+            },
+            {
+                'name': 'Équation d\'Onde',
+                'slug': 'wave-equation',
+                'description': 'Résolution de l\'équation d\'onde 1D par différences finies.',
+                'theory': '''
+## Équation d'Onde
+
+∂²u/∂t² = c² × ∂²u/∂x²
+
+Schéma explicite centré avec condition CFL: r = c×dt/dx ≤ 1
+                '''.strip(),
+                'parameters_schema': {
+                    'type': 'object',
+                    'properties': {
+                        'length': {'type': 'number', 'minimum': 0.1, 'maximum': 100},
+                        'time': {'type': 'number', 'minimum': 0.1, 'maximum': 10},
+                        'nx': {'type': 'integer', 'minimum': 10, 'maximum': 500},
+                        'nt': {'type': 'integer', 'minimum': 100, 'maximum': 5000},
+                        'wave_speed': {'type': 'number', 'minimum': 0.1, 'maximum': 10}
+                    }
+                },
+                'default_parameters': {'length': 1.0, 'time': 1.0, 'nx': 100, 'nt': 500, 'wave_speed': 1.0}
+            },
+        ]
+        
+        for method_data in methods:
+            method, created = SimulationMethod.objects.update_or_create(
+                slug=method_data['slug'],
+                defaults=method_data
+            )
+            if created:
+                self.stdout.write(self.style.SUCCESS(f'Créé: {method.name}'))
+            else:
+                self.stdout.write(self.style.WARNING(f'Mis à jour: {method.name}'))
+        
+        self.stdout.write(self.style.SUCCESS(f'{len(methods)} méthodes initialisées'))

simulations/migrations/0001_initial.py

@@ -0,0 +1,61 @@
+# Generated by Django 6.0.1 on 2026-01-19 00:16
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='SimulationMethod',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=200)),
+                ('slug', models.SlugField(unique=True)),
+                ('description', models.TextField()),
+                ('theory', models.TextField(blank=True)),
+                ('parameters_schema', models.JSONField(default=dict)),
+                ('default_parameters', models.JSONField(default=dict)),
+                ('is_active', models.BooleanField(default=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+            ],
+            options={
+                'ordering': ['name'],
+            },
+        ),
+        migrations.CreateModel(
+            name='SimulationRun',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(blank=True, max_length=200)),
+                ('parameters', models.JSONField(default=dict)),
+                ('status', models.CharField(choices=[('PENDING', 'En attente'), ('RUNNING', 'En cours'), ('SUCCESS', 'Terminé'), ('FAILURE', 'Échoué'), ('CANCELLED', 'Annulé')], default='PENDING', max_length=20)),
+                ('progress', models.IntegerField(default=0)),
+                ('logs', models.TextField(blank=True)),
+                ('result_data', models.JSONField(blank=True, null=True)),
+                ('error_message', models.TextField(blank=True)),
+                ('input_file', models.FileField(blank=True, null=True, upload_to='simulations/inputs/')),
+                ('output_file', models.FileField(blank=True, null=True, upload_to='simulations/outputs/')),
+                ('plot_file', models.FileField(blank=True, null=True, upload_to='simulations/plots/')),
+                ('pdf_file', models.FileField(blank=True, null=True, upload_to='simulations/reports/')),
+                ('csv_file', models.FileField(blank=True, null=True, upload_to='simulations/csv/')),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('started_at', models.DateTimeField(blank=True, null=True)),
+                ('completed_at', models.DateTimeField(blank=True, null=True)),
+                ('created_by', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to=settings.AUTH_USER_MODEL)),
+                ('method', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='runs', to='simulations.simulationmethod')),
+            ],
+            options={
+                'ordering': ['-created_at'],
+            },
+        ),
+    ]

simulations/models.py

@@ -0,0 +1,515 @@
+import json
+import csv
+import io
+from datetime import datetime
+import numpy as np
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+from django.db import models
+from django.conf import settings
+
+
+class SimulationMethod(models.Model):
+    name = models.CharField(max_length=200)
+    slug = models.SlugField(unique=True)
+    description = models.TextField()
+    theory = models.TextField(blank=True)
+    parameters_schema = models.JSONField(default=dict)
+    default_parameters = models.JSONField(default=dict)
+    is_active = models.BooleanField(default=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        ordering = ['name']
+
+    def __str__(self):
+        return self.name
+
+
+class SimulationRun(models.Model):
+    STATUS_CHOICES = [
+        ('PENDING', 'En attente'),
+        ('RUNNING', 'En cours'),
+        ('SUCCESS', 'Terminé'),
+        ('FAILURE', 'Échoué'),
+        ('CANCELLED', 'Annulé'),
+    ]
+
+    method = models.ForeignKey(
+        SimulationMethod,
+        on_delete=models.CASCADE,
+        related_name='runs'
+    )
+    name = models.CharField(max_length=200, blank=True)
+    parameters = models.JSONField(default=dict)
+    status = models.CharField(
+        max_length=20,
+        choices=STATUS_CHOICES,
+        default='PENDING'
+    )
+    progress = models.IntegerField(default=0)
+    logs = models.TextField(blank=True)
+    result_data = models.JSONField(null=True, blank=True)
+    error_message = models.TextField(blank=True)
+    input_file = models.FileField(
+        upload_to='simulations/inputs/',
+        null=True,
+        blank=True
+    )
+    output_file = models.FileField(
+        upload_to='simulations/outputs/',
+        null=True,
+        blank=True
+    )
+    plot_file = models.FileField(
+        upload_to='simulations/plots/',
+        null=True,
+        blank=True
+    )
+    pdf_file = models.FileField(
+        upload_to='simulations/reports/',
+        null=True,
+        blank=True
+    )
+    csv_file = models.FileField(
+        upload_to='simulations/csv/',
+        null=True,
+        blank=True
+    )
+    created_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True
+    )
+    created_at = models.DateTimeField(auto_now_add=True)
+    started_at = models.DateTimeField(null=True, blank=True)
+    completed_at = models.DateTimeField(null=True, blank=True)
+
+    class Meta:
+        ordering = ['-created_at']
+
+    def __str__(self):
+        return self.name or f"Run #{self.id} - {self.method.name}"
+
+    def add_log(self, message):
+        from django.utils import timezone
+        timestamp = timezone.now().strftime('%Y-%m-%d %H:%M:%S')
+        self.logs += f"[{timestamp}] {message}\n"
+        self.save(update_fields=['logs'])
+
+    def set_running(self):
+        from django.utils import timezone
+        self.status = 'RUNNING'
+        self.started_at = timezone.now()
+        self.save(update_fields=['status', 'started_at'])
+
+    def set_success(self, result_data=None):
+        from django.utils import timezone
+        self.status = 'SUCCESS'
+        self.progress = 100
+        self.completed_at = timezone.now()
+        if result_data:
+            self.result_data = result_data
+        self.save(update_fields=['status', 'progress', 'completed_at', 'result_data'])
+        self.generate_outputs()
+
+    def set_failure(self, error_message):
+        from django.utils import timezone
+        self.status = 'FAILURE'
+        self.completed_at = timezone.now()
+        self.error_message = error_message
+        self.save(update_fields=['status', 'completed_at', 'error_message'])
+
+    def set_pending(self):
+        self.status = 'PENDING'
+        self.progress = 0
+        self.started_at = None
+        self.completed_at = None
+        self.save(update_fields=['status', 'progress', 'started_at', 'completed_at'])
+
+    def generate_plot(self):
+        """Génère un graphique selon la méthode."""
+        if not self.result_data:
+            return None
+        
+        fig, ax = plt.subplots(figsize=(10, 6))
+        
+        method_slug = self.method.slug
+        
+        if method_slug == 'monte-carlo-pi':
+            self._plot_monte_carlo(fig, ax)
+        elif method_slug == 'diffusion-1d':
+            self._plot_diffusion(fig, ax)
+        elif method_slug == 'linear-solve':
+            self._plot_linear(fig, ax)
+        elif method_slug == 'heat-conduction':
+            self._plot_heat_conduction(fig, ax)
+        elif method_slug == 'traffic-flow':
+            self._plot_traffic_flow(fig, ax)
+        elif method_slug == 'phugoid':
+            self._plot_phugoid(fig, ax)
+        elif method_slug == 'elasticity-dangvan':
+            self._plot_elasticity(fig, ax)
+        elif method_slug == 'wave-equation':
+            self._plot_wave_equation(fig, ax)
+        else:
+            ax.text(0.5, 0.5, 'Pas de visualisation disponible',
+                   ha='center', va='center', transform=ax.transAxes)
+        
+        plt.tight_layout()
+        
+        buffer = io.BytesIO()
+        plt.savefig(buffer, format='png', dpi=150)
+        buffer.seek(0)
+        plt.close(fig)
+        
+        return buffer
+
+    def _plot_monte_carlo(self, fig, ax):
+        """Graphique pour Monte Carlo."""
+        data = self.result_data
+        ax.bar(['Estimé', 'Exact'], [data['pi_estimate'], data['exact_pi']], 
+               color=['#3498db', '#27ae60'])
+        ax.set_ylabel('Valeur de Pi')
+        ax.set_title(f"Estimation de Pi - {data['n_points']} points")
+        ax.set_ylim(0, 4)
+        error_pct = abs(data['error']) / data['exact_pi'] * 100
+        ax.text(0.5, 0.9, f"Erreur: {error_pct:.4f}%", 
+               transform=ax.transAxes, ha='center')
+
+    def _plot_diffusion(self, fig, ax):
+        """Graphique pour diffusion 1D."""
+        data = self.result_data
+        final_state = data.get('final_state', [])
+        if final_state:
+            x = np.linspace(0, len(final_state) - 1, len(final_state))
+            ax.plot(x, final_state, 'b-', linewidth=2, label='État final')
+            ax.set_xlabel('Position x')
+            ax.set_ylabel('Concentration u(x,t)')
+            ax.set_title('Profil de diffusion 1D - État final')
+            ax.grid(True, alpha=0.3)
+            ax.legend()
+            ax.fill_between(x, final_state, alpha=0.3)
+        ax.set_xlim(0, len(final_state) if final_state else 100)
+
+    def _plot_linear(self, fig, ax):
+        """Graphique pour résolution linéaire."""
+        data = self.result_data
+        info = f"Taille: {data['size']}\n"
+        info += f"Norme solution: {data['solution_norm']:.4f}\n"
+        info += f"Résidu: {data['residual']:.2e}\n"
+        info += f"Nombre de condition: {data['condition_number']:.2e}"
+        ax.text(0.5, 0.5, info, transform=ax.transAxes, ha='center', va='center',
+               fontsize=12, bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))
+        ax.set_title('Résultats - Résolution système linéaire')
+
+    def _plot_heat_conduction(self, fig, ax):
+        """Graphique pour conduction thermique."""
+        data = self.result_data
+        T_final = np.array(data.get('final_T', []))
+        T_analytical = np.array(data.get('T_analytical', []))
+        N = len(T_final)
+        t = np.arange(N) * data.get('dt', 0.001)
+        
+        ax.plot(t, T_final, 'b-', linewidth=2, label='Numérique')
+        ax.plot(t, T_analytical, 'r--', linewidth=2, label='Analytique')
+        ax.set_xlabel('Temps')
+        ax.set_ylabel('Température')
+        ax.set_title(f"Conduction thermique - θ={data.get('theta', 0.5)}")
+        ax.legend()
+        ax.grid(True, alpha=0.3)
+
+    def _plot_traffic_flow(self, fig, ax):
+        """Graphique pour flux de trafic."""
+        data = self.result_data
+        rho_matrix = np.array(data.get('density_matrix', []))
+        if rho_matrix.size > 0:
+            im = ax.imshow(rho_matrix, aspect='auto', cmap='hot', origin='lower')
+            ax.set_xlabel('Position x')
+            ax.set_ylabel('Temps t')
+            ax.set_title('Densité de trafic')
+            plt.colorbar(im, ax=ax, label='Densité')
+        else:
+            ax.text(0.5, 0.5, 'Pas de données', ha='center', va='center')
+
+    def _plot_phugoid(self, fig, ax):
+        """Graphique pour trajectoire phugoid."""
+        data = self.result_data
+        x = np.array(data.get('x', []))
+        z = np.array(data.get('z', []))
+        if x.size > 0:
+            ax.plot(x, -z, 'b-', linewidth=2)
+            ax.set_xlabel('x')
+            ax.set_ylabel('z')
+            ax.set_title(f"Trajectoire de vol - C={data.get('C', 0):.3f}")
+            ax.grid(True, alpha=0.3)
+            ax.set_aspect('equal')
+
+    def _plot_elasticity(self, fig, ax):
+        """Graphique pour élasticité DangVan."""
+        data = self.result_data
+        tensor = np.array(data.get('tensor_matrix', [])).reshape(3, 3)
+        im = ax.imshow(tensor, cmap='coolwarm', aspect='equal')
+        ax.set_title('Tenseur des contraintes (MPa)')
+        for i in range(3):
+            for j in range(3):
+                ax.text(j, i, f'{tensor[i,j]:.1f}', ha='center', va='center', color='black')
+        plt.colorbar(im, ax=ax)
+
+    def _plot_wave_equation(self, fig, ax):
+        """Graphique pour équation d'onde."""
+        data = self.result_data
+        u = np.array(data.get('displacement_matrix', []))
+        if u.size > 0:
+            im = ax.imshow(u, aspect='auto', cmap='RdBu', origin='lower')
+            ax.set_xlabel('Position x')
+            ax.set_ylabel('Temps t')
+            ax.set_title('Déplacement u(x,t)')
+            plt.colorbar(im, ax=ax, label='u')
+
+    def generate_csv(self):
+        """Génère un fichier CSV des résultats."""
+        if not self.result_data:
+            return None
+        
+        buffer = io.StringIO()
+        writer = csv.writer(buffer)
+        
+        writer.writerow(['Simulation Run Report'])
+        writer.writerow(['ID', self.id])
+        writer.writerow(['Méthode', self.method.name])
+        writer.writerow(['Statut', self.status])
+        writer.writerow(['Créé le', self.created_at])
+        writer.writerow(['Terminé le', self.completed_at])
+        writer.writerow([])
+        
+        writer.writerow(['Paramètres'])
+        for key, value in self.parameters.items():
+            writer.writerow([key, str(value)])
+        writer.writerow([])
+        
+        writer.writerow(['Résultats'])
+        for key, value in self.result_data.items():
+            writer.writerow([key, str(value)])
+        
+        buffer.seek(0)
+        return io.BytesIO(buffer.getvalue().encode('utf-8'))
+
+    def generate_pdf(self):
+        """Génère un rapport PDF avec ReportLab."""
+        from reportlab.lib.pagesizes import A4
+        from reportlab.lib import colors
+        from reportlab.lib.units import inch
+        from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, Image
+        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+        from reportlab.lib.enums import TA_CENTER, TA_LEFT
+        import tempfile
+        
+        buffer = io.BytesIO()
+        doc = SimpleDocTemplate(buffer, pagesize=A4,
+                               leftMargin=0.5*inch, rightMargin=0.5*inch,
+                               topMargin=0.5*inch, bottomMargin=0.5*inch)
+        
+        styles = getSampleStyleSheet()
+        title_style = ParagraphStyle('Title', parent=styles['Heading1'], 
+                                     fontSize=18, spaceAfter=20, alignment=TA_CENTER)
+        heading_style = ParagraphStyle('Heading', parent=styles['Heading2'],
+                                       fontSize=14, spaceAfter=10, color=colors.darkblue)
+        normal_style = styles['Normal']
+        
+        story = []
+        
+        story.append(Paragraph(f"Rapport de Simulation: {self.method.name}", title_style))
+        story.append(Spacer(1, 20))
+        
+        story.append(Paragraph("Informations Générales", heading_style))
+        info_data = [
+            ['ID de la simulation', str(self.id)],
+            ['Méthode', self.method.name],
+            ['Statut', self.status],
+            ['Créé le', str(self.created_at)],
+            ['Terminé le', str(self.completed_at)],
+        ]
+        info_table = Table(info_data, colWidths=[2.5*inch, 3*inch])
+        info_table.setStyle(TableStyle([
+            ('BACKGROUND', (0, 0), (0, -1), colors.lightgrey),
+            ('TEXTCOLOR', (0, 0), (0, -1), colors.black),
+            ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
+            ('PADDING', (0, 0), (-1, -1), 6),
+        ]))
+        story.append(info_table)
+        story.append(Spacer(1, 20))
+        
+        story.append(Paragraph("Paramètres de Simulation", heading_style))
+        params_data = [[str(k), str(v)] for k, v in self.parameters.items()]
+        if params_data:
+            params_table = Table(params_data, colWidths=[2.5*inch, 3*inch])
+            params_table.setStyle(TableStyle([
+                ('BACKGROUND', (0, 0), (0, -1), colors.lightblue),
+                ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
+                ('PADDING', (0, 0), (-1, -1), 6),
+            ]))
+            story.append(params_table)
+        else:
+            story.append(Paragraph("Aucun paramètre personnalisé", normal_style))
+        story.append(Spacer(1, 20))
+        
+        story.append(Paragraph("Résultats", heading_style))
+        results_data = [[str(k), str(v)] for k, v in self.result_data.items()]
+        if results_data:
+            results_table = Table(results_data, colWidths=[2.5*inch, 3*inch])
+            results_table.setStyle(TableStyle([
+                ('BACKGROUND', (0, 0), (0, -1), colors.lightgreen),
+                ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
+                ('PADDING', (0, 0), (-1, -1), 6),
+            ]))
+            story.append(results_table)
+        story.append(Spacer(1, 20))
+        
+        story.append(Paragraph("Graphique", heading_style))
+        import os
+        if self.plot_file and os.path.exists(self.plot_file.path):
+            img = Image(self.plot_file.path, width=5*inch, height=3*inch)
+            img.hAlign = 'CENTER'
+            story.append(img)
+        else:
+            story.append(Paragraph("Graphique non disponible", normal_style))
+        story.append(Spacer(1, 20))
+        
+        if self.logs:
+            story.append(Paragraph("Logs d'Éxecution", heading_style))
+            log_style = ParagraphStyle('Log', parent=styles['Normal'],
+                                       fontSize=8, textColor=colors.darkgrey)
+            for line in self.logs.strip().split('\n')[-50:]:
+                story.append(Paragraph(line, log_style))
+        
+        story.append(Spacer(1, 30))
+        story.append(Paragraph(f"Généré le {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+                              ParagraphStyle('Date', parent=styles['Normal'],
+                                            fontSize=8, alignment=TA_CENTER)))
+        
+        doc.build(story)
+        
+        buffer.seek(0)
+        return buffer
+
+    def generate_outputs(self):
+        """Génère tous les fichiers de sortie."""
+        import os
+        
+        plot_buffer = self.generate_plot()
+        if plot_buffer:
+            filename = f"plot_{self.id}.png"
+            self.plot_file.save(filename, plot_buffer, save=True)
+        
+        csv_buffer = self.generate_csv()
+        if csv_buffer:
+            filename = f"results_{self.id}.csv"
+            self.csv_file.save(filename, csv_buffer, save=True)
+        
+        if self.plot_file:
+            pdf_buffer = self.generate_pdf_with_plot()
+            if pdf_buffer:
+                filename = f"report_{self.id}.pdf"
+                self.pdf_file.save(filename, pdf_buffer, save=True)
+    
+    def generate_pdf_with_plot(self):
+        """Génère un rapport PDF avec le graphique déjà sauvegardé."""
+        from reportlab.lib.pagesizes import A4
+        from reportlab.lib import colors
+        from reportlab.lib.units import inch
+        from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, Image
+        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+        from reportlab.lib.enums import TA_CENTER, TA_LEFT
+        import os
+        
+        if not self.plot_file or not os.path.exists(self.plot_file.path):
+            return None
+        
+        buffer = io.BytesIO()
+        doc = SimpleDocTemplate(buffer, pagesize=A4,
+                               leftMargin=0.5*inch, rightMargin=0.5*inch,
+                               topMargin=0.5*inch, bottomMargin=0.5*inch)
+        
+        styles = getSampleStyleSheet()
+        title_style = ParagraphStyle('Title', parent=styles['Heading1'], 
+                                     fontSize=18, spaceAfter=20, alignment=TA_CENTER)
+        heading_style = ParagraphStyle('Heading', parent=styles['Heading2'],
+                                       fontSize=14, spaceAfter=10, color=colors.darkblue)
+        normal_style = styles['Normal']
+        
+        story = []
+        
+        story.append(Paragraph(f"Rapport de Simulation: {self.method.name}", title_style))
+        story.append(Spacer(1, 20))
+        
+        story.append(Paragraph("Informations Générales", heading_style))
+        info_data = [
+            ['ID de la simulation', str(self.id)],
+            ['Méthode', self.method.name],
+            ['Statut', self.status],
+            ['Créé le', str(self.created_at)],
+            ['Terminé le', str(self.completed_at)],
+        ]
+        info_table = Table(info_data, colWidths=[2.5*inch, 3*inch])
+        info_table.setStyle(TableStyle([
+            ('BACKGROUND', (0, 0), (0, -1), colors.lightgrey),
+            ('TEXTCOLOR', (0, 0), (0, -1), colors.black),
+            ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
+            ('PADDING', (0, 0), (-1, -1), 6),
+        ]))
+        story.append(info_table)
+        story.append(Spacer(1, 20))
+        
+        story.append(Paragraph("Paramètres de Simulation", heading_style))
+        params_data = [[str(k), str(v)] for k, v in self.parameters.items()]
+        if params_data:
+            params_table = Table(params_data, colWidths=[2.5*inch, 3*inch])
+            params_table.setStyle(TableStyle([
+                ('BACKGROUND', (0, 0), (0, -1), colors.lightblue),
+                ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
+                ('PADDING', (0, 0), (-1, -1), 6),
+            ]))
+            story.append(params_table)
+        else:
+            story.append(Paragraph("Aucun paramètre personnalisé", normal_style))
+        story.append(Spacer(1, 20))
+        
+        story.append(Paragraph("Résultats", heading_style))
+        if self.result_data:
+            results_data = [[str(k), str(v)] for k, v in self.result_data.items()]
+            if results_data:
+                results_table = Table(results_data, colWidths=[2.5*inch, 3*inch])
+                results_table.setStyle(TableStyle([
+                    ('BACKGROUND', (0, 0), (0, -1), colors.lightgreen),
+                    ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
+                    ('PADDING', (0, 0), (-1, -1), 6),
+                ]))
+                story.append(results_table)
+        story.append(Spacer(1, 20))
+        
+        story.append(Paragraph("Graphique", heading_style))
+        img = Image(self.plot_file.path, width=5*inch, height=3*inch)
+        img.hAlign = 'CENTER'
+        story.append(img)
+        story.append(Spacer(1, 20))
+        
+        if self.logs:
+            story.append(Paragraph("Logs d'Éxecution", heading_style))
+            log_style = ParagraphStyle('Log', parent=styles['Normal'],
+                                       fontSize=8, textColor=colors.darkgrey)
+            for line in self.logs.strip().split('\n')[-50:]:
+                story.append(Paragraph(line, log_style))
+        
+        story.append(Spacer(1, 30))
+        story.append(Paragraph(f"Généré le {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+                              ParagraphStyle('Date', parent=styles['Normal'],
+                                            fontSize=8, alignment=TA_CENTER)))
+        
+        doc.build(story)
+        
+        buffer.seek(0)
+        return buffer

simulations/registry.py

@@ -0,0 +1,181 @@
+"""
+Système extensible pour les méthodes de simulation numérique.
+
+Pour ajouter une nouvelle méthode :
+1. Créer une fonction dans tasks.py qui retourne un générateur
+2. Ajouter la méthode au SIMULATION_METHODS dict dans tasks.py
+3. Créer un SimulationMethod via l'admin ou init_simulation_methods
+
+Le système gérera automatiquement :
+- L'affichage des résultats
+- La génération des fichiers (PNG, PDF, CSV)
+"""
+
+from simulations.models import SimulationMethod, SimulationRun
+from simulations.tasks import SIMULATION_METHODS
+
+
+def get_method_info(slug):
+    """Récupère les informations sur une méthode de simulation."""
+    try:
+        method = SimulationMethod.objects.get(slug=slug)
+        return {
+            'name': method.name,
+            'slug': method.slug,
+            'description': method.description,
+            'theory': method.theory,
+            'default_parameters': method.default_parameters,
+        }
+    except SimulationMethod.DoesNotExist:
+        return None
+
+
+def get_all_methods():
+    """Liste toutes les méthodes disponibles."""
+    return list(SIMULATION_METHODS.keys())
+
+
+def method_exists(slug):
+    """Vérifie si une méthode existe."""
+    return slug in SIMULATION_METHODS
+
+
+def get_method_description(slug):
+    """Retourne une description lisible pour une méthode."""
+    descriptions = {
+        'monte-carlo-pi': 'Estimation de π par la méthode de Monte Carlo',
+        'diffusion-1d': 'Résolution de l\'équation de diffusion 1D',
+        'linear-solve': 'Résolution de systèmes linéaires Ax = b',
+        'heat-conduction': 'Simulation de conduction thermique',
+        'traffic-flow': 'Modèle de trafic 1D (Lighthill-Whitham-Richards)',
+        'phugoid': 'Trajectoire de vol phugoid (mouvement oscillatoire)',
+        'elasticity-dangvan': 'Calcul du tenseur deviatoire et critères de plasticité',
+        'wave-equation': 'Résolution de l\'équation d\'onde 1D',
+    }
+    return descriptions.get(slug, 'Méthode de simulation numérique')
+
+
+def format_result_value(value):
+    """Formate une valeur de résultat pour l'affichage."""
+    if isinstance(value, (int, float)):
+        if abs(value) < 0.001 or abs(value) > 10000:
+            return f"{value:.2e}"
+        return f"{value:.4f}"
+    elif isinstance(value, list):
+        if len(value) <= 5:
+            return ', '.join(format_result_value(v) for v in value)
+        else:
+            return f"[{len(value)} éléments]"
+    elif isinstance(value, dict):
+        return f"{{ {len(value)} clés }}"
+    return str(value)
+
+
+def get_result_summary(result_data):
+    """Génère un résumé des résultats."""
+    if not result_data:
+        return "Aucun résultat"
+    
+    summary = []
+    for key, value in result_data.items():
+        if key in ['tensor_matrix', 'deviator_tensor', 'displacement_matrix', 
+                  'density_matrix', 'final_T', 'x', 'z']:
+            continue
+        formatted = format_result_value(value)
+        summary.append(f"{key}: {formatted}")
+    
+    return ' | '.join(summary[:5]) if summary else "Résultats disponibles"
+
+
+# Registre des configurations d'affichage par méthode
+DISPLAY_CONFIG = {
+    'monte-carlo-pi': {
+        'icon': '🎲',
+        'title': 'Estimation de Pi',
+        'metrics': ['pi_estimate', 'exact_pi', 'error', 'n_points'],
+    },
+    'diffusion-1d': {
+        'icon': '🌡️',
+        'title': 'Diffusion 1D',
+        'metrics': ['dx', 'dt', 'nx', 'nt', 'max_value'],
+    },
+    'linear-solve': {
+        'icon': '📐',
+        'title': 'Système Linéaire',
+        'metrics': ['size', 'solution_norm', 'residual', 'condition_number'],
+    },
+    'heat-conduction': {
+        'icon': '🔥',
+        'title': 'Conduction Thermique',
+        'metrics': ['T_initial', 'T_surface', 'k', 'theta', 'error_max'],
+    },
+    'traffic-flow': {
+        'icon': '🚗',
+        'title': 'Flux de Trafic',
+        'metrics': ['u_max', 'rho_max', 'max_density', 'avg_density'],
+    },
+    'phugoid': {
+        'icon': '✈️',
+        'title': 'Trajectoire de Vol',
+        'metrics': ['C', 'zt', 'z0', 'theta0', 'theta_final'],
+    },
+    'elasticity-dangvan': {
+        'icon': '⚙️',
+        'title': 'Élasticité',
+        'metrics': ['trace', 'hydrostatic_pressure', 'tresca', 'von_mises'],
+    },
+    'wave-equation': {
+        'icon': '🌊',
+        'title': 'Équation d\'Onde',
+        'metrics': ['wave_speed', 'dx', 'dt', 'CFL', 'max_displacement'],
+    },
+}
+
+
+def get_display_config(slug):
+    """Récupère la configuration d'affichage pour une méthode."""
+    return DISPLAY_CONFIG.get(slug, {
+        'icon': '📊',
+        'title': slug.replace('-', ' ').title(),
+        'metrics': [],
+    })
+
+
+# Import pour éviter les dépendances circulaires
+import json
+
+
+def run_simulation_safe(run_id):
+    """Exécute une simulation de manière sécurisée avec gestion des erreurs."""
+    try:
+        run = SimulationRun.objects.get(pk=run_id)
+        method_func = SIMULATION_METHODS.get(run.method.slug)
+        
+        if not method_func:
+            raise ValueError(f"Méthode inconnue: {run.method.slug}")
+        
+        gen = method_func(run.parameters)
+        result = None
+        
+        try:
+            while True:
+                progress = next(gen)
+                run.progress = progress
+                run.save(update_fields=['progress'])
+        except StopIteration as e:
+            result = e.value
+        
+        if result is None:
+            result = {}
+        
+        # Nettoyer les valeurs NaN/Inf
+        from simulations.tasks import clean_for_json
+        result = clean_for_json(result)
+        
+        run.set_success(result)
+        return {'success': True, 'run_id': run_id}
+        
+    except Exception as e:
+        if 'run' in locals():
+            run.set_failure(str(e))
+        return {'success': False, 'error': str(e), 'run_id': run_id}

simulations/serializers.py

@@ -0,0 +1,57 @@
+from rest_framework import serializers
+from .models import SimulationMethod, SimulationRun
+
+
+class SimulationMethodSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = SimulationMethod
+        fields = [
+            'id', 'name', 'slug', 'description', 'theory',
+            'parameters_schema', 'default_parameters',
+            'is_active', 'created_at', 'updated_at'
+        ]
+        read_only_fields = ['id', 'created_at', 'updated_at']
+
+
+class SimulationRunSerializer(serializers.ModelSerializer):
+    method_name = serializers.CharField(source='method.name', read_only=True)
+    method_slug = serializers.CharField(source='method.slug', read_only=True)
+    
+    class Meta:
+        model = SimulationRun
+        fields = [
+            'id', 'method', 'method_name', 'method_slug',
+            'name', 'parameters', 'status', 'progress',
+            'logs', 'result_data', 'error_message',
+            'input_file', 'output_file', 'created_at',
+            'started_at', 'completed_at'
+        ]
+        read_only_fields = [
+            'id', 'status', 'progress', 'logs',
+            'result_data', 'error_message', 'output_file',
+            'created_at', 'started_at', 'completed_at'
+        ]
+
+
+class SimulationRunCreateSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = SimulationRun
+        fields = ['method', 'name', 'parameters', 'input_file']
+    
+    def validate_parameters(self, value):
+        method = self.initial_data.get('method')
+        if method:
+            try:
+                sim_method = SimulationMethod.objects.get(pk=method)
+                schema = sim_method.parameters_schema
+            except SimulationMethod.DoesNotExist:
+                pass
+        return value
+
+
+class SimulationRunDetailSerializer(serializers.ModelSerializer):
+    method = SimulationMethodSerializer(read_only=True)
+    
+    class Meta:
+        model = SimulationRun
+        fields = '__all__'

simulations/tasks.py

@@ -0,0 +1,418 @@
+import time
+import random
+import math
+from celery import shared_task
+import json
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def clean_for_json(obj):
+    """Convertit les objets numpy en types Python valides pour JSON."""
+    if isinstance(obj, np.ndarray):
+        return [clean_for_json(x) for x in obj.tolist()]
+    elif isinstance(obj, (np.integer,)):
+        return int(obj)
+    elif isinstance(obj, (np.floating,)):
+        val = float(obj)
+        if math.isnan(val) or math.isinf(val):
+            return 0.0
+        return val
+    elif isinstance(obj, dict):
+        return {k: clean_for_json(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [clean_for_json(x) for x in obj]
+    elif isinstance(obj, (int, float, str, bool, type(None))):
+        return obj
+    else:
+        return obj
+
+
+def run_monte_carlo_simulation(params):
+    """Simulation Monte Carlo pour estimation de Pi."""
+    n_points = params.get('n_points', 10000)
+    seed = params.get('seed', 42)
+    
+    random.seed(seed)
+    inside_circle = 0
+    
+    for i in range(n_points):
+        x = random.random()
+        y = random.random()
+        if x*x + y*y <= 1:
+            inside_circle += 1
+        if (i + 1) % (n_points // 10) == 0:
+            progress = int((i + 1) / n_points * 100)
+            yield progress
+    
+    pi_estimate = 4 * inside_circle / n_points
+    return {
+        'pi_estimate': clean_for_json(pi_estimate),
+        'exact_pi': math.pi,
+        'error': clean_for_json(abs(pi_estimate - math.pi)),
+        'n_points': n_points,
+        'inside_circle': inside_circle
+    }
+
+
+def run_diffusion_1d_simulation(params):
+    """Simulation de diffusion 1D explicite."""
+    L = params.get('length', 1.0)
+    T = params.get('time', 0.1)
+    nx = params.get('nx', 50)
+    nt = params.get('nt', 100)
+    D = params.get('diffusion_coef', 1.0)
+    
+    dx = L / (nx - 1)
+    dt = T / nt
+    
+    u = [0.0] * nx
+    u[0] = 1.0
+    u[-1] = 0.0
+    
+    for j in range(nt):
+        u_old = u.copy()
+        for i in range(1, nx - 1):
+            u[i] = u_old[i] + D * dt / (dx * dx) * (
+                u_old[i+1] - 2*u_old[i] + u_old[i-1]
+            )
+        if (j + 1) % (nt // 10) == 0:
+            progress = int((j + 1) / nt * 100)
+            yield progress
+    
+    return {
+        'final_state': clean_for_json(u),
+        'dx': clean_for_json(dx),
+        'dt': clean_for_json(dt),
+        'nx': nx,
+        'nt': nt,
+        'max_value': clean_for_json(max(u)),
+        'min_value': clean_for_json(min(u))
+    }
+
+
+def run_linear_solve_simulation(params):
+    """Résolution de système linéaire Ax = b."""
+    size = params.get('size', 100)
+    
+    np.random.seed(params.get('seed', 42))
+    
+    A = np.random.rand(size, size) + size * np.eye(size)
+    b = np.random.rand(size)
+    
+    for i in range(5):
+        time.sleep(0.5)
+        yield (i + 1) * 20
+    
+    x = np.linalg.solve(A, b)
+    residual = np.linalg.norm(A.dot(x) - b)
+    
+    return {
+        'solution_norm': clean_for_json(np.linalg.norm(x)),
+        'residual': clean_for_json(residual),
+        'condition_number': clean_for_json(np.linalg.cond(A)),
+        'size': size
+    }
+
+
+def run_heat_conduction_simulation(params):
+    """Simulation de conduction thermique Newton (finite_difference)."""
+    T_0 = params.get('T_initial', 100.0)
+    T_s = params.get('T_surface', 20.0)
+    k = params.get('conductivity', 0.1)
+    dt = params.get('dt', 0.001)
+    N = params.get('N', 1000)
+    theta = params.get('theta', 0.5)
+    
+    T = np.zeros(N)
+    T[0] = T_0
+    
+    for i in range(1, N):
+        T[i] = (1 - (1 - theta) * dt * k) * T[i-1] / (1 + theta * dt * k) - k * dt * T_s / (1 + theta * dt * k)
+        if (i + 1) % (N // 10) == 0:
+            progress = int((i + 1) / N * 100)
+            yield progress
+    
+    T_analytical = (T_0 - T_s) * np.exp(-k * np.arange(N) * dt) + T_s
+    error = np.max(np.abs(T - T_analytical))
+    
+    return {
+        'final_T': clean_for_json(T.tolist()),
+        'T_analytical': clean_for_json(T_analytical.tolist()),
+        'error_max': clean_for_json(error),
+        'T_initial': T_0,
+        'T_surface': T_s,
+        'k': k,
+        'dt': dt,
+        'theta': theta,
+        'N': N,
+        'time_final': clean_for_json(N * dt)
+    }
+
+
+def run_traffic_flow_simulation(params):
+    """Modèle de trafic 1D (numerical-mooc)."""
+    nx = params.get('nx', 100)
+    nt = params.get('nt', 200)
+    L = params.get('length', 10.0)
+    T = params.get('time', 2.0)
+    u_max = params.get('u_max', 1.0)
+    rho_max = params.get('rho_max', 1.0)
+    
+    dx = L / nx
+    dt = T / nt
+    
+    x = np.linspace(0, L, nx)
+    t = np.linspace(0, T, nt)
+    
+    rho = np.zeros((nt, nx))
+    rho[0] = rho_red_light(x, rho_max)
+    
+    for n in range(nt - 1):
+        for i in range(nx):
+            F_ip = flux(rho[n, (i+1) % nx], u_max, rho_max)
+            F_i = flux(rho[n, i], u_max, rho_max)
+            rho[n+1, i] = rho[n, i] + dt / dx * (F_i - F_ip)
+        
+        if (n + 1) % (nt // 10) == 0:
+            progress = int((n + 1) / nt * 100)
+            yield progress
+    
+    return {
+        'density_matrix': clean_for_json(rho.tolist()),
+        'x_grid': clean_for_json(x.tolist()),
+        't_grid': clean_for_json(t.tolist()),
+        'u_max': u_max,
+        'rho_max': rho_max,
+        'max_density': clean_for_json(float(np.max(rho))),
+        'avg_density': clean_for_json(float(np.mean(rho)))
+    }
+
+
+def rho_red_light(x, rho_max):
+    """Condition initiale 'red light' avec choc."""
+    rho = rho_max * np.ones_like(x)
+    mask = np.where(x < 3.0)
+    rho[mask] = 0.5 * rho_max
+    return rho
+
+
+def flux(rho, u_max, rho_max):
+    """Flux de trafic F = V * rho."""
+    return rho * u_max * (1.0 - rho / rho_max)
+
+
+def run_phugoid_simulation(params):
+    """Trajectoire de vol phugoid (numerical-mooc)."""
+    zt = params.get('zt', 1.0)
+    z0 = params.get('z0', 2.0)
+    theta0 = params.get('theta0', 5.0)
+    N = params.get('N', 1000)
+    
+    theta0_rad = np.radians(theta0)
+    
+    if z0 <= 0:
+        z0 = 0.1
+    
+    try:
+        C = (np.cos(theta0_rad) - 1/3 * z0 / zt) * (z0 / zt)**0.5
+    except (ZeroDivisionError, RuntimeWarning):
+        C = 0.0
+    
+    x = np.zeros(N)
+    z = np.zeros(N)
+    theta = theta0_rad
+    
+    for i in range(1, N):
+        try:
+            normal = np.array([+ np.cos(theta + np.pi/2.0), - np.sin(theta + np.pi/2.0)])
+            R = radius_of_curvature(z[i-1], zt, C)
+            if abs(R) < 0.001:
+                R = 0.001
+            center = np.array([x[i-1], z[i-1]]) + R * normal
+            ds = 1.0
+            dtheta = ds / R
+            x[i], z[i] = rotate((x[i-1], z[i-1]), center=center, angle=dtheta, mode='radians')
+            theta += dtheta
+        except (RuntimeWarning, FloatingPointError):
+            break
+        
+        if i % (N // 10) == 0:
+            yield int(i / N * 100)
+    
+    return {
+        'x': clean_for_json(x.tolist()),
+        'z': clean_for_json(z.tolist()),
+        'theta_final': clean_for_json(float(np.degrees(theta))),
+        'C': clean_for_json(float(C)),
+        'zt': zt,
+        'z0': z0,
+        'theta0': theta0
+    }
+
+
+def radius_of_curvature(z, zt, C):
+    """Rayon de courbure de la trajectoire."""
+    if z <= 0 or abs(1/3 - C / 2 * (zt / z)**1.5) < 1e-10:
+        return zt * 1000
+    return zt / (1 / 3 - C / 2 * (zt / z)**1.5)
+
+
+def rotate(coords, center=(0.0, 0.0), angle=0.0, mode='degrees'):
+    """Rotation d'un point autour d'un centre."""
+    x, z = coords
+    xc, zc = center
+    if mode == 'degrees':
+        angle = np.radians(angle)
+    x_new = xc + (x - xc) * np.cos(angle) + (z - zc) * np.sin(angle)
+    z_new = zc - (x - xc) * np.sin(angle) + (z - zc) * np.cos(angle)
+    return x_new, z_new
+
+
+def run_elasticity_dangvan_simulation(params):
+    """Tenseur deviatoire et critère de Tresca (DangVan)."""
+    tensor_input = params.get('tensor', [100, 0, 0, 0, 50, 0, 0, 0, 30])
+    sigma = np.array(tensor_input).reshape(3, 3)
+    trace = np.trace(sigma)
+    hydrostatic = (trace / 3) * np.eye(3)
+    deviator = sigma - hydrostatic
+    eigenvals = np.linalg.eigvals(sigma)
+    
+    yield 30
+    
+    tresca = np.max(eigenvals) - np.min(eigenvals)
+    von_mises = np.sqrt(3/2 * np.sum(deviator**2))
+    
+    yield 60
+    
+    yield 100
+    
+    return {
+        'tensor_matrix': clean_for_json(sigma.tolist()),
+        'deviator_tensor': clean_for_json(deviator.tolist()),
+        'principal_stresses': clean_for_json(eigenvals.tolist()),
+        'trace': clean_for_json(float(trace)),
+        'hydrostatic_pressure': clean_for_json(float(trace / 3)),
+        'tresca': clean_for_json(float(tresca)),
+        'von_mises': clean_for_json(float(von_mises))
+    }
+
+
+def run_wave_equation_simulation(params):
+    """Résolution de l'équation d'onde 1D."""
+    L = params.get('length', 1.0)
+    T = params.get('time', 1.0)
+    nx = params.get('nx', 100)
+    nt = params.get('nt', 500)
+    c = params.get('wave_speed', 1.0)
+    
+    dx = L / nx
+    dt = T / nt
+    r = c * dt / dx
+    
+    if r > 1.0:
+        r = 0.9
+    
+    x = np.linspace(0, L, nx)
+    t = np.linspace(0, T, nt)
+    
+    u = np.zeros((nt, nx))
+    u[0] = np.sin(np.pi * x / L)
+    u[1] = 0.5 * u[0].copy()
+    
+    for n in range(1, nt - 1):
+        for i in range(1, nx - 1):
+            u[n+1, i] = 2*(1 - r**2) * u[n, i] - u[n-1, i] + r**2 * (u[n, i+1] + u[n, i-1])
+        u[n+1, 0] = 0
+        u[n+1, -1] = 0
+        
+        if (n + 1) % (nt // 10) == 0:
+            progress = int((n + 1) / nt * 100)
+            yield progress
+    
+    max_displacement = clean_for_json(float(np.max(np.abs(u))))
+    
+    return {
+        'displacement_matrix': clean_for_json(u.tolist()),
+        'x_grid': clean_for_json(x.tolist()),
+        't_grid': clean_for_json(t.tolist()),
+        'wave_speed': c,
+        'dx': clean_for_json(dx),
+        'dt': clean_for_json(dt),
+        'CFL': clean_for_json(r),
+        'max_displacement': max_displacement
+    }
+
+
+SIMULATION_METHODS = {
+    'monte-carlo-pi': run_monte_carlo_simulation,
+    'diffusion-1d': run_diffusion_1d_simulation,
+    'linear-solve': run_linear_solve_simulation,
+    'heat-conduction': run_heat_conduction_simulation,
+    'traffic-flow': run_traffic_flow_simulation,
+    'phugoid': run_phugoid_simulation,
+    'elasticity-dangvan': run_elasticity_dangvan_simulation,
+    'wave-equation': run_wave_equation_simulation,
+}
+
+
+@shared_task(bind=True)
+def run_simulation(self, run_id):
+    """Tâche Celery pour exécuter une simulation."""
+    from simulations.models import SimulationRun
+    
+    try:
+        run = SimulationRun.objects.get(pk=run_id)
+        run.set_running()
+        run.add_log(f"Début de la simulation {run_id}")
+        run.add_log(f"Paramètres: {json.dumps(run.parameters)}")
+        
+        method_func = SIMULATION_METHODS.get(run.method.slug)
+        
+        if not method_func:
+            raise ValueError(f"Méthode inconnue: {run.method.slug}")
+        
+        gen = method_func(run.parameters)
+        result = None
+        
+        try:
+            while True:
+                progress = next(gen)
+                run.progress = progress
+                run.save(update_fields=['progress'])
+        except StopIteration as e:
+            result = e.value
+        
+        if result is None:
+            result = {}
+        
+        result = clean_for_json(result)
+        
+        run.set_success(result)
+        run.add_log(f"Simulation terminée avec succès")
+        run.add_log(f"Résultat: {json.dumps(result)}")
+        
+    except Exception as e:
+        if 'run' in locals():
+            run.set_failure(str(e))
+            run.add_log(f"Erreur: {str(e)}")
+        raise
+
+
+@shared_task
+def cleanup_old_runs(days=7):
+    """Nettoie les simulations anciennes."""
+    from simulations.models import SimulationRun
+    from django.utils import timezone
+    from datetime import timedelta
+    
+    cutoff = timezone.now() - timedelta(days=days)
+    old_runs = SimulationRun.objects.filter(
+        created_at__lt=cutoff,
+        status__in=['SUCCESS', 'FAILURE', 'CANCELLED']
+    )
+    
+    count = old_runs.count()
+    old_runs.delete()
+    
+    return f"Supprimé {count} simulations anciennes"

simulations/templates/simulations/base.html

@@ -0,0 +1,78 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{% block title %}Simulations Numériques{% endblock %}</title>
+    <style>
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; line-height: 1.6; background: #f5f5f5; }
+        header { background: #2c3e50; color: white; padding: 1rem 2rem; }
+        nav a { color: white; text-decoration: none; margin-right: 1.5rem; }
+        nav a:hover { text-decoration: underline; }
+        main { max-width: 1200px; margin: 0 auto; padding: 2rem; }
+        .card { background: white; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); padding: 1.5rem; margin-bottom: 1.5rem; }
+        .btn { display: inline-block; padding: 0.5rem 1rem; background: #3498db; color: white; text-decoration: none; border-radius: 4px; border: none; cursor: pointer; }
+        .btn:hover { background: #2980b9; }
+        .btn-secondary { background: #95a5a6; }
+        .btn-danger { background: #e74c3c; }
+        .btn-success { background: #27ae60; }
+        .status-pending { color: #f39c12; }
+        .status-running { color: #3498db; }
+        .status-success { color: #27ae60; }
+        .status-failure { color: #e74c3c; }
+        .status-cancelled { color: #95a5a6; }
+        table { width: 100%; border-collapse: collapse; }
+        th, td { padding: 0.75rem; text-align: left; border-bottom: 1px solid #eee; }
+        .progress-bar { background: #ecf0f1; border-radius: 4px; height: 20px; overflow: hidden; }
+        .progress-fill { background: #27ae60; height: 100%; transition: width 0.3s; }
+        .logs { background: #2c3e50; color: #ecf0f1; padding: 1rem; border-radius: 4px; font-family: monospace; white-space: pre-wrap; max-height: 300px; overflow-y: auto; }
+        .grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 1.5rem; }
+        .method-card { transition: transform 0.2s; }
+        .method-card:hover { transform: translateY(-2px); }
+        .flash-messages { margin-bottom: 1rem; }
+        .flash { padding: 1rem; border-radius: 4px; margin-bottom: 0.5rem; }
+        .flash-success { background: #d4edda; color: #155724; }
+        .flash-error { background: #f8d7da; color: #721c24; }
+    </style>
+</head>
+<body>
+    <header>
+        <nav>
+            <a href="{% url 'home' %}">Accueil</a>
+            <a href="{% url 'method_list' %}">Méthodes</a>
+            <a href="{% url 'run_create' %}">Nouvelle Simulation</a>
+            <a href="{% url 'run_list' %}">Historique</a>
+        </nav>
+    </header>
+    <main>
+        {% if messages %}
+        <div class="flash-messages">
+            {% for message in messages %}
+            <div class="flash flash-{{ message.tags }}">{{ message }}</div>
+            {% endfor %}
+        </div>
+        {% endif %}
+        {% block content %}{% endblock %}
+    </main>
+    <script>
+        function pollStatus(runId) {
+            fetch(`/run/${runId}/status/`)
+                .then(r => r.json())
+                .then(data => {
+                    document.getElementById('status').textContent = data.status;
+                    document.getElementById('progress').textContent = data.progress + '%';
+                    document.getElementById('progress-fill').style.width = data.progress + '%';
+                    if (data.status === 'RUNNING') {
+                        setTimeout(() => pollStatus(runId), 1000);
+                    } else {
+                        location.reload();
+                    }
+                });
+        }
+        {% if run and run.status == 'RUNNING' %}
+        pollStatus({{ run.id }});
+        {% endif %}
+    </script>
+</body>
+</html>

simulations/templates/simulations/home.html

@@ -0,0 +1,56 @@
+{% extends 'simulations/base.html' %}
+{% block title %}Accueil - Simulations Numériques{% endblock %}
+{% block content %}
+<h1>Simulations Numériques</h1>
+<p>Plateforme d'exécution de méthodes de simulation numérique avec traitement asynchrone.</p>
+
+<div class="grid">
+    {% for method in methods %}
+    <div class="card method-card">
+        <h3>{{ method.name }}</h3>
+        <p>{{ method.description|truncatewords:20 }}</p>
+        <a href="{% url 'method_detail' method.slug %}" class="btn">Voir la méthode</a>
+        <a href="{% url 'run_create_method' method.slug %}" class="btn btn-success">Lancer</a>
+    </div>
+    {% empty %}
+    <p>Aucune méthode disponible.</p>
+    {% endfor %}
+</div>
+
+{% if recent_runs %}
+<h2>Simulations récentes</h2>
+<table>
+    <thead>
+        <tr>
+            <th>ID</th>
+            <th>Méthode</th>
+            <th>Statut</th>
+            <th>Progrès</th>
+            <th>Créé</th>
+        </tr>
+    </thead>
+    <tbody>
+        {% for run in recent_runs %}
+        <tr>
+            <td><a href="{% url 'run_detail' run.id %}">#{{ run.id }}</a></td>
+            <td>{{ run.method.name }}</td>
+            <td class="status-{{ run.status|lower }}">{{ run.get_status_display }}</td>
+            <td>{{ run.progress }}%</td>
+            <td>{{ run.created_at|date:"d/m/Y H:i" }}</td>
+        </tr>
+        {% endfor %}
+    </tbody>
+</table>
+{% endif %}
+
+<div class="card">
+    <h2>Démarrage rapide</h2>
+    <ol>
+        <li>Choisissez une méthode de simulation</li>
+        <li>Configurez les paramètres</li>
+        <li>Lancez la simulation</li>
+        <li>Consultez les résultats</li>
+    </ol>
+    <a href="{% url 'run_create' %}" class="btn btn-success">Créer une simulation</a>
+</div>
+{% endblock %}

simulations/templates/simulations/method_detail.html

@@ -0,0 +1,24 @@
+{% extends 'simulations/base.html' %}
+{% load simulation_extras %}
+{% block title %}{{ method.name }}{% endblock %}
+{% block content %}
+<h1>{{ method.name }}</h1>
+<div class="card">
+    <h2>Description</h2>
+    <p>{{ method.description }}</p>
+</div>
+
+{% if method.theory %}
+<div class="card">
+    <h2>Théorie</h2>
+    <div>{{ method.theory|linebreaks }}</div>
+</div>
+{% endif %}
+
+<div class="card">
+    <h2>Paramètres par défaut</h2>
+    <pre>{{ method.default_parameters|json_format }}</pre>
+</div>
+
+<a href="{% url 'run_create_method' method.slug %}" class="btn btn-success">Lancer une simulation</a>
+{% endblock %}

simulations/templates/simulations/method_list.html

@@ -0,0 +1,17 @@
+{% extends 'simulations/base.html' %}
+{% block title %}Méthodes de Simulation{% endblock %}
+{% block content %}
+<h1>Méthodes de Simulation</h1>
+<div class="grid">
+    {% for method in methods %}
+    <div class="card method-card">
+        <h3>{{ method.name }}</h3>
+        <p>{{ method.description }}</p>
+        <a href="{% url 'method_detail' method.slug %}" class="btn">En savoir plus</a>
+        <a href="{% url 'run_create_method' method.slug %}" class="btn btn-success">Lancer</a>
+    </div>
+    {% empty %}
+    <p>Aucune méthode disponible.</p>
+    {% endfor %}
+</div>
+{% endblock %}

simulations/templates/simulations/run_create.html

@@ -0,0 +1,57 @@
+{% extends 'simulations/base.html' %}
+{% load simulation_extras %}
+{% block title %}Nouvelle Simulation{% endblock %}
+{% block content %}
+<h1>Nouvelle Simulation</h1>
+<form method="post" enctype="multipart/form-data" class="card">
+    {% csrf_token %}
+    <div>
+        <label for="method">Méthode:</label>
+        <select name="method" id="method" required onchange="updateParams()">
+            <option value="">Sélectionnez une méthode</option>
+            {% for method in methods %}
+            <option value="{{ method.id }}" {% if selected_method and selected_method.id == method.id %}selected{% endif %}>
+                {{ method.name }}
+            </option>
+            {% endfor %}
+        </select>
+    </div>
+    <div>
+        <label for="name">Nom (optionnel):</label>
+        <input type="text" name="name" id="name" placeholder="Ma simulation">
+    </div>
+    <div>
+        <label for="parameters">Paramètres (JSON):</label>
+        <textarea name="parameters" id="parameters" rows="10" placeholder='{"n_points": 10000}'>{}</textarea>
+    </div>
+    <div>
+        <label for="input_file">Fichier d'entrée (optionnel):</label>
+        <input type="file" name="input_file" id="input_file">
+    </div>
+    <button type="submit" class="btn btn-success">Lancer la simulation</button>
+</form>
+
+<script>
+const methods = {
+{% for method in methods %}
+    {{ method.id }}: {
+        name: "{{ method.name }}",
+        default_params: {{ method.default_parameters|json_format }}
+    }{% if not forloop.last %},{% endif %}
+{% endfor %}
+};
+
+function updateParams() {
+    const methodId = document.getElementById('method').value;
+    if (methodId && methods[methodId]) {
+        document.getElementById('parameters').value = JSON.stringify(
+            methods[methodId].default_params, null, 2
+        );
+    }
+}
+
+{% if selected_method %}
+updateParams();
+{% endif %}
+</script>
+{% endblock %}

simulations/templates/simulations/run_detail.html

@@ -0,0 +1,193 @@
+{% extends 'simulations/base.html' %}
+{% load simulation_extras %}
+{% block title %}Simulation #{{ run.id }}{% endblock %}
+{% block content %}
+<h1>Simulation #{{ run.id }}</h1>
+
+<div class="card">
+    <h2>Informations</h2>
+    <table>
+        <tr><th>Méthode:</th><td>{{ run.method.name }}</td></tr>
+        <tr><th>Slug:</th><td><code>{{ run.method.slug }}</code></td></tr>
+        <tr><th>Statut:</th><td class="status-{{ run.status|lower }}" id="status">{{ run.get_status_display }}</td></tr>
+        <tr><th>Progrès:</th><td><span id="progress">{{ run.progress }}</span>%</td></tr>
+        <tr><th>Créé le:</th><td>{{ run.created_at|date:"d/m/Y H:i:s" }}</td></tr>
+        <tr><th>Terminé le:</th><td>{{ run.completed_at|date:"d/m/Y H:i:s"|default:"-" }}</td></tr>
+    </table>
+    
+    <div class="progress-bar" style="margin-top: 1rem;">
+        <div class="progress-fill" id="progress-fill" style="width: {{ run.progress }}%; transition: width 0.5s;"></div>
+    </div>
+    
+    <div id="loading-indicator" style="display: none; margin-top: 1rem; text-align: center;">
+        <p>⏳ Simulation en cours... La page se rafraîchira automatiquement.</p>
+    </div>
+</div>
+
+<div class="card">
+    <h2>Paramètres</h2>
+    {% if run.parameters %}
+    <table style="width: 100%;">
+        <thead><tr><th>Paramètre</th><th>Valeur</th></tr></thead>
+        <tbody>
+        {% for key, value in run.parameters.items %}
+        <tr><td>{{ key }}</td><td>{{ value }}</td></tr>
+        {% endfor %}
+        </tbody>
+    </table>
+    {% else %}
+    <p>Aucun paramètre personnalisé</p>
+    {% endif %}
+</div>
+
+{% if run.error_message %}
+<div class="card" id="error-section" style="display: none;">
+    <h2>Erreur</h2>
+    <p style="color: #e74c3c;" id="error-message">{{ run.error_message }}</p>
+</div>
+{% endif %}
+
+{% if run.result_data %}
+<div class="card" id="results-section">
+    <h2>Résultats</h2>
+    
+    {# Tableau générique pour tous les résultats #}
+    <table style="width: 100%;">
+        <thead><tr><th>Paramètre</th><th>Valeur</th></tr></thead>
+        <tbody>
+        {% for key, value in run.result_data.items %}
+        <tr>
+            <td>{{ key }}</td>
+            <td>
+                {% if value|is_list %}
+                <table style="width: 100%; font-size: 0.9em;">
+                    {% for item in value %}
+                    <tr><td>{{ item }}</td></tr>
+                    {% endfor %}
+                </table>
+                {% elif value|is_dict %}
+                <pre>{{ value|json_format }}</pre>
+                {% elif key|contains:"matrix" or key|contains:"grid" or key|contains:"state" %}
+                <span style="color: #7f8c8d;">[Tableau {{ value|length }} éléments]</span>
+                {% else %}
+                {{ value|sigfig:2 }}
+                {% endif %}
+            </td>
+        </tr>
+        {% endfor %}
+        </tbody>
+    </table>
+</div>
+{% endif %}
+
+{% if run.plot_file %}
+<div class="card">
+    <h2>Graphique</h2>
+    <img src="{{ run.plot_file.url }}" alt="Graphique de la simulation" style="max-width: 100%; height: auto; border: 1px solid #ddd; border-radius: 4px;">
+</div>
+{% endif %}
+
+{% if run.pdf_file or run.csv_file or run.plot_file %}
+<div class="card">
+    <h2>Téléchargements</h2>
+    <div style="display: flex; gap: 1rem; flex-wrap: wrap;">
+        {% if run.pdf_file %}
+        <a href="{{ run.pdf_file.url }}" class="btn btn-secondary" download>📄 Rapport PDF</a>
+        {% endif %}
+        {% if run.csv_file %}
+        <a href="{{ run.csv_file.url }}" class="btn btn-secondary" download>📊 Résultats CSV</a>
+        {% endif %}
+        {% if run.plot_file %}
+        <a href="{{ run.plot_file.url }}" class="btn btn-secondary" download>📈 Graphique PNG</a>
+        {% endif %}
+    </div>
+</div>
+{% endif %}
+
+{% if run.logs %}
+<div class="card">
+    <h2>Logs d'exécution</h2>
+    <div class="logs">{{ run.logs }}</div>
+</div>
+{% endif %}
+
+<div class="card">
+    <h2>Actions</h2>
+    {% if run.status == 'PENDING' or run.status == 'RUNNING' %}
+    <a href="{% url 'run_cancel' run.id %}" class="btn btn-danger">Annuler</a>
+    {% endif %}
+    {% if run.status == 'FAILURE' or run.status == 'CANCELLED' %}
+    <a href="{% url 'run_retry' run.id %}" class="btn btn-success">Réessayer</a>
+    {% endif %}
+    <a href="{% url 'run_list' %}" class="btn btn-secondary">Retour à la liste</a>
+</div>
+
+<script>
+const runId = {{ run.id }};
+const runStatus = "{{ run.status }}";
+
+function updateStatus() {
+    fetch(`/run/${runId}/status/`)
+        .then(response => response.json())
+        .then(data => {
+            document.getElementById('status').textContent = getStatusText(data.status);
+            document.getElementById('status').className = `status-${data.status.toLowerCase()}`;
+            document.getElementById('progress').textContent = data.progress;
+            document.getElementById('progress-fill').style.width = `${data.progress}%`;
+            
+            const resultsSection = document.getElementById('results-section');
+            const errorSection = document.getElementById('error-section');
+            const loadingIndicator = document.getElementById('loading-indicator');
+            
+            if (data.status === 'RUNNING') {
+                loadingIndicator.style.display = 'block';
+                resultsSection.style.display = 'none';
+                errorSection.style.display = 'none';
+                setTimeout(updateStatus, 1000);
+            } else if (data.status === 'PENDING') {
+                loadingIndicator.style.display = 'block';
+                setTimeout(updateStatus, 1000);
+            } else if (data.status === 'SUCCESS') {
+                loadingIndicator.style.display = 'none';
+                resultsSection.style.display = 'block';
+                errorSection.style.display = 'none';
+                document.getElementById('status').textContent = 'Terminé';
+                location.reload();
+            } else if (data.status === 'FAILURE') {
+                loadingIndicator.style.display = 'none';
+                resultsSection.style.display = 'none';
+                errorSection.style.display = 'block';
+                document.getElementById('error-message').textContent = data.error_message || 'Erreur inconnue';
+                document.getElementById('status').textContent = 'Échoué';
+            } else if (data.status === 'CANCELLED') {
+                loadingIndicator.style.display = 'none';
+                document.getElementById('status').textContent = 'Annulé';
+            }
+        })
+        .catch(error => {
+            console.error('Erreur:', error);
+            setTimeout(updateStatus, 2000);
+        });
+}
+
+function getStatusText(status) {
+    const statusMap = {
+        'PENDING': 'En attente',
+        'RUNNING': 'En cours',
+        'SUCCESS': 'Terminé',
+        'FAILURE': 'Échoué',
+        'CANCELLED': 'Annulé'
+    };
+    return statusMap[status] || status;
+}
+
+if (runStatus === 'PENDING' || runStatus === 'RUNNING') {
+    updateStatus();
+} else if (runStatus === 'SUCCESS') {
+    document.getElementById('results-section').style.display = 'block';
+} else if (runStatus === 'FAILURE') {
+    document.getElementById('error-section').style.display = 'block';
+    document.getElementById('error-message').textContent = "{{ run.error_message|escapejs }}";
+}
+</script>
+{% endblock %}

simulations/templates/simulations/run_list.html

@@ -0,0 +1,52 @@
+{% extends 'simulations/base.html' %}
+{% block title %}Historique des Simulations{% endblock %}
+{% block content %}
+<h1>Historique des Simulations</h1>
+
+<div class="card">
+    <form method="get" style="display: flex; gap: 1rem; align-items: center;">
+        <label for="status">Filtrer par statut:</label>
+        <select name="status" id="status" onchange="this.form.submit()">
+            <option value="">Tous</option>
+            <option value="PENDING" {% if status_filter == 'PENDING' %}selected{% endif %}>En attente</option>
+            <option value="RUNNING" {% if status_filter == 'RUNNING' %}selected{% endif %}>En cours</option>
+            <option value="SUCCESS" {% if status_filter == 'SUCCESS' %}selected{% endif %}>Terminé</option>
+            <option value="FAILURE" {% if status_filter == 'FAILURE' %}selected{% endif %}>Échoué</option>
+            <option value="CANCELLED" {% if status_filter == 'CANCELLED' %}selected{% endif %}>Annulé</option>
+        </select>
+    </form>
+</div>
+
+<table>
+    <thead>
+        <tr>
+            <th>ID</th>
+            <th>Méthode</th>
+            <th>Nom</th>
+            <th>Statut</th>
+            <th>Progrès</th>
+            <th>Créé le</th>
+            <th>Actions</th>
+        </tr>
+    </thead>
+    <tbody>
+        {% for run in runs %}
+        <tr>
+            <td><a href="{% url 'run_detail' run.id %}">#{{ run.id }}</a></td>
+            <td>{{ run.method.name }}</td>
+            <td>{{ run.name|default:"-" }}</td>
+            <td class="status-{{ run.status|lower }}">{{ run.get_status_display }}</td>
+            <td>{{ run.progress }}%</td>
+            <td>{{ run.created_at|date:"d/m/Y H:i" }}</td>
+            <td>
+                <a href="{% url 'run_detail' run.id %}" class="btn" style="padding: 0.25rem 0.5rem;">Voir</a>
+            </td>
+        </tr>
+        {% empty %}
+        <tr>
+            <td colspan="7">Aucune simulation trouvée.</td>
+        </tr>
+        {% endfor %}
+    </tbody>
+</table>
+{% endblock %}

simulations/templatetags/simulation_extras.py

@@ -0,0 +1,88 @@
+import json as json_module
+from django import template
+
+register = template.Library()
+
+
+@register.filter
+def json_format(value):
+    """Affiche un objet Python au format JSON."""
+    return json_module.dumps(value, indent=2, ensure_ascii=False)
+
+
+@register.filter
+def multiply(value, arg):
+    """Multiplie la valeur par arg."""
+    try:
+        return float(value) * float(arg)
+    except (ValueError, TypeError):
+        return 0
+
+
+@register.filter
+def divide(value, arg):
+    """Divise la valeur par arg."""
+    try:
+        return float(value) / float(arg)
+    except (ValueError, TypeError, ZeroDivisionError):
+        return 0
+
+
+@register.filter
+def add(value, arg):
+    """Ajoute arg à la valeur."""
+    try:
+        return float(value) + float(arg)
+    except (ValueError, TypeError):
+        return value
+
+
+@register.filter
+def scientific(value):
+    """Affiche en notation scientifique."""
+    try:
+        return f"{float(value):.2e}"
+    except (ValueError, TypeError):
+        return value
+
+
+@register.filter
+def sigfig(value, digits=2):
+    """Affiche avec un nombre de chiffres significatifs."""
+    try:
+        val = float(value)
+        if val == 0:
+            return "0"
+        import math
+        magnitude = math.floor(math.log10(abs(val)))
+        precision = digits - 1 - magnitude
+        return f"{val:.{max(1, precision)}f}"
+    except (ValueError, TypeError):
+        return value
+
+
+@register.filter
+def is_list(value):
+    """Vérifie si la valeur est une liste."""
+    return isinstance(value, list)
+
+
+@register.filter
+def is_dict(value):
+    """Vérifie si la valeur est un dictionnaire."""
+    return isinstance(value, dict)
+
+
+@register.filter
+def contains(value, arg):
+    """Vérifie si la valeur contient arg."""
+    return arg in str(value)
+
+
+@register.filter
+def length(value):
+    """Retourne la longueur d'une liste."""
+    try:
+        return len(value)
+    except (TypeError, ValueError):
+        return 0

simulations/urls.py

@@ -0,0 +1,11 @@
+from django.urls import path, include
+from rest_framework.routers import DefaultRouter
+from .views import SimulationMethodViewSet, SimulationRunViewSet
+
+router = DefaultRouter()
+router.register(r'methods', SimulationMethodViewSet, basename='method')
+router.register(r'runs', SimulationRunViewSet, basename='run')
+
+urlpatterns = [
+    path('', include(router.urls)),
+]

simulations/urls_views.py

@@ -0,0 +1,15 @@
+from django.urls import path
+from . import views_views
+
+urlpatterns = [
+    path('', views_views.home, name='home'),
+    path('methods/', views_views.method_list, name='method_list'),
+    path('methods/<slug:slug>/', views_views.method_detail, name='method_detail'),
+    path('run/create/', views_views.run_create, name='run_create'),
+    path('run/create/<slug:method_slug>/', views_views.run_create, name='run_create_method'),
+    path('run/<int:run_id>/', views_views.run_detail, name='run_detail'),
+    path('run/<int:run_id>/status/', views_views.run_status, name='run_status'),
+    path('run/<int:run_id>/cancel/', views_views.run_cancel, name='run_cancel'),
+    path('run/<int:run_id>/retry/', views_views.run_retry, name='run_retry'),
+    path('runs/', views_views.run_list, name='run_list'),
+]

simulations/views.py

@@ -0,0 +1,85 @@
+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from .models import SimulationMethod, SimulationRun
+from .serializers import (
+    SimulationMethodSerializer,
+    SimulationRunSerializer,
+    SimulationRunCreateSerializer,
+)
+from .tasks import run_simulation
+
+
+class SimulationMethodViewSet(viewsets.ModelViewSet):
+    queryset = SimulationMethod.objects.filter(is_active=True)
+    serializer_class = SimulationMethodSerializer
+    lookup_field = 'slug'
+
+
+class SimulationRunViewSet(viewsets.ModelViewSet):
+    queryset = SimulationRun.objects.all()
+    
+    def get_serializer_class(self):
+        if self.action == 'create':
+            return SimulationRunCreateSerializer
+        if self.action == 'retrieve':
+            return SimulationRunDetailSerializer
+        return SimulationRunSerializer
+    
+    def create(self, request, *args, **kwargs):
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        
+        run = serializer.save()
+        
+        run_simulation.delay(run.id)
+        
+        output_serializer = SimulationRunSerializer(run)
+        return Response(
+            output_serializer.data,
+            status=status.HTTP_202_ACCEPTED
+        )
+    
+    @action(detail=True, methods=['post'])
+    def cancel(self, request, pk=None):
+        run = self.get_object()
+        if run.status in ['PENDING', 'RUNNING']:
+            run.status = 'CANCELLED'
+            run.save(update_fields=['status'])
+            return Response({'status': 'cancelled'})
+        return Response(
+            {'error': 'Cannot cancel run in current state'},
+            status=status.HTTP_400_BAD_REQUEST
+        )
+    
+    @action(detail=True, methods=['get'])
+    def status(self, request, pk=None):
+        run = self.get_object()
+        return Response({
+            'id': run.id,
+            'status': run.status,
+            'progress': run.progress,
+            'error_message': run.error_message,
+            'created_at': run.created_at,
+            'started_at': run.started_at,
+            'completed_at': run.completed_at,
+        })
+    
+    @action(detail=False, methods=['get'])
+    def pending(self, request):
+        runs = SimulationRun.objects.filter(status='PENDING')
+        serializer = self.get_serializer(runs, many=True)
+        return Response(serializer.data)
+    
+    @action(detail=False, methods=['get'])
+    def running(self, request):
+        runs = SimulationRun.objects.filter(status='RUNNING')
+        serializer = self.get_serializer(runs, many=True)
+        return Response(serializer.data)
+    
+    @action(detail=False, methods=['get'])
+    def recent(self, request):
+        limit = int(request.query_params.get('limit', 10))
+        runs = SimulationRun.objects.all()[:limit]
+        serializer = self.get_serializer(runs, many=True)
+        return Response(serializer.data)

simulations/views_views.py

@@ -0,0 +1,106 @@
+from django.shortcuts import render, get_object_or_404, redirect
+from django.http import JsonResponse
+from .models import SimulationMethod, SimulationRun
+from .tasks import run_simulation
+import json
+
+
+def home(request):
+    methods = SimulationMethod.objects.filter(is_active=True)
+    recent_runs = SimulationRun.objects.all()[:5]
+    return render(request, 'simulations/home.html', {
+        'methods': methods,
+        'recent_runs': recent_runs,
+    })
+
+
+def method_list(request):
+    methods = SimulationMethod.objects.filter(is_active=True)
+    return render(request, 'simulations/method_list.html', {
+        'methods': methods,
+    })
+
+
+def method_detail(request, slug):
+    method = get_object_or_404(SimulationMethod, slug=slug, is_active=True)
+    return render(request, 'simulations/method_detail.html', {
+        'method': method,
+    })
+
+
+def run_create(request, method_slug=None):
+    methods = SimulationMethod.objects.filter(is_active=True)
+    
+    if method_slug:
+        selected_method = get_object_or_404(
+            SimulationMethod, slug=method_slug, is_active=True
+        )
+    else:
+        selected_method = None
+    
+    if request.method == 'POST':
+        method_id = request.POST.get('method')
+        parameters = json.loads(request.POST.get('parameters', '{}'))
+        name = request.POST.get('name', '')
+        
+        method = get_object_or_404(SimulationMethod, pk=method_id)
+        
+        run = SimulationRun.objects.create(
+            method=method,
+            name=name,
+            parameters=parameters,
+        )
+        
+        run_simulation.delay(run.id)
+        
+        return redirect('run_detail', run_id=run.id)
+    
+    return render(request, 'simulations/run_create.html', {
+        'methods': methods,
+        'selected_method': selected_method,
+    })
+
+
+def run_detail(request, run_id):
+    run = get_object_or_404(SimulationRun, pk=run_id)
+    return render(request, 'simulations/run_detail.html', {
+        'run': run,
+    })
+
+
+def run_list(request):
+    runs = SimulationRun.objects.all()
+    status_filter = request.GET.get('status')
+    if status_filter:
+        runs = runs.filter(status=status_filter)
+    return render(request, 'simulations/run_list.html', {
+        'runs': runs,
+        'status_filter': status_filter,
+    })
+
+
+def run_status(request, run_id):
+    run = get_object_or_404(SimulationRun, pk=run_id)
+    return JsonResponse({
+        'id': run.id,
+        'status': run.status,
+        'progress': run.progress,
+        'error_message': run.error_message,
+        'started_at': run.started_at.strftime('%Y-%m-%d %H:%M:%S') if run.started_at else None,
+        'completed_at': run.completed_at.strftime('%Y-%m-%d %H:%M:%S') if run.completed_at else None,
+    })
+
+
+def run_cancel(request, run_id):
+    run = get_object_or_404(SimulationRun, pk=run_id)
+    if run.status in ['PENDING', 'RUNNING']:
+        run.status = 'CANCELLED'
+        run.save(update_fields=['status'])
+    return redirect('run_detail', run_id=run.id)
+
+
+def run_retry(request, run_id):
+    run = get_object_or_404(SimulationRun, pk=run_id)
+    run.set_pending()
+    run_simulation.delay(run.id)
+    return redirect('run_detail', run_id=run.id)

simulationserver/README.md

@@ -0,0 +1,116 @@
+# Simulation Numérique Server
+
+Plateforme Django pour exécuter des méthodes de simulation numérique avec traitement asynchrone via Celery et Redis.
+
+## Architecture
+
+```
+simulationserver/
+├── simulations/          # App Django
+│   ├── models.py        # Modèles (SimulationMethod, SimulationRun)
+│   ├── tasks.py         # Tâches Celery
+│   ├── views.py         # API REST
+│   ├── views_views.py   # Vues HTML
+│   └── templates/       # Templates
+├── simulationserver/     # Configuration Django
+│   ├── settings.py      # Settings + Celery config
+│   ├── celery.py        # Configuration Celery
+│   └── urls.py          # URLs
+└── manage.py
+```
+
+## Installation
+
+```bash
+pip install -r simulationserver/requirements.txt
+```
+
+## Configuration
+
+1. Installer et démarrer Redis:
+```bash
+# Sur Debian/Ubuntu
+sudo apt install redis-server
+sudo systemctl start redis
+
+# Ou avec Docker
+docker run -d -p 6379:6379 redis:alpine
+```
+
+## Démarrage
+
+1. Appliquer les migrations:
+```bash
+python manage.py migrate
+```
+
+2. Initialiser les méthodes de simulation:
+```bash
+python manage.py init_simulation_methods
+```
+
+3. Démarrer le serveur Django:
+```bash
+python manage.py runserver 0.0.0.0:8000
+```
+
+4. Démarrer le worker Celery (dans un autre terminal):
+```bash
+cd /root/bookshop
+celery -A simulationserver worker --loglevel=info
+```
+
+## Utilisation
+
+### Interface Web
+
+- **Accueil**: http://localhost:8000/
+- **Liste des méthodes**: http://localhost:8000/methods/
+- **Créer une simulation**: http://localhost:8000/run/create/
+- **Historique**: http://localhost:8000/runs/
+
+### API REST
+
+- `GET /api/methods/` - Liste des méthodes
+- `GET /api/methods/{slug}/` - Détail d'une méthode
+- `POST /api/runs/` - Créer et lancer une simulation
+- `GET /api/runs/{id}/` - Détail d'une simulation
+- `GET /api/runs/{id}/status/` - Statut d'une simulation
+- `POST /api/runs/{id}/cancel/` - Annuler une simulation
+- `GET /api/runs/recent/` - Simulations récentes
+
+## Modèles
+
+### SimulationMethod
+
+Décrit une méthode de simulation:
+- `name`: Nom de la méthode
+- `slug`: Identifiant unique
+- `description`: Description courte
+- `theory`: Documentation/theorie
+- `parameters_schema`: Schema JSON des paramètres
+- `default_parameters`: Paramètres par défaut
+
+### SimulationRun
+
+Une exécution de simulation:
+- `method`: Méthode utilisée
+- `parameters`: Paramètres de la simulation
+- `status`: PENDING, RUNNING, SUCCESS, FAILURE, CANCELLED
+- `progress`: Pourcentage de progression
+- `logs`: Logs d'exécution
+- `result_data`: Résultats JSON
+
+## Tâches Celery
+
+Les simulations sont exécutées en arrière-plan via Celery:
+- Le worker lit les paramètres depuis la base
+- Exécute le calcul
+- Met à jour le statut et les résultats
+- Les pages web font du polling pour le suivi
+
+## Ajouter une nouvelle méthode
+
+1. Ajouter la fonction de simulation dans `simulations/tasks.py`
+2. Ajouter le mapping dans `SIMULATION_METHODS`
+3. Créer un `SimulationMethod` via l'admin ou `init_simulation_methods`

simulationserver/__init__.py

@@ -0,0 +1,3 @@
+from .celery import app as celery_app
+
+__all__ = ('celery_app',)

simulationserver/asgi.py

@@ -0,0 +1,9 @@
+"""
+ASGI config for simulationserver project.
+"""
+
+import os
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'simulationserver.settings')
+application = get_asgi_application()

simulationserver/celery.py

@@ -0,0 +1,13 @@
+import os
+from celery import Celery
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'simulationserver.settings')
+
+app = Celery('simulationserver')
+app.config_from_object('django.conf:settings', namespace='CELERY')
+app.autodiscover_tasks()
+
+
+@app.task(bind=True, ignore_result=True)
+def debug_task(self):
+    print(f'Request: {self.request!r}')

simulationserver/requirements.txt

@@ -0,0 +1,7 @@
+Django>=4.2,<5.0
+djangorestframework>=3.14,<4.0
+celery>=5.3,<6.0
+redis>=4.5,<6.0
+numpy>=1.24,<2.0
+matplotlib>=3.7,<4.0
+reportlab>=4.0,<5.0

simulationserver/settings.py

@@ -0,0 +1,112 @@
+"""
+Django settings for simulationserver project.
+"""
+
+from pathlib import Path
+import os
+import sys
+from celery import Celery
+
+# Build paths inside the project like this: BASE_DIR / 'subdir'.
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+# Add django-polls to path for the existing app
+sys.path.insert(0, str(Path.home() / 'django-polls'))
+
+# Quick-start development settings
+SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY', 'django-insecure-simulationserver-key-change-in-production')
+DEBUG = os.environ.get('DEBUG', 'True').lower() in ('true', '1', 'yes')
+ALLOWED_HOSTS = ['*']
+
+# Application definition
+INSTALLED_APPS = [
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    'rest_framework',
+    'simulations',
+]
+
+MIDDLEWARE = [
+    'django.middleware.security.SecurityMiddleware',
+    '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',
+]
+
+ROOT_URLCONF = 'simulationserver.urls'
+
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',
+        'DIRS': [BASE_DIR / 'templates'],
+        '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 = 'simulationserver.wsgi.application'
+
+# Database
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': BASE_DIR / 'db.sqlite3',
+    }
+}
+
+# Celery Configuration
+CELERY_BROKER_URL = os.environ.get('CELERY_BROKER_URL', 'redis://localhost:6379/0')
+CELERY_RESULT_BACKEND = os.environ.get('CELERY_RESULT_BACKEND', 'redis://localhost:6379/0')
+CELERY_ACCEPT_CONTENT = ['json']
+CELERY_TASK_SERIALIZER = 'json'
+CELERY_RESULT_SERIALIZER = 'json'
+CELERY_TIMEZONE = 'UTC'
+
+# REST Framework
+REST_FRAMEWORK = {
+    'DEFAULT_RENDERER_CLASSES': [
+        'rest_framework.renderers.JSONRenderer',
+    ],
+    'DEFAULT_PARSER_CLASSES': [
+        'rest_framework.parsers.JSONParser',
+        'rest_framework.parsers.MultiPartParser',
+    ],
+}
+
+# Password validation
+AUTH_PASSWORD_VALIDATORS = [
+    {'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator'},
+    {'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator'},
+    {'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator'},
+    {'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator'},
+]
+
+# Internationalization
+LANGUAGE_CODE = 'fr'
+TIME_ZONE = 'UTC'
+USE_I18N = True
+USE_TZ = True
+
+# Static files
+STATIC_URL = 'static/'
+
+# Media files
+MEDIA_URL = 'media/'
+MEDIA_ROOT = BASE_DIR / 'media'
+
+# Default primary key field type
+DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

simulationserver/templates/simulations/home.html

@@ -0,0 +1,113 @@
+{% extends 'simulations/base.html' %}
+{% load simulation_extras %}
+{% block title %}Simulations Numériques{% endblock %}
+{% block content %}
+<h1>🧮 Simulations Numériques</h1>
+<p>Plateforme d'exécution de méthodes de simulation numérique avec traitement asynchrone.</p>
+
+<h2>Méthodes disponibles</h2>
+<div class="grid">
+    {% for method in methods %}
+    <div class="card method-card" style="position: relative;">
+        <div style="position: absolute; top: 10px; right: 10px; font-size: 2em;">
+            {% if 'monte-carlo' in method.slug %}🎲
+            {% elif 'diffusion' in method.slug %}🌡️
+            {% elif 'linear' in method.slug %}📐
+            {% elif 'heat' in method.slug %}🔥
+            {% elif 'traffic' in method.slug %}🚗
+            {% elif 'phugoid' in method.slug %}✈️
+            {% elif 'elasticity' in method.slug %}⚙️
+            {% elif 'wave' in method.slug %}🌊
+            {% else %}📊{% endif %}
+        </div>
+        <h3>{{ method.name }}</h3>
+        <p>{{ method.description }}</p>
+        <div style="margin-top: 1rem;">
+            <a href="{% url 'method_detail' method.slug %}" class="btn btn-secondary">En savoir plus</a>
+            <a href="{% url 'run_create_method' method.slug %}" class="btn btn-success">Lancer une simulation</a>
+        </div>
+    </div>
+    {% empty %}
+    <p>Aucune méthode disponible. Exécutez <code>python manage.py init_simulation_methods</code></p>
+    {% endfor %}
+</div>
+
+{% if recent_runs %}
+<h2>Simulations récentes</h2>
+<table>
+    <thead>
+        <tr>
+            <th>ID</th>
+            <th>Méthode</th>
+            <th>Statut</th>
+            <th>Progrès</th>
+            <th>Créé le</th>
+            <th>Actions</th>
+        </tr>
+    </thead>
+    <tbody>
+        {% for run in recent_runs %}
+        <tr>
+            <td><a href="{% url 'run_detail' run.id %}">#{{ run.id }}</a></td>
+            <td>{{ run.method.name }}</td>
+            <td class="status-{{ run.status|lower }}">{{ run.get_status_display }}</td>
+            <td>
+                <div style="display: flex; align-items: center; gap: 0.5rem;">
+                    <div class="progress-bar" style="width: 50px; height: 8px;">
+                        <div class="progress-fill" style="width: {{ run.progress }}%;"></div>
+                    </div>
+                    <span>{{ run.progress }}%</span>
+                </div>
+            </td>
+            <td>{{ run.created_at|date:"d/m/Y H:i" }}</td>
+            <td>
+                <a href="{% url 'run_detail' run.id %}" class="btn" style="padding: 0.25rem 0.5rem; font-size: 0.8em;">Voir</a>
+            </td>
+        </tr>
+        {% endfor %}
+    </tbody>
+</table>
+{% endif %}
+
+<div class="card" style="margin-top: 2rem;">
+    <h2>📖 Guide rapide</h2>
+    <ol>
+        <li>Choisissez une méthode de simulation dans la liste ci-dessus</li>
+        <li>Configurez les paramètres (ou laissez les valeurs par défaut)</li>
+        <li>Lancez la simulation - elle s'exécute en arrière-plan</li>
+        <li>Attendez que le statut passe à "Terminé"</li>
+        <li>Visualisez les résultats et téléchargez les fichiers (PNG, PDF, CSV)</li>
+    </ol>
+    
+    <h3>Architecture</h3>
+    <ul>
+        <li><strong>Django</strong> : Interface Web + API REST</li>
+        <li><strong>Celery</strong> : Traitement asynchrone des simulations</li>
+        <li><strong>Redis</strong> : Message broker</li>
+        <li><strong>Matplotlib</strong> : Génération des graphiques</li>
+        <li><strong>ReportLab</strong> : Génération des rapports PDF</li>
+    </ul>
+</div>
+
+<div class="card" style="margin-top: 1rem;">
+    <h2>🔧 Ajouter une nouvelle méthode</h2>
+    <p>Pour ajouter une nouvelle méthode de simulation :</p>
+    <ol>
+        <li>Créer une fonction dans <code>simulations/tasks.py</code> qui retourne un générateur</li>
+        <li>Ajouter la méthode à <code>SIMULATION_METHODS</code> dans tasks.py</li>
+        <li>Créer un <code>SimulationMethod</code> via l'admin ou la commande <code>init_simulation_methods</code></li>
+        <li>Le système gérera automatiquement l'affichage et les téléchargements</li>
+    </ol>
+    
+    <h3>Exemple de fonction de simulation</h3>
+    <pre style="background: #2c3e50; color: #ecf0f1; padding: 1rem; border-radius: 4px; overflow-x: auto;">
+def ma_nouvelle_simulation(params):
+    """Ma nouvelle simulation."""
+    # Code de simulation avec yield pour la progression
+    for i in range(100):
+        # Faire des calculs...
+        yield i  # Progrès de 0 à 100
+    
+    return {'resultat': 'valeur'}</pre>
+</div>
+{% endblock %}

simulationserver/urls.py

@@ -0,0 +1,14 @@
+"""
+URL configuration for simulationserver project.
+"""
+
+from django.contrib import admin
+from django.urls import path, include
+from django.conf import settings
+from django.conf.urls.static import static
+
+urlpatterns = [
+    path('admin/', admin.site.urls),
+    path('api/', include('simulations.urls')),
+    path('', include('simulations.urls_views')),
+] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

simulationserver/wsgi.py

@@ -0,0 +1,9 @@
+"""
+WSGI config for simulationserver project.
+"""
+
+import os
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'simulationserver.settings')
+application = get_wsgi_application()