# 📝 Guide de Saisie des Paramètres

## 🎯 Deux Modes de Saisie

L'interface utilise maintenant **deux modes différents** pour faciliter la saisie:

### 1. λ (Lambda) - Taux Direct

**Champ:** "Taux d'arrivée externe (λ)"
**Unité:** req/ms (requêtes par milliseconde)
**Saisie:** Directe en taux

```
┌─────────────────────────────────────┐
│ Taux d'arrivée externe (λ)          │
│ ┌─────────────────────────────┐     │
│ │ 0.008                req/ms │     │
│ └─────────────────────────────┘     │
│ Requêtes par milliseconde (req/ms)  │
└─────────────────────────────────────┘
```

**Pourquoi en taux?**
- λ représente naturellement un taux (arrivées par unité de temps)
- Notation mathématique standard
- Cohérent avec les formules théoriques

### 2. μ (Mu) - Temps Moyen avec Conversion

**Champs:** "Temps moyen de service"
**Unité:** ms ou s (selon sélecteur)
**Saisie:** Temps moyen, converti automatiquement en taux

```
┌─────────────────────────────────────┐
│ Unité: [ms] s                       │
│                                     │
│ Temps moyen de service (1/μc)       │
│ ┌─────────────────────────────┐     │
│ │ 10                       ms │     │
│ └─────────────────────────────┘     │
│ En millisecondes                    │
└─────────────────────────────────────┘
```

**Pourquoi en temps?**
- Le sujet du TP parle en temps (10ms, 120ms, 240ms)
- Plus intuitif pour l'utilisateur
- Conversion automatique en taux en arrière-plan

## 📊 Table de Conversion

### Valeurs du Scénario 1

| Paramètre | Valeur du Sujet | À Saisir | Explication |
|-----------|----------------|----------|-------------|
| **λ** (arrivées) | 8 req/s | **0.008** req/ms | Taux direct |
| **μc** (coord.) | 10 ms | **10** ms | Temps moyen |
| **μ1** (serveur) | 120 ms | **120** ms | Temps moyen |

### Comment obtenir λ?

**Méthode 1:** À partir du nombre de requêtes par seconde
```
Sujet: "8 requêtes par seconde"
Conversion: 8 req/s = 8/1000 req/ms = 0.008 req/ms
À saisir: 0.008
```

**Méthode 2:** À partir du temps moyen entre arrivées
```
Sujet: "temps moyen entre arrivées = 125 ms"
Formule: λ = 1 / temps = 1 / 125 = 0.008 req/ms
À saisir: 0.008
```

**Méthode 3:** Utiliser le convertisseur
```
1. Ouvrir le convertisseur de temps
2. Entrer 125 ms (temps entre arrivées)
3. Noter que 125 ms = 0.125 s
4. Calculer: λ = 1 / 0.125 s = 8 req/s = 0.008 req/ms
```

## 🎓 Exemples Pratiques

### Scénario 1: Configuration Complète

**Données du sujet:**
- Arrivées: 8 req/s
- Coordinateur: 10 ms
- Serveur: 120 ms
- p = 0.5

**Saisie dans l'interface:**

```
┌──────────────────────────────────────────┐
│ Paramètres du réseau         [ms] s     │
├──────────────────────────────────────────┤
│ Taux d'arrivée externe (λ)               │
│ │ 0.008                     req/ms │    │ ← Taux direct
│                                          │
│ COORDINATEUR                             │
│ Temps moyen de service (1/μc)            │
│ │ 10                             ms │   │ ← Temps avec unité
│ Probabilité de sortie (p)                │
│ │ 0.5                               │   │
│                                          │
│ SERVEUR 1                                │
│ Temps moyen de service (1/μ1)            │
│ │ 120                            ms │   │ ← Temps avec unité
│ Probabilité de routage (q1)              │
│ │ 0.5                               │   │
└──────────────────────────────────────────┘
```

### Scénario 2: Variation de λ

**Objectif:** Tester différents taux d'arrivée

| Test | req/s | req/ms (à saisir) | Temps entre arrivées |
|------|-------|-------------------|----------------------|
| Faible charge | 4 | 0.004 | 250 ms |
| Charge normale | 8 | 0.008 | 125 ms |
| Forte charge | 12 | 0.012 | 83.3 ms |

**Saisie:** Changez uniquement λ (0.004, 0.008, 0.012)

## 🔄 Avec le Sélecteur d'Unité

Le sélecteur **[ms] [s]** affecte **SEULEMENT** les temps de service (μ), **PAS** λ.

### En mode [ms]
```
λ: 0.008 req/ms     ← Toujours en req/ms
μc: 10 ms           ← Temps en ms
μ1: 120 ms          ← Temps en ms
```

### En mode [s]
```
λ: 0.008 req/ms     ← TOUJOURS en req/ms (ne change pas!)
μc: 0.010 s         ← Temps en s
μ1: 0.120 s         ← Temps en s
```

**Important:** λ reste toujours en req/ms, seuls les μ changent d'unité!

## 💡 Astuces de Saisie

### Pour λ (lambda)

✅ **Recommandé:** Calculez à partir du sujet
```
"8 requêtes/seconde" → λ = 8/1000 = 0.008 req/ms
```

✅ **Alternative:** Utilisez la formule
```
"Temps entre arrivées = 125 ms" → λ = 1/125 = 0.008 req/ms
```

❌ **À éviter:** Confondre avec le temps
```
Ne PAS entrer 125 dans le champ λ!
```

### Pour μ (mu)

✅ **Recommandé:** Entrez directement le temps du sujet
```
"Coordinateur: 10 ms" → Entrer 10
"Serveur: 120 ms" → Entrer 120
```

✅ **Alternative:** Changez d'unité avec le sélecteur
```
Mode [ms]: Entrer 10
Mode [s]: Entrer 0.010
```

## 🧮 Formules de Référence

### Pour calculer λ

**À partir de req/s:**
```
λ (req/ms) = req/s ÷ 1000

Exemple: 8 req/s → 8 ÷ 1000 = 0.008 req/ms
```

**À partir du temps moyen:**
```
λ (req/ms) = 1 ÷ temps_moyen_ms

Exemple: 125 ms → 1 ÷ 125 = 0.008 req/ms
```

### Pour μ (automatique)

Le système calcule automatiquement:
```
μ (req/ms) = 1 ÷ temps_moyen_ms

Vous entrez: 10 ms
Système calcule: μc = 1/10 = 0.1 req/ms
```

## ✅ Validation

### Vérification λ

Pour vérifier que votre λ est correct:

```
Temps entre arrivées = 1 / λ

Exemple: λ = 0.008 req/ms
→ Temps = 1 / 0.008 = 125 ms ✓
```

### Vérification μ

Le système affiche le temps saisi:
```
Vous entrez: 120 ms
Système affiche: 120 ms
Système stocke: μ = 1/120 = 0.008333 req/ms
```

## 📋 Récapitulatif

| Paramètre | Unité affichée | Ce que vous saisissez | Exemple |
|-----------|----------------|----------------------|---------|
| **λ** | req/ms | Taux directement | 0.008 |
| **μc** | ms ou s | Temps moyen | 10 ms |
| **μi** | ms ou s | Temps moyen | 120 ms |
| **p** | - | Probabilité | 0.5 |
| **qi** | - | Probabilité | 0.25 |

## 🎯 Pour les 5 Scénarios du TP

### Valeurs de λ à utiliser

Tous les scénarios utilisent: **λ = 0.008 req/ms**
(Sauf scénario 5 où vous testez différentes valeurs)

### Valeurs de μ à utiliser

| Scénario | Coordinateur | Serveurs |
|----------|--------------|----------|
| 1 | 10 ms | 120 ms |
| 2 | 10 ms | 120 ms + 240 ms |
| 3 | 10 ms | 240 ms × 3 |
| 4 | 10 ms | 120 ms + 190 ms |
| 5 | 10 ms | Variable |

**Saisie directe:** Entrez ces valeurs telles quelles en mode [ms]!

---

**Résumé:** λ en taux, μ en temps. Simple et efficace! 🚀