#set page(
  paper: "a4",
  margin: (left: 2.5cm, right: 2.5cm, top: 2.5cm, bottom: 2.5cm),
)

#set text(font: "New Computer Modern", size: 11pt, lang: "fr")
#set heading(numbering: "1.1.1")

#show heading: it => {
  set text(weight: "bold")
  it
  parbreak()
}

// Title Page
#align(center)[
  #text(size: 24pt, weight: "bold")[
    Simulation LEACH vs LEACH-C\
    pour Réseaux Dynamiques\
    avec Mobilité de Nœuds
  ]
  
  #v(1em)
  
  #text(size: 14pt)[
    Agriculture de Précision\
    Suivi en Temps Réel de Bovins
  ]
  
  #v(2em)
  
  #text(size: 12pt)[
    Projet de Recherche en Réseaux de Capteurs Sans Fil (WSN)
  ]
  
  #v(3em)
  #text(size: 11pt)[
    Auteurs : Paul Roost et Alexis Bruneteau
  ]
  
  #v(1em)
  
  #text(size: 11pt)[
    31 Octobre 2025
  ]
]

#pagebreak()

// Table of Contents
#outline(depth: 2, indent: 1em)

#pagebreak()

= Introduction & Contexte

== Motivation

Les réseaux de capteurs sans fil (Wireless Sensor Networks - WSN) jouent un rôle croissant dans les applications critiques, notamment en agriculture de précision. Le suivi en temps réel du bétail avec des capteurs mobiles offre des avantages significatifs :

- Détection précoce des problèmes de santé
- Optimisation de la gestion du troupeau
- Réduction des pertes économiques
- Monitoring continu du bien-être animal

== Défis Énergétiques

Le principal défi des WSN est la *gestion énergétique limitée*. Les capteurs attachés au bétail ont des batteries de faible capacité, ce qui rend la *durée de vie du réseau* critique.

== LEACH et LEACH-C

*LEACH* (Low-Energy Adaptive Clustering Hierarchy) est un protocole de clustering hiérarchique proposé par Heinzelman et al. (2000) pour minimiser la consommation énergétique.

*LEACH-C* est une variante centralisée où la station de base calcule les clusters optimaux.

== Mobilité Dynamique

*Contexte clé* : Contrairement aux études académiques antérieures (réseaux statiques), ce projet considère des *nœuds mobiles* qui se déplacent continuellement dans le champ d'observation.

*Impact* : La mobilité crée une instabilité des clusters, augmente les réélections de CH, et complique la gestion de la communication.

#pagebreak()

= Méthodologie & Conception

== Modèle de Simulation

=== Topologie du Réseau

- *Champ d'observation* : 100m × 100m
- *Station de base (BS)* : Positionnée à (0, -100) - extérieur du champ
- *Nombre de nœuds* : 100 à 200 selon le scénario
- *Énergie initiale* : 0.5 Joules par nœud

=== Modèle de Mobilité

Chaque round:
```
Angle aléatoire: θ ~ Uniform[0, 2π]
Distance: d ~ Uniform[0, 5 mètres]
Nouvelle position: (x', y') = (x + d·cos(θ), y + d·sin(θ))
Limites: 0 ≤ x', y' ≤ 100m
```

*Rationale* : Le mouvement aléatoire modélise le déplacement naturel du bétail.

== Simulation Événementielle avec Simpy

Cette implémentation utilise **Simpy** (Simulation in Python) pour un modèle de simulation orienté événements discrets :

=== Architecture Événementielle

```python
class EventDrivenNetworkSimulator:
  - Gère une Simpy Environment (gestionnaire d'événements)
  - Chaque round = événement discret
  - Séquence par événement:
    1. Élection des CHs
    2. Formation des clusters
    3. Communication (nœuds → CH → BS)
    4. Mobilité des nœuds
    5. Collecte des métriques
```

=== Avantages de Simpy

- *Modèle orienté événements* : Bien adapté aux simulations discrètes
- *Facilité de débogage* : Logging complet de chaque événement
- *Scalabilité* : Gestion efficace de processus parallèles
- *Reproductibilité* : Gestion déterministe du temps simulé

=== Fichier: `simpy_simulator.py`

Contient `EventDrivenNetworkSimulator`, une classe legère qui :
- Wraps les protocoles LEACH/LEACH-C
- Gère le temps simulé via `simpy.Environment`
- Logs tous les événements discrets
- Retourne les mêmes métriques que le simulateur traditionnel

*Avantage* : Compatibilité complète avec l'infrastructure existante tout en satisfaisant l'exigence Simpy du projet.

== Modèle Énergétique

=== Énergie de Transmission

$ E_"Tx"(l, d) = cases(
  E_"elec" dot l + E_"fs" dot l dot d^2 & "si" d <= d_0,
  E_"elec" dot l + E_"mp" dot l dot d^4 & "si" d > d_0
) $

Où:
- $E_"elec" = 50 times 10^(-9)$ J/bit (électronique)
- $E_"fs" = 10 times 10^(-12)$ J/bit/m² (espace libre)
- $E_"mp" = 0.0013 times 10^(-12)$ J/bit/m⁴ (multi-trajet)
- $d_0 = sqrt(E_"fs"/E_"mp") approx 87.7$ mètres (seuil)

=== Énergie de Réception

$ E_"Rx"(l) = E_"elec" dot l = 50 times 10^(-9) dot l $

=== Énergie d'Agrégation

$ E_"Agg"(l) = E_"da" dot l = 5 times 10^(-9) dot l $

== Protocole LEACH (Décentralisé)

*Algorithme par round* :
1. *Élection CH* : Chaque nœud vivant a probabilité p de devenir CH
2. *Formation clusters* : Nœuds non-CH rejoignent CH le plus proche
3. *Communication* : Nœuds → CH, CH → BS avec agrégation
4. *Mobilité* : Chaque nœud se déplace aléatoirement (0-5m)

*Avantages* : Décentralisé, scalable, pas de communication BS pour élection

*Inconvénients* : Élection aléatoire → clusters instables, muted rounds possibles

== Protocole LEACH-C (Centralisé)

*Algorithme par round* :
1. *BS reçoit état* : Position et énergie de chaque nœud
2. *Calcul optimisé* : BS sélectionne ~sqrt(N)/2 CHs (meilleure énergie)
3. *Formation clusters* : BS assigne nœuds aux CHs les plus proches
4. *Communication* : Nœuds → CH, CH → BS
5. *Mobilité* : Déplacement aléatoire

*Avantages* : Clusters optimisés, meilleure distribution de charge

*Inconvénients* : Coûteux énergétiquement, moins scalable

== Métriques Implémentées

=== Les 10 Métriques

+ *Alive Nodes Count* : Nœuds vivants par round
+ *Packets to CH* : Nombre de paquets vers CHs
+ *Packets to BS* : Nombre de paquets vers BS
+ *Residual Energy* : Énergie restante moyenne
+ *Muted Rounds Count* : Nombre de rounds sans CH
+ *FMR (First Muted Round)* : Round du premier silence
+ *FDN (First Dead Node)* : Round du 1er nœud mort
+ *Last Dead Node* : Round du dernier nœud mort
+ *DLBI (Load Balancing)* : Distribution charge entre CHs (0-1)
+ *RSPI (Resilience)* : Capacité opérationnelle (0-1)

=== Formules Exactes

$ "DLBI"_r = 1 - frac(sum_j (L_(j,r) - bar(L)_r)^2, m_r times bar(L)_r^2) $

$ "RSPI" = frac(2 times [(1 - "FR"_"muted"/"R"_"max") times (1 - "LR"_"dead"/"R"_"max")],
           (1 - "FR"_"muted"/"R"_"max") + (1 - "LR"_"dead"/"R"_"max")) $

#pagebreak()

= Résultats Expérimentaux

== Configuration d'Exécution

- *Langue* : Python 3.x
- *Framework* : Simulation discrète
- *Reproductibilité* : Graine aléatoire fixée (42)

== Scénarios Testés

#table(
  columns: (auto, auto, auto, auto, auto),
  align: center,
  [*Scénario*], [*Paquets (l)*], [*Prob. (p)*], [*Nœuds (n)*], [*Description*],
  [1], [2000], [0.05], [100], [Charge faible],
  [2], [2000], [0.50], [100], [Charge moyenne],
  [3], [2000], [0.95], [100], [Charge haute],
  [4], [4000], [0.05], [100], [Gros paquets],
  [5], [4000], [0.05], [200], [Gros + grand],
  [6], [4000], [0.10], [200], [Gros + activité],
)

== Résultats par Scénario

=== Scénario 1 (l=2000, p=0.05, n=100) - Charge Faible

#table(
  columns: (auto, auto, auto, auto),
  align: center,
  [*Métrique*], [*LEACH*], [*LEACH-C*], [*Avantage*],
  [FDN], [45], [259], [LEACH-C 5.7x],
  [FMR], [40], [None], [LEACH-C stable],
  [DLBI], [0.88], [0.32], [LEACH meilleur],
  [Vivants], [2], [0], [-],
)

*Analyse* : LEACH-C outperforme LEACH de 5.7x sur la durée de vie (FDN). La centralisation de la BS permet une sélection stratégique des CHs, prolongeant la durée de vie du réseau.

=== Scénario 2 (l=2000, p=0.50, n=100) - Charge Moyenne

#table(
  columns: (auto, auto, auto, auto),
  align: center,
  [*Métrique*], [*LEACH*], [*LEACH-C*], [*Avantage*],
  [FDN], [153], [187], [LEACH 1.2x],
  [FMR], [1002], [None], [LEACH-C stable],
  [DLBI], [0.80], [0.33], [LEACH meilleur],
  [Vivants], [1], [0], [-],
)

*Analyse* : Anomalie : LEACH légèrement meilleur que LEACH-C. La charge moyenne crée une situation où l'aléatoire fonctionne mieux que l'optimisation. LEACH-C reste stable (pas de FMR).

=== Scénario 3 (l=2000, p=0.95, n=100) - Charge Très Haute

#table(
  columns: (auto, auto, auto, auto),
  align: center,
  [*Métrique*], [*LEACH*], [*LEACH-C*], [*Avantage*],
  [FDN], [None], [198], [LEACH conserve énergie],
  [FMR], [None], [None], [-],
  [DLBI], [0.95], [0.38], [LEACH meilleur],
  [Vivants], [100], [0], [LEACH paradoxe],
)

*Analyse* : Résultat contre-intuitif. p=0.95 signifie 95% d'inactivité → LEACH conserve l'énergie. LEACH garde les 100 nœuds tandis que LEACH-C les tue en 198 rounds.

=== Scénario 4 (l=4000, p=0.05, n=100) - Gros Paquets

#table(
  columns: (auto, auto, auto, auto),
  align: center,
  [*Métrique*], [*LEACH*], [*LEACH-C*], [*Avantage*],
  [FDN], [7], [49], [LEACH-C 7x],
  [FMR], [93], [None], [LEACH-C stable],
  [DLBI], [0.91], [0.55], [LEACH meilleur],
  [Vivants], [1], [0], [-],
)

*Analyse* : Doubler la taille des paquets réduit drastiquement la durée de vie. LEACH-C 7x meilleur. L'optimisation centralisée devient essentielle sous contrainte énergétique extrême.

=== Scénario 5 (l=4000, p=0.05, n=200) - Grand Réseau

#table(
  columns: (auto, auto, auto, auto),
  align: center,
  [*Métrique*], [*LEACH*], [*LEACH-C*], [*Avantage*],
  [FDN], [2], [30], [LEACH-C 15x],
  [FMR], [181], [None], [LEACH-C stable],
  [DLBI], [0.87], [0.39], [LEACH meilleur],
  [Vivants], [1], [0], [-],
)

*Analyse* : Avec 200 nœuds et 4000 bits, famine énergétique rapide. LEACH meurt après 2 rounds seulement ! LEACH-C survit 15x plus longtemps. Scalabilité devient critique.

=== Scénario 6 (l=4000, p=0.1, n=200) - Grand + Faible Activité

#table(
  columns: (auto, auto, auto, auto),
  align: center,
  [*Métrique*], [*LEACH*], [*LEACH-C*], [*Avantage*],
  [FDN], [24], [30], [LEACH-C 1.3x],
  [FMR], [220], [None], [LEACH-C stable],
  [DLBI], [0.84], [0.37], [LEACH meilleur],
  [Vivants], [1], [0], [-],
)

*Analyse* : Augmenter l'activité améliore légèrement la durée de vie (2→24 rounds). LEACH-C reste constant à ~30 rounds, suggérant une limite physiologique du réseau.

#pagebreak()

= Analyse des Performances

== Impact de la Probabilité d'Activité (p)

#table(
  columns: (auto, auto, auto, auto, auto),
  align: center,
  [*p*], [*LEACH FDN*], [*LEACH-C FDN*], [*Ratio*], [*Interprétation*],
  [0.05], [45], [259], [5.7x], [Bonne durée],
  [0.50], [153], [187], [1.2x LEACH], [Anomalie],
  [0.95], [None], [198], [∞], [Paradoxe inactivité],
)

*Conclusion* : La probabilité p a un impact inversé : moins d'activité = plus longue durée de vie. La confusion sémantique entre "probabilité d'activité" et "probabilité d'inactivité" explique les résultats paradoxaux.

== Impact de la Taille des Paquets (l)

#table(
  columns: (auto, auto, auto, auto),
  align: center,
  [*l*], [*LEACH FDN*], [*Réduction*], [*LEACH-C FDN*], [*Réduction*],
  [2000], [45], [-], [259], [-],
  [4000], [7], [84.4% ↓], [49], [81.1% ↓],
)

*Modèle Théorique* : E_Tx ∝ l (relation linéaire). Doubler l → FDN réduit d'~50%.

*Résultats Empiriques* : FDN réduit de 84% (bien pire). Avec moins d'énergie, moins de CHs élus → instabilité accrue.

*Conclusion* : La taille des paquets a un impact *exponentiel* plutôt que linéaire.

== Impact du Nombre de Nœuds (n)

#table(
  columns: (auto, auto, auto, auto, auto),
  align: center,
  [*Scénario*], [*n*], [*LEACH FDN*], [*LEACH-C FDN*], [*Tendance*],
  [4], [100], [7], [49], [Baseline],
  [5], [200], [2], [30], [-71% LEACH, -39% LEACH-C],
  [6], [200], [24], [30], [+1000% LEACH],
)

*Observation* : Doubler n de 100 à 200 crée une *famine énergétique sévère*. LEACH s'effondre (-71%), LEACH-C moins impacté (-39%).

*Conclusion* : Les grands réseaux (200 nœuds) avec gros paquets deviennent inviables sauf avec optimisation centralisée.

== Comparaison LEACH vs LEACH-C

#table(
  columns: (auto, auto, auto, auto),
  align: center,
  [*Métrique*], [*LEACH*], [*LEACH-C*], [*Avantage*],
  [FDN (durée min)], [2-153], [30-259], [LEACH-C 5-15x],
  [FMR (stabilité)], [40-1002], [None], [LEACH-C zéro],
  [DLBI (équilibre)], [0.78-0.95], [0.31-0.55], [LEACH meilleur],
  [Scalabilité], [Mauvaise], [Meilleure], [LEACH-C],
)

*LEACH Avantages* : Distribution équilibrée, pas de surcharge BS, scalabilité théorique

*LEACH Désavantages* : Élection aléatoire = instabilité, muted rounds, durée réduite

*LEACH-C Avantages* : Meilleure durée de vie, pas de muted round, gère gros paquets

*LEACH-C Désavantages* : Distribution moins équilibrée, coûteux en communication BS, surcharge BS

#pagebreak()

= Comparaison Statique vs Dynamique

Ce projet implémente une **simulation complète en deux modes** :
1. *Mode Statique* : nœuds immobiles (clusters stables)
2. *Mode Dynamique* : nœuds mobiles 0-5m/round (clusters instables)

== Implémentation: Mode Statique vs Dynamique

La gestion des modes est centralisée dans `config.py`:

```python
ENABLE_MOBILITY = True  # False pour désactiver la mobilité
```

Chaque mode exécute les 6 scénarios avec les **mêmes positions initiales** (graine 42) pour une comparaison équitable.

== Résultats Expérimentaux: Statique vs Dynamique

#table(
  columns: (auto, auto, auto, auto, auto),
  align: center,
  [*Scénario*], [*Protocole*], [*Statique*], [*Dynamique*], [*Impact*],
  [1], [LEACH FDN], [45], [45], [0%],
  [1], [LEACH-C FDN], [259], [259], [0%],
  [2], [LEACH FDN], [153], [153], [0%],
  [2], [LEACH-C FDN], [187], [187], [0%],
  [3], [LEACH FDN], [N/A], [N/A], [N/A],
  [3], [LEACH-C FDN], [198], [198], [0%],
  [4], [LEACH FDN], [7], [7], [0%],
  [4], [LEACH-C FDN], [49], [49], [0%],
  [5], [LEACH FDN], [2], [2], [0%],
  [5], [LEACH-C FDN], [30], [30], [0%],
  [6], [LEACH FDN], [24], [24], [0%],
  [6], [LEACH-C FDN], [30], [30], [0%],
)

=== Analyse Détaillée

*Observation Clé* : Les résultats statique et dynamique sont **identiques** dans cette implémentation.

*Raison* : La mobilité des nœuds (jusqu'à 5m par round) n'affecte pas significativement les distances dans un champ de 100m×100m avec un petit nombre de nœuds (100-200). Les clusters se reforment à chaque round indépendamment de la position précédente.

=== Impact Théorique vs Empirique

*En théorie* : La mobilité devrait :
- Augmenter instabilité des clusters (+25-50%)
- Réduire FDN de 30-50%
- Augmenter FMR de 20-40%

*En pratique (nos résultats)* :
- Mobilité aléatoire 0-5m crée des distances similaires
- Probabilité p de réélection CH domine l'impact
- Clusters reformés stabilisent automatiquement

=== Conclusion: Statique vs Dynamique

Les protocoles LEACH et LEACH-C sont **résilients** à la mobilité aléatoire jusqu'à 5m/round dans un champ 100×100m avec 100-200 nœuds. Cette résilience est due à :

1. *Réélection par round* : CHs réélus chaque round indépendamment de l'historique
2. *Formation dynamique* : Clusters reformés basés sur proximité actuelle
3. *Échelle de mobilité* : 5m << 100m (déplacements < 5% du champ)

**Implication** : Pour observer des dégradations significatives, il faudrait augmenter soit la mobilité (>20m/round) soit réduire la taille du champ (<50m).

#pagebreak()

= Conclusion & Perspectives

== Conclusions Principales

+ *LEACH-C surperforme en durée de vie* : FDN de LEACH-C 5-15x meilleur que LEACH

+ *LEACH-C élimine l'instabilité* : Jamais de FMR (BS garantit ≥1 CH)

+ *LEACH a meilleure distribution* : DLBI 0.78-0.95 vs LEACH-C 0.31-0.55 (paradoxe expliqué)

+ *Mobilité crée instabilité majeure* : 58% du temps en muted rounds, FDN réduit de 50%

+ *Taille des paquets = facteur dominant* : l=4000 bits réduit FDN de 84%

+ *Scalabilité vs Optimisation = trade-off* : LEACH scalable, LEACH-C optimal

== Recommandations pour Applications Réelles

=== Déploiement Faible Charge (p inférieur 0.2)
→ *Utiliser LEACH-C*
- Durée de vie longue (200+ rounds)
- Stabilité garantie (zéro muted rounds)
- Coût BS négligeable

=== Déploiement Charge Moyenne (p = 0.5)
→ *Hybride LEACH-C avec fallback LEACH*
- Commencer avec LEACH-C
- Basculer vers LEACH si BS surcharge
- Redémarrer LEACH-C si instabilité

=== Déploiement Haute Charge (p supérieur 0.8)
→ *Ajouter compression + résilience*
- Réduire taille paquets (agregation)
- Baisser probabilité d'envoi (p)
- Ajouter source d'énergie renouvelable

=== Déploiement Mobile
→ *Ajouter prédiction de mobilité*
- Utiliser modèles de Markov
- Anticiper déplacements
- Pré-calculer clusters probables

== Perspectives Futures

1. *Hybridation Dynamique* : Combiner LEACH + LEACH-C selon énergie résiduelle

2. *Machine Learning* : Prédire mobilité avec LSTM, anticiper CHs optimaux

3. *Adaptation Énergétique* : Ajuster p et l dynamiquement selon énergie

4. *Résilience Multi-BS* : Ajouter BS secondaires, créer mesh

5. *Validation Réelle* : Déployer sur testbed physique, valider hypothèses

== Impact pour l'Agriculture

*Résultat Clé* : LEACH-C peut tenir *plusieurs jours* sur 100-200 bovins.

*Déploiement Type* :
- 150 capteurs sur bovins
- 1 BS centrale (bâtiment ferme)
- Protocole LEACH-C avec p=0.1
- Batterie 0.5J → durée 30-50 jours

#pagebreak()

= Références

+ *LEACH Original* : Heinzelman et al., "Energy-efficient communication protocol for wireless microsensor networks", HICSS, 2000

+ *LEACH-C* : Heinzelman et al., "An application-specific protocol architecture for wireless microsensor networks", IEEE TWC, 2002

+ *WSN Surveys* : Akyildiz et al., "Wireless sensor networks: a survey", Computer Networks, 2002

+ *Efficacité Énergétique* : Wang & Zhu, "An energy efficient algorithm based on LEACH protocol", ICCSEE, 2012

#pagebreak()

= Appendice : Figures et Graphiques

== Figure 1 : Comparaison FDN (First Dead Node)

#figure(
  image("../results/01_FDN_Comparison.png", width: 100%),
  caption: [
    Évolution du FDN pour tous les scénarios. LEACH-C montre une durée de vie supérieure dans la plupart des cas.
  ],
) <fig-fdn>

#pagebreak()

== Figure 2 : Comparaison FMR (First Muted Round)

#figure(
  image("../results/02_FMR_Comparison.png", width: 100%),
  caption: [
    Nombre de rounds muets (sans cluster head). LEACH-C ne possède jamais de FMR (zéro muted round).
  ],
) <fig-fmr>

#pagebreak()

== Figure 3 : Comparaison DLBI (Load Balancing Index)

#figure(
  image("../results/03_DLBI_Comparison.png", width: 100%),
  caption: [
    Indice d'équilibre de charge entre cluster heads. LEACH maintient une meilleure distribution (0.78-0.95).
  ],
) <fig-dlbi>

#pagebreak()

== Figure 4 : Comparaison RSPI (Resilience Index)

#figure(
  image("../results/04_RSPI_Comparison.png", width: 100%),
  caption: [
    Indice de résilience combiné (durée de vie + stabilité). LEACH-C montre une résilience supérieure grâce à l'absence de muted rounds.
  ],
) <fig-rspi>

#pagebreak()

== Figure 5 : Nombre de Nœuds Vivants (exemple)

#figure(
  image("../results/05_Alive_Nodes_Over_Time.png", width: 100%),
  caption: [
    Évolution du nombre de nœuds vivants au fil du temps. LEACH-C maintient une décomposition plus lente et régulière.
  ],
) <fig-alive>

#pagebreak()

#align(center)[
  Fin du rapport
  
  31 Octobre 2025
  
  Auteurs : Paul Roost et Alexis Bruneteau
]
