# Cariflex - EMS Operations Guide

> Guide d'opération du Energy Management System Cariflex

## 1. Architecture EMS

```
┌─────────────────────────────────────────────────────────────────────────────┐
│                              CARIFLEX EMS                                    │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                         DATA INGESTION                                │   │
│  │                                                                        │   │
│  │  Sources:                                                              │   │
│  │  • Cariflex Simulator (API REST, 30s interval)                        │   │
│  │  • MQTT Broker (cariflex-mqtt:1886)                                   │   │
│  │  • CitrineOS (OCPP 2.0.1)                                             │   │
│  │  • Weather API (Solcast)                                              │   │
│  │  • EPEX SPOT (Day-ahead prices)                                       │   │
│  │                                                                        │   │
│  │  Workers:                                                              │   │
│  │  • cariflex-ingestion (RQ worker)                                     │   │
│  │  • fm-worker-zedlkc (forecasting)                                     │   │
│  │  • 235f252af21e4b63b412dfd6016c72d8 (scheduling)                      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                              │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                          FORECASTING                                  │   │
│  │                                                                        │   │
│  │  Model: TrainPredictPipeline (autoregressive)                         │   │
│  │  Training window: 30 days                                              │   │
│  │  Prediction window: 24 hours                                           │   │
│  │  Resolution: 5 minutes                                                 │   │
│  │                                                                        │   │
│  │  Sensors:                                                              │   │
│  │  • PV (41-50): 82 forecasts each                                       │   │
│  │  • Battery (51-60): SOC forecasts                                      │   │
│  │  • EV Charger (61-70): Power forecasts                                 │   │
│  │  • EV (71-80): SOC forecasts                                           │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                              │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                           SCHEDULING                                  │   │
│  │                                                                        │   │
│  │  Scheduler: StorageScheduler                                           │   │
│  │  Optimization: Linear programming                                      │   │
│  │  Duration: 24 hours                                                    │   │
│  │  Resolution: 5 minutes                                                 │   │
│  │                                                                        │   │
│  │  Flex Model:                                                           │   │
│  │  • soc_min: 10 kWh (batteries), 15 kWh (EVs)                          │   │
│  │  • soc_max: 100 kWh (batteries), 75 kWh (EVs)                         │   │
│  │  • power_capacity: 50 kW (batteries), 11 kW (EVs)                     │   │
│  │  • charging_efficiency: 0.95                                           │   │
│  │  • discharging_efficiency: 0.95                                        │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────────────────┘
```

## 2. Opérations Quotidiennes

### 2.1 Démarrage des Services

```bash
# 1. Vérifier que FlexMeasures tourne
docker ps | grep flexmeasures

# 2. Vérifier que le worker RQ tourne
docker exec flexmeasures-worker ps aux | grep rq

# 3. Vérifier que le simulateur tourne
ps aux | grep cariflex_simulator

# 4. Vérifier les données en temps réel
docker exec flexmeasures-db psql -U flexmeasures -d flexmeasures -c "
SELECT MAX(event_start) FROM timed_belief;
"
```

### 2.2 Forecasting

```bash
# Générer les forecasts pour tous les capteurs PV
docker exec flexmeasures-server bash -c "
cd /app && for sensor in \$(seq 41 50); do
  .venv/bin/flexmeasures add forecasts --sensor \$sensor --to-date \$(date -u -d '+24 hours' +'%Y-%m-%dT%H:%M:%S+00:00')
done
"

# Vérifier les forecasts
docker exec flexmeasures-db psql -U flexmeasures -d flexmeasures -c "
SELECT COUNT(*) FROM timed_belief WHERE source_id IN (SELECT id FROM data_source WHERE name LIKE '%forecast%');
"
```

### 2.3 Scheduling

```bash
# Créer les schedules pour les batteries
bash /home/eric/cariflex/scripts/fm_scheduling.sh

# Vérifier les schedules
docker exec flexmeasures-db psql -U flexmeasures -d flexmeasures -c "
SELECT s.name, COUNT(t.id) as schedule_points
FROM sensor s
JOIN timed_belief t ON t.sensor_id = s.id
WHERE s.id BETWEEN 51 AND 60
  AND t.source_id IN (SELECT id FROM data_source WHERE name LIKE '%schedule%')
GROUP BY s.name;
"
```

### 2.4 Monitoring

```bash
# Vérifier les queues Redis
docker exec flexmeasures-redis redis-cli -a Digitribe972 SMEMBERS rq:workers

# Vérifier les logs du simulateur
tail -f /tmp/simulator.log

# Vérifier les logs du worker FM
docker logs -f flexmeasures-worker --tail 50
```

## 3. Commandes Utiles

### 3.1 Gestion des Workers

```bash
# Lancer un worker RQ pour l'ingestion
docker exec -d flexmeasures-worker bash -c "
cd /app && .venv/bin/flexmeasures jobs run-worker --queue ingestion --name cariflex-ingestion
"

# Lancer un worker RQ pour le forecasting
docker exec -d flexmeasures-worker bash -c "
cd /app && .venv/bin/flexmeasures jobs run-worker --queue forecasting --name cariflex-forecast
"

# Lancer un worker RQ pour le scheduling
docker exec -d flexmeasures-worker bash -c "
cd /app && .venv/bin/flexmeasures jobs run-worker --queue scheduling --name cariflex-scheduling
"
```

### 3.2 Gestion du Simulateur

```bash
# Démarrer le simulateur
bash /home/eric/cariflex/scripts/start_simulator.sh

# Arrêter le simulateur
pkill -f cariflex_simulator

# Vérifier le statut
ps aux | grep cariflex_simulator
```

### 3.3 Nettoyage

```bash
# Nettoyer les anciens workers RQ
docker exec flexmeasures-redis redis-cli -a Digitribe972 DEL rq:workers

# Nettoyer les anciennes données (plus de 30 jours)
docker exec flexmeasures-db psql -U flexmeasures -d flexmeasures -c "
DELETE FROM timed_belief WHERE event_start < NOW() - INTERVAL '30 days';
"
```

## 4. Métriques et KPIs

### 4.1 Données d'Ingestion
- **Fréquence** : 30 secondes
- **Capteurs** : 40 (10 PV, 10 Bat, 10 Chg, 10 EV)
- **Données/jour** : ~115,000 beliefs

### 4.2 Forecasting
- **Fréquence** : Quotidien (cron)
- **Horizon** : 24 heures
- **Résolution** : 5 minutes
- **Forecasts/jour** : 820 (82 per sensor × 10 sensors)

### 4.3 Scheduling
- **Fréquence** : Quotidien ou sur demande
- **Horizon** : 24 hours
- **Résolution** : 5 minutes
- **Schedules/jour** : 20 (10 batteries + 10 EVs)

## 5. Dépannage

### 5.1 Le simulateur n'envoie plus de données
```bash
# Vérifier le processus
ps aux | grep cariflex_simulator

# Redémarrer
pkill -f cariflex_simulator
bash /home/eric/cariflex/scripts/start_simulator.sh

# Vérifier les logs
tail -f /tmp/simulator.log
```

### 5.2 Le worker RQ ne traite pas les jobs
```bash
# Vérifier les workers
docker exec flexmeasures-redis redis-cli -a Digitribe972 SMEMBERS rq:workers

# Redémarrer le worker
docker exec -d flexmeasures-worker bash -c "
cd /app && .venv/bin/flexmeasures jobs run-worker --queue ingestion --name cariflex-ingestion
"
```

### 5.3 Les données ne s'affichent pas dans Grafana
```bash
# Vérifier la connexion DB
docker exec flexmeasures-db psql -U flexmeasures -d flexmeasures -c "SELECT 1;"

# Vérifier les données récentes
docker exec flexmeasures-db psql -U flexmeasures -d flexmeasures -c "
SELECT MAX(event_start) FROM timed_belief;
"

# Vérifier le datasource Grafana
curl -s -u admin:admin "http://localhost:3001/api/datasources" | python3 -m json.tool | head -20
```
