Reflets — Jumeau numérique de la BSPP

Reflets est un jumeau numérique de la Brigade des Sapeurs-Pompiers de Paris (BSPP). Le projet simule l'année opérationnelle 2023 (≈ 480 000 interventions, 267 véhicules, 72 centres de secours) puis optimise la répartition de la flotte (POMPE, VSAV, PSE) entre les centres pour différentes fonctions objectif. Projet de PSC (Projet Scientifique Collectif) à l'École Polytechnique en partenariat avec la BSPP.

📄 Rapport complet du PSC (PDF)

⚠️ Confidentialité des données BSPP. Aucune donnée opérationnelle de la BSPP n'est incluse dans ce dépôt :

• les interventions 2023 (parquet/CSV), les matrices de trajets et le découpage des secteurs ont été retirés,
• les allocations détaillées véhicule-par-véhicule (CSV par CS) ont également été retirées,
• seuls le code et les métriques agrégées (temps moyens, P95/P99, taux de couverture sur l'année complète) sont conservés.

Le format des données attendues est documenté plus bas pour permettre la lecture du code ; le repo n'est pas exécutable tel quel.

---

Aperçu

Simulation	Optimisation

Visualisation des allocations	Comparaison de politiques

Détail par centre de secours

---

Les trois briques

L'application est accessible depuis une interface Streamlit unifiée (interface.py) avec une navigation par pages.

1. Simulateur événementiel

Rejoue chronologiquement les interventions de 2023 sur une flotte de véhicules configurable. Pour chaque intervention :

• application des règles d'engagement (priorité au CS territorialement compétent — CSTC),
• recherche du véhicule disponible le plus proche en cas d'indisponibilité,
• gestion des durées (départ → trajet → traitement → retour) et de la remise en disponibilité,
• agrégation de métriques : temps moyen de réponse, P95, P99, taux de couverture < 8 min, manque local par CS.

Code : main.py, classes.py, filters.py, fonction_calcul_trajet.py.

2. Optimiseur GPU (PyTorch / CUDA)

Recherche par recuit simulé vectorisé de la meilleure allocation de la flotte entre les 72 CS.

• Simulation entièrement vectorisée sur GPU : ~10⁵ allocations évaluées en quelques minutes (vs. plusieurs heures sur CPU).
• Recuit simulé parallèle avec batches de plusieurs milliers de configurations simultanées.
• Plusieurs fonctions objectif disponibles : temps moyen, P95 / P99 VSAV, score composite, équité par pression (écart-type des Q95 normalisés).
• Fleet sweep : balayage de la taille de flotte pour étudier la sensibilité.

Code : Reflets_gpu/ — voir notamment gpu_simulator.py (simulation vectorisée), gpu_optimizer.py (recuit simulé), run_gpu_optim.py (entrée principale), run_fleet_sweep.py.

3. Comparaison de politiques

Pages Streamlit pour visualiser les allocations optimisées :

• pages/2_Optimisation.py — lancement et suivi.
• pages/3_Visualisation_resultat.py — détail d'une allocation (carte + métriques par CS).
• pages/4_Comparaison_politiques.py — comparaison côte-à-côte de plusieurs politiques (allocation initiale vs. différents objectifs optimisés).

Résultats

Les métriques avant/après de chaque optimisation sont stockées dans Reflets_gpu/results/ (fichiers allocation_<metric>_optimale.json), simulées sur l'année 2023 complète (478 063 interventions). Les CSV d'allocation détaillée véhicule-par-véhicule, qui révèlent la distribution opérationnelle de la flotte BSPP par CS, ne sont pas inclus.

Quelques chiffres sur la flotte 2023 (267 véhicules, 72 CS) :

Politique	Temps moyen VSAV	P95 VSAV	P99 VSAV	Couverture < 8 min	Véhicules déplacés
Initiale (référence)	530.7 s	868 s	1049 s	42.2 %	—
Optim temps moyen	521.6 s (−9 s)	830 s	1003 s	42.6 %	32
Optim P95 VSAV	527.6 s	823 s (−45 s)	989 s	40.7 %	46
Optim P99 VSAV	533.9 s	832 s	980 s (−69 s)	39.7 %	48
Optim composite	522.8 s	843 s	1019 s	42.9 %	30

Lecture : chaque optimisation cible un objectif différent et améliore principalement la métrique correspondante, parfois au prix d'un léger recul sur les autres. La comparaison interactive est disponible dans la page Comparaison de politiques.

Architecture

.
├── interface.py              # Page d'accueil Streamlit (paramètres + simulation)
├── pages/
│   ├── 2_Optimisation.py
│   ├── 3_Visualisation_resultat.py
│   └── 4_Comparaison_politiques.py
│
├── main.py                   # Boucle de simulation événementielle
├── classes.py                # Modèle métier (Engin, Intervention, Secteur, …)
├── data.py                   # Chargement des données
├── filters.py                # Règles d'attribution des véhicules
├── fonction_calcul_trajet.py # Estimation des temps de trajet
│
├── optimisation/             # Optimiseur CPU (legacy, recuit simulé)
├── Reflets_gpu/              # Optimiseur GPU (PyTorch) — version utilisée
│   ├── gpu_simulator.py      # Simulation vectorisée GPU
│   ├── gpu_optimizer.py      # Recuit simulé GPU
│   ├── run_gpu_optim.py
│   ├── run_fleet_sweep.py
│   └── results/              # Allocations optimales + métriques avant/après
│
├── ui/                       # Helpers Streamlit
├── docs/DOCUMENTATION.md     # Documentation technique détaillée
└── rapport.pdf               # Rapport final du PSC

Stack

• Python 3.13
• PyTorch (CUDA) — simulation et optimisation vectorisées sur GPU
• Streamlit — interface web
• GeoPandas / Shapely / pyproj — géométrie des secteurs
• Folium — cartographie interactive
• Pandas / NumPy / Scipy — traitement
• Matplotlib / Plotly / Seaborn — visualisation

Installation

git clone https://github.com/baptisteduperray/Reflets.git
cd Reflets

python -m venv venv
# Windows :   venv\Scripts\activate
# Linux/Mac : source venv/bin/activate

pip install -r requirements.txt

Lancement

Une fois les données fournies sous datas/ (voir section suivante) :

# interface Streamlit complète
streamlit run interface.py

# ou directement l'optimiseur GPU
python Reflets_gpu/run_gpu_optim.py --metric temps_moyen --n_batch 8192

Format des données attendues

Le code attend la structure suivante (non incluse dans le dépôt) :

datas/
├── interventions/
│   ├── inter_23_modifie.parquet   # interventions 2023 (selection, x, y,
│   │                              # x_final, y_final, traitement, depart,
│   │                              # trajet, retour, cstc, cs, proc, fem_mma, …)
│   └── cma_inter.csv              # IdMMASelection → identifiant intervention
├── geo/
│   └── secteurs_cs.geojson        # polygones des secteurs (EPSG:2154)
├── matrices/
│   ├── travel_matrix.npy          # matrice (N_inter, N_cs) des temps aller
│   └── return_travel_matrix.npy   # idem pour le retour
├── reseau/
│   ├── nodes.csv                  # nœuds du graphe routier
│   └── experiment_osm.csv         # arêtes annotées (temps OSM)
└── utils/
    └── liste_engins_finale.csv    # parc véhicules (type, CS de rattachement)

Détails (dtypes, unités, sémantique) dans docs/DOCUMENTATION.md.

Documents

• rapport.pdf — rapport final du PSC (modélisation, méthodologie, résultats).
• docs/DOCUMENTATION.md — documentation technique détaillée du code.

Mentions

• Projet Scientifique Collectif réalisé à l'École Polytechnique en partenariat avec la BSPP.
• Les données opérationnelles utilisées sont propriété de la BSPP et soumises à confidentialité.
• Ce dépôt expose uniquement le code et les résultats agrégés ; aucune donnée individuelle d'intervention n'y figure.