# ⏱️ Temps de Simulation - Guide d'utilisation

## 📍 Emplacement

Le champ "Temps de simulation" se trouve dans le **panneau de paramètres**, juste après le taux d'arrivée λ.

```
┌──────────────────────────────────────┐
│ Paramètres du réseau      [ms] [s]  │
├──────────────────────────────────────┤
│ Taux d'arrivée externe (λ)           │
│ │ 0.008                   req/ms │  │
│                                      │
│ Temps de simulation           [NEW] │
│ │ 100000                      ms │  │ ← Nouveau champ!
│ ~800 requêtes attendues              │ ← Calcul automatique
└──────────────────────────────────────┘
```

## 🎯 Fonctionnement

### Valeur par défaut
```
100,000 ms (100 secondes)
```

### Adaptation au sélecteur d'unité

**Mode [ms]:**
```
Temps de simulation: 100000 ms
~800 requêtes attendues (si λ = 0.008 req/ms)
```

**Mode [s]:**
```
Temps de simulation: 100.0 s
~800 requêtes attendues (si λ = 0.008 req/ms)
```

Le champ s'adapte automatiquement comme les autres paramètres de temps!

## 📊 Calcul automatique du nombre de requêtes

**Formule utilisée:**
```
Nombre de requêtes ≈ λ × temps_simulation
```

**Exemples:**

| λ (req/ms) | Temps (ms) | Requêtes attendues |
|-----------|-----------|-------------------|
| 0.004 | 100,000 | ~400 |
| 0.008 | 100,000 | ~800 |
| 0.012 | 100,000 | ~1,200 |
| 0.008 | 200,000 | ~1,600 |

## 🎓 Recommandations pour le TP

### Temps minimum recommandé

**Pour garantir le régime permanent:**

| Utilisation max (ρ) | Temps recommandé | Requêtes (λ=0.008) |
|---------------------|------------------|-------------------|
| ρ < 0.5 | 50,000 ms | ~400 |
| 0.5 ≤ ρ < 0.8 | 100,000 ms | ~800 |
| 0.8 ≤ ρ < 0.95 | 200,000 ms | ~1,600 |
| ρ ≥ 0.95 | 500,000+ ms | ~4,000+ |

**Important:** Plus ρ est proche de 1, plus il faut de temps pour atteindre le régime permanent!

### Pour les 5 scénarios du TP

**Scénarios stables (1-4):**
```
Temps recommandé: 100,000 ms
Suffisant pour atteindre le régime permanent
```

**Scénario 5 (analyse de sensibilité):**
```
Tester plusieurs valeurs:
- 50,000 ms (charge faible)
- 100,000 ms (charge normale)
- 200,000 ms (charge élevée)
```

## 💡 Période de chauffe (Warmup)

**Automatique et transparent:**
```
Warmup: 10,000 ms (par défaut)
Statistiques collectées: Après le warmup uniquement
```

Le système ignore automatiquement les **10,000 premières unités de temps** pour éliminer l'effet transitoire initial.

**Exemple avec temps = 100,000 ms:**
```
┌─────────────┬──────────────────────────┐
│ 0-10,000 ms │ Warmup (ignoré)          │
│ 10,000-     │ Collecte des statistiques│
│ 100,000 ms  │                          │
└─────────────┴──────────────────────────┘
```

## 🔧 Modification du temps de simulation

### Via l'interface

1. Localisez le champ "Temps de simulation"
2. Entrez la nouvelle valeur
3. Le nombre de requêtes se met à jour automatiquement
4. Lancez la simulation

### Valeurs suggérées

**Pour tests rapides:**
```
50,000 ms → ~400 requêtes (2-5 secondes)
```

**Pour résultats précis:**
```
100,000 ms → ~800 requêtes (15-30 secondes)
```

**Pour analyse fine:**
```
200,000 ms → ~1,600 requêtes (30-60 secondes)
```

## ⚠️ Garanties de régime permanent

### Le temps de simulation SEUL ne garantit PAS le régime permanent!

**Conditions nécessaires:**

1. **Stabilité du système** (CRITIQUE!)
   ```
   Pour CHAQUE file: ρ = λ/μ < 1
   ```
   Si ρ ≥ 1, le système est instable → PAS de régime permanent possible!

2. **Période de warmup**
   ```
   Automatique: 10,000 ms
   ```

3. **Temps de simulation suffisant**
   ```
   Dépend de ρ (voir tableau des recommandations)
   ```

### Vérification de stabilité

L'interface affiche automatiquement:

```
✅ Système stable - régime permanent atteignable
⚠️ Utilisation élevée (ρ = 0.96) - augmentez le temps
❌ Système instable (ρ ≥ 1) - régime permanent impossible
```

## 📈 Impact sur les performances

| Temps (ms) | Requêtes | Durée réelle | Mémoire |
|-----------|---------|--------------|---------|
| 50,000 | ~400 | 2-5 sec | <50 MB |
| 100,000 | ~800 | 15-30 sec | <100 MB |
| 200,000 | ~1,600 | 30-60 sec | <150 MB |
| 500,000 | ~4,000 | 2-3 min | <300 MB |

**Note:** Durées approximatives sur machine standard

## 🎯 Cas d'usage pratiques

### Scénario 1: Configuration standard

**Objectif:** Résultats précis pour le rapport

```
Temps de simulation: 100,000 ms
λ = 0.008 req/ms
→ ~800 requêtes
→ Temps d'exécution: 15-30 secondes
→ Régime permanent atteint ✓
```

### Scénario 2: Tests rapides

**Objectif:** Vérifier rapidement la configuration

```
Temps de simulation: 50,000 ms
λ = 0.008 req/ms
→ ~400 requêtes
→ Temps d'exécution: 2-5 secondes
→ Résultats approximatifs
```

### Scénario 3: Système proche de l'instabilité

**Objectif:** ρ ≈ 0.96 (Scénario 1 du TP)

```
Temps de simulation: 200,000 ms
λ = 0.008 req/ms
→ ~1,600 requêtes
→ Temps d'exécution: 30-60 secondes
→ Nécessaire pour la convergence
```

## 🔄 Interaction avec les autres paramètres

### Changement de λ

```
Avant: λ = 0.008, temps = 100,000 ms → ~800 requêtes
Après:  λ = 0.012, temps = 100,000 ms → ~1,200 requêtes
```

Le nombre de requêtes se recalcule automatiquement!

### Changement d'unité [ms] ↔ [s]

```
Mode [ms]: 100000 ms → ~800 requêtes
Mode [s]:  100.0 s   → ~800 requêtes (même valeur!)
```

La conversion est automatique et transparente.

## 📋 Récapitulatif

| Aspect | Détail |
|--------|--------|
| **Valeur par défaut** | 100,000 ms |
| **Unité affichée** | ms ou s (selon sélecteur) |
| **Stockage interne** | Toujours en ms |
| **Calcul automatique** | Nombre de requêtes = λ × temps |
| **Warmup** | 10,000 ms (automatique) |
| **Minimum recommandé** | 50,000 ms (400 requêtes) |
| **Standard TP** | 100,000 ms (800 requêtes) |
| **Haute précision** | 200,000+ ms (1,600+ requêtes) |

## ✅ Avantages de cette approche

1. **Contrôle précis**: Vous choisissez exactement la durée
2. **Indépendant de λ**: Change λ sans recalculer le temps
3. **Calcul automatique**: Nombre de requêtes affiché en temps réel
4. **Adaptatif**: S'adapte au sélecteur [ms]/[s]
5. **Standard académique**: Approche utilisée dans les simulateurs professionnels

## 🚀 Workflow recommandé

1. **Configurez vos paramètres** (λ, μ, p, q)
2. **Vérifiez la stabilité** (p + Σq = 1, ρ < 1 pour toutes les files)
3. **Ajustez le temps de simulation** selon ρ max
4. **Lancez la simulation**
5. **Vérifiez la convergence** dans les graphiques
6. **Augmentez le temps** si nécessaire

---

**Le champ "Temps de simulation" vous donne un contrôle total sur la précision de vos résultats!** 🎯