- Ajout onglet "Compteurs" dans l'interface avec graphique d'évolution
- Implémentation RequestCountersChart : nuages de points pour arrivées/départs/en file
- Modification backend : collecte des compteurs cumulés en temps réel
- Fix reset warmup : conservation des compteurs total_arrivals/departures
- Ajout champs cumulative_arrivals/departures_per_queue dans TimeSeriesData
- Conformité 100% avec les 8 résultats demandés dans le sujet

- Layout 3 colonnes (config, résultats, export)
- Remplacement de tous les emojis par des icônes MUI
- Ajout de composants collapse pour les sections
- Position sticky pour les sidebars
- Icônes: ShowChartIcon, MenuBookIcon, TrendingUpIcon, AssessmentIcon
- Sections réductibles pour métriques simulation et analytiques
- Layout plus professionnel et navigation améliorée

Nouveau composant QueueEvolutionChart qui affiche:
- N_coordinateur(t): clients dans le coordinateur
- N_serveur_i(t): clients dans chaque serveur
- N_total(t): total clients dans le système (pointillés)

Placé en premier dans l'onglet Visualisations.
Affiche statistiques (moyenne, max) pour chaque file.

Nouveau composant SteadyStateChart qui affiche:
- Évolution du nombre de clients dans le système
- Séparation visuelle période de chauffe / régime permanent
- Statistiques du régime permanent (moyenne, écart-type, min, max)
- Coefficient de variation pour évaluer la stabilité
- Courbe colorée différemment avant/après warmup_time

Intégration dans l'onglet Visualisations de ResultsDisplay.

Problèmes corrigés:
1. average_customers_in_system était toujours 0 (non calculé)
2. Comparaison utilisait γ₀ au lieu de λ₀ (erreur 101%)

Modifications:
- simulation.py: Ajout calcul L = λ₀ × W (Loi de Little)
- jackson.py: Ajout champ external_arrival_rate (λ₀)
- comparison.py: Utilisation de λ₀ au lieu de γ₀ pour L total
- analytics.py: Mise à jour API response model
- simulation.ts: Ajout external_arrival_rate dans types

Documentation complète expliquant:
- λ saisi directement en req/ms (taux)
- μ saisi en temps (ms ou s) avec conversion automatique
- Tables de conversion pour tous les scénarios
- Formules de calcul de λ
- Exemples pratiques
- Astuces de validation

Changements dans ParameterPanel:
- λ (lambda) maintenant saisi directement en req/ms
- Label: "Taux d'arrivée externe (λ)"
- Helper text: "Requêtes par milliseconde (req/ms)"
- Unité affichée: "req/ms"
- Plus de conversion nécessaire pour λ

Avantages:
✅ Saisie directe du taux (comme les μ)
✅ Cohérent avec la notation mathématique
✅ Plus simple pour les utilisateurs avancés
✅ Les temps de service gardent la conversion ms/s

Exemple de saisie:
- λ = 0.008 req/ms (au lieu de "temps entre arrivées = 125 ms")
- μc = 10 ms (temps moyen)
- μ1 = 120 ms (temps moyen)

Guide complet d'utilisation du convertisseur ms/s avec:
- Instructions d'utilisation détaillées
- Captures d'écran ASCII de l'interface
- Cas d'usage pratiques
- Tableau des valeurs du TP
- Exemples de workflow
- Fonctionnalités avancées

Nouveau composant TimeConverter:
- Conversion bidirectionnelle ms ↔ s
- Interface pliable/dépliable pour gagner de l'espace
- Bouton d'échange (swap) pour inverser les valeurs
- Référence rapide avec les valeurs du TP (10ms, 120ms, 240ms, etc.)
- Formules de conversion affichées
- Intégré directement dans le ParameterPanel

Fonctionnalités:
✅ Entrée dans un champ, conversion automatique dans l'autre
✅ Bouton swap pour échanger les valeurs
✅ Section référence avec toutes les valeurs du TP
✅ Pliable par défaut pour ne pas encombrer l'interface
✅ Style cohérent avec Material-UI

Utilisation:
1. Cliquez sur "🔄 Convertisseur de temps" pour déplier
2. Entrez une valeur en ms ou en s
3. La conversion se fait automatiquement
4. Utilisez le bouton ⇅ pour échanger les valeurs

Document récapitulatif avec:
- Conformité avec le sujet du TP
- Architecture technique détaillée
- Résultats des 5 scénarios
- Validation scientifique (écarts < 2%)
- Tests et qualité (29/29 tests passent)
- Points forts et justifications des choix
- Guide pour la présentation

Frontend:
- Ajout d'un ToggleButton pour choisir entre millisecondes (ms) et secondes (s)
- Conversion automatique temps ↔ taux dans ParameterPanel
- Interface plus intuitive: entrer directement les temps moyens (10ms, 120ms, etc.)
- Labels mis à jour: "Temps moyen de service" au lieu de "Taux de service"
- Helper text dynamique selon l'unité choisie

Rapport LaTeX:
- Document complet de 49 pages avec structure professionnelle
- 8 sections principales (intro, théorie, modélisation, implémentation, scénarios, résultats, analyse, conclusion)
- 2 annexes (code source complet, résultats détaillés)
- Bibliographie de 20 références scientifiques
- Diagrammes TikZ, tableaux, équations mathématiques
- Validation du théorème de Jackson avec preuves
- Fichier PDF compilé: rapport/main.pdf (420 KB)

Documentation:
- Guide d'utilisation détaillé (GUIDE_UTILISATION.md)
- Exemples pour les 5 scénarios du TP
- Explications de la conversion temps/taux

- Création de NOUVELLES-FONCTIONNALITES.md
  * Description détaillée des séries temporelles
  * Description détaillée de l'histogramme
  * Utilité scientifique pour le TP
  * Exemples d'interprétation
  * Guide d'utilisation dans le rapport
  * Références théoriques

- Mise à jour de DEMARRAGE.md
  * Ajout des nouvelles visualisations dans l'onglet Visualisations
  * Mention de la convergence et validation M/M/1

Documentation complète pour:
✓ Compréhension des graphiques
✓ Interprétation scientifique
✓ Intégration dans le rapport universitaire

Tests: ✓ 21/21 tests passent

Backend (Python):
- Collecte de données de séries temporelles (échantillonnage toutes les 1000 unités)
- Comptage du nombre de clients par file au fil du temps
- Génération d'histogramme des temps de traitement (20 bins)
- Calcul de statistiques: min, max, moyenne, écart-type
- Ajout des champs time_series_data et histogram_data à SimulationResults
- Méthode _create_histogram() pour génération automatique des bins

Frontend (React + TypeScript):
- Nouveau composant TimeSeriesChart: graphique de l'évolution du nombre de clients
  * Affiche la convergence vers l'état stable
  * Utilise Chart.js Line chart
  * Responsive avec Material-UI Paper
- Nouveau composant ProcessingTimeHistogram: distribution des temps de traitement
  * Barres montrant la distribution exponentielle
  * Statistiques affichées (min, moyenne, écart-type, max)
  * Utilise Chart.js Bar chart
- Intégration dans ResultsDisplay onglet Visualisations
- Nouveaux types TypeScript: TimeSeriesData, HistogramData

Améliorations TP:
✓ Visualisation de la convergence vers l'état d'équilibre
✓ Validation de la distribution exponentielle (M/M/1)
✓ Graphiques scientifiques pour le rapport

Build: ✓ 720.12 kB (gzip 231.51 kB)

- Remplacement de tous les composants Tailwind par Material-UI
- Dashboard: AppBar, Container, Paper, Stack pour la mise en page
- ScenarioSelector: FormControl, Select, MenuItem, Alert
- ParameterPanel: TextField, Button, IconButton, Paper
- SimulationControl: Button variants, Chip avec animation pulse
- ResultsDisplay: Tabs, Alert, CircularProgress
- MetricsCard: Paper avec variants (outlined/elevation)
- ComparisonTable: Table MUI complète avec TableContainer
- ExportButton: Stack avec boutons Material

Thème Material Design:
- Palette de couleurs cohérente (primary blue, secondary purple)
- Typography personnalisée
- Components stylisés (borderRadius: 8, textTransform: none)
- CssBaseline pour normalisation CSS

Corrections TypeScript:
- Import type pour SelectChangeEvent
- Suppression imports non utilisés

Build: ✓ 713.70 kB (gzip 229.68 kB)
Tests: ✓ 21/21 tests backend passent

Remplacement de Tailwind CSS par Material-UI pour un design plus professionnel.

1. Installation MUI:
   - @mui/material @mui/icons-material
   - @emotion/react @emotion/styled (styling engine)

2. Configuration theme (theme.ts):
   - Palette couleurs (primary=bleu, secondary=violet)
   - Typography (Roboto font family)
   - Components overrides (buttons, cards)
   - Border radius 8px

3. Main.tsx:
   - ThemeProvider wrapping App
   - CssBaseline pour reset CSS Material

4. Dashboard refactorise (100% MUI):
   - AppBar + Toolbar (header professionnel)
   - Container responsive (maxWidth xl)
   - Paper elevation pour cartes (ombres)
   - Typography pour textes (h6, caption, body2)
   - Alert avec IconButton pour erreurs
   - Stack + Box pour layout flexbox
   - Icons: ScienceIcon, CloseIcon

Avantages MUI:
- Design Material cohérent et professionnel
- Composants accessibles (ARIA)
- Animations fluides
- Theme customizable
- TypeScript support excellent
- Documentation complete

Build status: OK (600KB gzip 198KB)
Frontend: Fonctionnel avec hot reload

Prochaines etapes (optionnel):
- Convertir ScenarioSelector (Select + MenuItem)
- Convertir ParameterPanel (TextField)
- Convertir SimulationControl (Button)
- Convertir ResultsDisplay (Tabs + Alert)
- Convertir MetricsCard (Card + CardContent)
- Convertir ComparisonTable (Table MUI)

Documentation: MIGRATION-MUI.md avec guide complet

Corrections et ajouts:

1. ResultsDisplay.tsx:
   - Suppression div fermante en double (ligne 346-347)
   - Structure JSX corrigee pour les 3 onglets
   - Frontend recharge correctement maintenant

2. test-integration.sh:
   - Script complet de test d'integration
   - 8 tests automatiques:
     * Backend health check
     * API endpoints (root, scenarios, simulation)
     * Execution simulation complete
     * Analyse Jackson et comparaison
     * Frontend accessible
     * Configuration CORS
   - Code couleur pour resultats (vert=OK, rouge=echec)
   - Affichage URLs finales

3. DEMARRAGE.md:
   - Guide complet de demarrage
   - Instructions installation (Python + Node.js)
   - Commandes lancement (backend + frontend)
   - Utilisation interface web
   - Documentation API REST avec exemples curl
   - Description des 5 scenarios
   - Architecture detaillee (backend + frontend)
   - Metriques calculees (simulation + analytique)
   - Section depannage
   - Notes pour rapport universitaire

Tests integration: TOUS PASSES (8/8)
Backend API: http://localhost:8000 - Operationnel
Frontend: http://localhost:5173 - Operationnel
CORS: Configure et fonctionnel

Implementation complete des visualisations interactives:

1. Bibliotheques installees:
   - chart.js + react-chartjs-2 (graphiques)
   - d3 + @types/d3 (diagramme reseau)

2. NetworkDiagram (D3.js):
   - Diagramme topologie du reseau
   - Visualisation coordinateur + serveurs + sortie
   - Fleches avec probabilites de routage (p, qi)
   - Taux de service affiches (λ, μc, μi)
   - Code couleur: bleu=coordinateur, violet=serveurs, rouge=sortie
   - Fleches pointillees pour feedback (serveur -> coord)

3. UtilizationChart (Chart.js):
   - Graphique barres pour utilisation (ρ)
   - Comparaison simulation vs analytique
   - Ligne rouge a ρ=1.0 (seuil stabilite)
   - Tooltip avec valeurs precises

4. MetricsComparisonChart (Chart.js):
   - Deux versions: L (nombre moyen clients) et W (temps moyen)
   - Barres comparatives simulation/analytique
   - Visualisation par file d'attente

5. ResultsDisplay mis a jour:
   - Interface a onglets: Metriques | Visualisations | Comparaison
   - Onglet Metriques: tableaux metriques detailles
   - Onglet Visualisations:
     * Diagramme reseau
     * Graphique utilisation
     * Graphiques L et W cote a cote
   - Onglet Comparaison:
     * Table comparaison complete
     * Charts visualisation differences

6. ExportButton:
   - Export JSON (config + tous resultats)
   - Export CSV (metriques formatees)
   - Boutons dans header resultats
   - Fichiers horodates automatiquement

7. Dashboard integre:
   - Boutons export visibles en permanence
   - Layout responsive pour visualisations
   - Grille adaptative (1 ou 2 colonnes selon taille ecran)

Toutes les visualisations requises pour le projet universitaire sont implementees.
L'application est complete et prete pour execution des 5 scenarios.

Implementation complete du frontend React avec:

1. API Client Service (services/api.ts)
   - Axios client configure avec base URL
   - 12 endpoints mappes (simulation, scenarios, analytics)
   - Types TypeScript pour toutes les requetes/reponses
   - Gestion erreurs et timeouts

2. Types TypeScript (types/simulation.ts)
   - Tous les modeles Pydantic mappes en TypeScript
   - SimulationConfig, SimulationResults
   - NetworkAnalytics, NetworkComparison
   - Interfaces completes pour API

3. Zustand Store (store/simulationStore.ts)
   - Gestion d'etat centralisee
   - Actions: setConfig, startSimulation, computeAnalytical, etc.
   - State: config, results, analyticalResults, comparisonResults
   - Chargement automatique des scenarios
   - Calculs analytiques et comparaisons automatiques

4. Dashboard Layout (components/Dashboard.tsx)
   - Layout principal avec header/footer
   - Grille responsive (sidebar + main content)
   - Notification d'erreurs
   - Integration de tous les composants

5. Composants de Simulation:
   - ScenarioSelector: Dropdown avec 5 scenarios predefinis
   - ParameterPanel: Formulaire edition parametres (λ, μc, p, serveurs)
     * Validation conservation probabilites (p + Σq = 1.0)
     * Ajout/suppression dynamique de serveurs
   - SimulationControl: Boutons Start/Stop/Clear/Reset
     * Indicateur de statut (running/completed)
     * Spinner pendant execution
     * Info parametres simulation

6. Composants de Resultats:
   - ResultsDisplay: Affichage complet resultats
     * Indicateur stabilite
     * Resultats simulation (coord + serveurs)
     * Resultats analytiques (Jackson)
     * Table comparaison
   - MetricsCard: Carte pour une metrique (compact/normal)
   - ComparisonTable: Table comparaison Analytique vs Simulation
     * Code couleur differences (<5% vert, 5-10% jaune, >10% rouge)
     * Affichage tous les metriques (ρ, L, W, Wq)

7. Features:
   - Interface bilingue (francais)
   - Responsive design (Tailwind CSS)
   - Loading states et spinners
   - Validation formulaires
   - Gestion erreurs comprehensive
   - Build optimise (Vite)

Frontend pret pour integration avec backend FastAPI.
Prochaine etape: Visualisations (charts et diagrammes)

Complete REST API with FastAPI for simulation, scenarios, and analytics

API Endpoints - Simulation (/api/simulation):
- POST /start: Start new simulation with custom config
  - Accepts SimulationConfigModel (Pydantic validation)
  - Returns session_id for result retrieval
  - Runs simulation synchronously

- GET /results/{session_id}: Get simulation results
  - Returns complete SimulationResultsModel
  - Includes coordinator and server statistics
  - Stability assessment

- DELETE /results/{session_id}: Clean up session
- GET /sessions: List all active sessions

API Endpoints - Scenarios (/api/scenarios):
- GET /: List all 5 predefined scenarios
  - Returns scenario metadata (id, name, description)

- GET /{scenario_id}: Get scenario configuration
  - Returns full SimulationConfigModel
  - Ready to use or modify

- GET /scenario_5/variations: Get parameter sensitivity variations
  - Returns all variations for scenario 5

- POST /{scenario_id}/run: Execute predefined scenario
  - Runs scenario and stores results
  - Returns session_id for retrieval

API Endpoints - Analytics (/api/analytics):
- POST /jackson: Analyze with Jackson's theorem
  - Input: SimulationConfigModel
  - Output: Analytical results (L, W, ρ, stability)
  - No simulation required

- GET /compare/{session_id}: Compare analytical vs simulation
  - Requires existing simulation session
  - Returns detailed comparison with percentage differences
  - Per-queue and system-wide metrics

- POST /stability: Quick stability check
  - Input: Configuration
  - Output: Stability conditions for all queues
  - Utilization calculations

Architecture:
- Modular router design (simulation, scenarios, analytics)
- Pydantic models for validation and serialization
- In-memory session storage (could use Redis in production)
- Comprehensive error handling
- CORS enabled for frontend integration

Testing:
- test_api.py: Complete API test suite
  - Tests all endpoints
  - End-to-end workflow
  - Includes examples of usage

Documentation:
- Auto-generated OpenAPI docs at /docs
- ReDoc documentation at /redoc
- Comprehensive endpoint descriptions

Features:
- Type-safe API with Pydantic validation
- Automatic request/response serialization
- Built-in API documentation
- CORS support for React frontend
- Session management for results

Phase 5 Complete ✓
Next: Phase 6 - Frontend React dashboard

Implement analytical analysis using Jackson's theorem for open networks

Jackson's Theorem Implementation:
- analytics/jackson.py: Complete Jackson theorem analyzer
  - Calculate effective arrival rates (λᵢ)
  - Calculate utilizations (ρᵢ = λᵢ/μᵢ)
  - Stability check (ρᵢ < 1 for all queues)
  - M/M/1 formulas: L = ρ/(1-ρ), W = L/λ
  - System-wide metrics using Little's Law
  - Handles both stable and unstable queues

Mathematical Formulas:
- Effective arrival rates for network topology
- Utilization: ρᵢ = λᵢ / μᵢ
- Average customers: Lᵢ = ρᵢ / (1 - ρᵢ)
- Average time: Wᵢ = Lᵢ / λᵢ (Little's Law)
- Average wait: Wq = W - 1/μ
- Total system: L_total = Σ Lᵢ, W_total = L_total / λ₀

Comparison Module:
- analytics/comparison.py: Compare analytical vs simulation
  - QueueComparison for per-queue metrics
  - NetworkComparison for system-wide comparison
  - Percentage difference calculations
  - Formatted comparison reports

Testing & Validation:
- tests/test_analytics.py: 7 tests validating Jackson's theorem
  - Simple M/M/1 queue (analytical vs theory)
  - Unstable queue detection (ρ > 1)
  - Network with multiple servers
  - Little's Law validation (L = λW)
  - Probability conservation
  - Effective arrival rates
  - Multi-server stability

Demo & Examples:
- demo_analytical.py: Compare analytical vs simulation for scenarios
  - Runs scenarios 1-3
  - Shows theoretical predictions
  - Shows simulation results
  - Detailed comparison tables
  - Percentage differences

Results:
- ✅ All 7 analytical tests pass
- ✅ Little's Law validated for all queues
- ✅ Stability detection working correctly
- ✅ Comparison reveals expected statistical variation

Observations:
- Analytical predictions are accurate for stable systems
- Simulation shows statistical variation (finite sample)
- Unstable queues detected correctly (ρ ≥ 1)
- Differences increase with higher utilization

Phase 4 Complete ✓
Next: Phase 5 - Backend API implementation

Add Pydantic models for API validation and 5 project scenarios

Pydantic Models:
- models/config.py: SimulationConfigModel with full validation
  - ServerConfig for each server in the network
  - Probability conservation validation
  - Conversion to internal SimulationConfig

- models/results.py: Complete results models for API responses
  - QueueStatisticsModel per queue
  - TimeSeriesDataModel for evolution tracking
  - HistogramDataModel for processing time distribution
  - SimulationResultsModel with all metrics

Predefined Scenarios:
- scenarios.py: 5 scenarios from project requirements
  - Scenario 1: 1 fast server (120ms) - instability test
  - Scenario 2: 1 fast + 1 slow server (120ms/240ms)
  - Scenario 3: 3 slow servers (240ms each)
  - Scenario 4: 1 fast + 1 medium (120ms/190ms) - compare with scenario 3
  - Scenario 5: Parameter sensitivity (vary λ and p)

- Theoretical utilization calculations for each scenario
- Scenario registry for easy access
- list_scenarios() function for API

Testing:
- test_all_scenarios.py: Comprehensive test of all scenarios
- Runs all 5 scenarios with variations
- Compares theoretical vs simulation results
- Summary table for performance comparison

Results Analysis:
- All scenarios execute successfully
- Stable systems show ρ < 1 as expected
- Some scenarios show slight instability (ρ ≈ 1.0) due to high load
- Parameter sensitivity variations demonstrate impact of λ and p

Phase 3 Complete ✓
Next: Phase 4 - Analytical module (Jackson's theorem)

Implement event-driven discrete simulation for queueing networks

Core Components:
- events.py: Event and EventType for discrete event simulation
  - Priority queue ordering by time
  - ARRIVAL and SERVICE_END event types

- request.py: Request entity with full visit tracking
  - QueueVisit records for each queue visited
  - Automatic calculation of wait/service/system times
  - Journey tracking through network

- random_utils.py: Random number generation
  - Exponential distribution (inverse transform method)
  - Probabilistic choice for routing decisions
  - Seed control for reproducibility

- queues.py: M/M/1 Queue implementation
  - FIFO discipline with single server
  - Complete statistics collection (utilization, avg times)
  - Exponential service times

- router.py: Probabilistic routing logic
  - Route from coordinator: exit (p) or server (qi)
  - Route from server: always return to coordinator
  - Probability conservation validation

- simulation.py: Main event-driven simulator
  - Priority queue (heapq) for event scheduling
  - Warmup period to reach steady state
  - Complete statistics generation
  - Support for multiple servers

Testing:
- test_random_utils.py: Validate exponential distribution (mean, reproducibility)
- test_simulation.py: End-to-end simulation tests
  - Stable and unstable systems
  - Multiple servers
  - Reproducibility with seeds

Demo:
- demo_simulation.py: Scenario 1 demonstration (1 fast server)
- Theoretical vs simulation comparison
- All 14 tests passing ✓

Phase 2 Complete ✓
Next: Phase 3 - Statistics collection and multi-server scenarios

Initialize Turborepo monorepo with Python backend and React frontend

- Setup Turborepo configuration with workspaces
- Configure Python FastAPI backend
  - Create project structure (core, analytics, api, models)
  - Add requirements.txt with FastAPI, Uvicorn, Pydantic, etc.
  - Basic FastAPI app with health endpoints
  - CORS middleware for frontend integration
- Configure React + TypeScript + Vite frontend
  - Install dependencies (Chart.js, D3.js, Zustand, Axios)
  - Setup Tailwind CSS with PostCSS
  - Create component directory structure
  - Basic landing page with Tailwind styling
- Add comprehensive README files
- Configure .gitignore for Python and Node.js

Phase 1 Complete ✓
Next: Phase 2 - Core simulation engine implementation