# Résumé (executive summary)  
Le **calendrier lunaire de jardinage** se base sur les cycles astronomiques de la Lune pour répartir les travaux (semis, plantations, récoltes) en «jours racine/feuille/fleur/fruit» et selon la **montée/descente de la sève**. Cette méthode traditionnelle, reprise par l’agriculture biodynamique, prétend optimiser la croissance. Toutefois, des sources scientifiques avertissent qu’**aucune influence directe mesurable** n’a été démontrée【6†L373-L381】【5†L108-L116】. Malgré tout, le calendrier lunaire sert souvent de repère pratique pour planifier les travaux. Ce document explique les concepts astronomiques (phases, illumination, etc.), leur calcul en Python (avec *skyfield*), et leur traduction en règles de jardinage, tout en restant critique et rigoureux.  

## Concepts astronomiques clés  
1. **Phases de la Lune** : La phase lunaire se définit par l’angle entre la Lune et le Soleil vus depuis la Terre, mesuré le long de l’écliptique. En pratique, on calcule la différence de longitude écliptique Soleil–Lune【14†L123-L131】. Ce résultat vaut 0° (Nouvelle Lune), ≈90° (Premier Quartier), ≈180° (Pleine Lune) ou ≈270° (Dernier Quartier) modulo 360°【14†L123-L131】.  
   La **fraction illuminée** (illumination) peut être obtenue à partir de l’angle de phase : si θ est la séparation géocentrique Soleil–Lune (en radians), alors l’illumination ≈ (1–cosθ)/2. (Skyfield propose aussi `m.fraction_illuminated(sun)` pour obtenir directement ce pourcentage.)  

2. **Lune montante / descendante** : Traditionnellement, on dit «lune montante» quand la Lune «monte» dans le ciel, c’est-à-dire que sa déclinaison géocentrique augmente au fil du jour. En pratique, on calcule la déclinaison (angle au‑dessus du plan équatorial) pour midi d’un jour et du lendemain : si la déclinaison augmente, on est en **période montante**, sinon descendante. La montée (ou descente) de la Lune coïncide grosso modo avec le flux de sève vers le haut (ou le bas) dans les plantes.

3. **Longitude écliptique et signes zodiacaux** : La position de la Lune dans le **zodiaque** (son signe astrologique) se déduit de sa longitude écliptique : on divise l’écliptique (360°) en 12 signes de 30°. Par exemple, Taureau (30°–60°), Gémeaux (60°–90°), etc. Chaque signe est associé à un élément (Terre, Eau, Air, Feu) selon la tradition agricole. On définit alors les **jours «racine/feuille/fleur/fruit»** :  
   - **Racine** : signes de Terre (Taureau, Vierge, Capricorne) – favorise légumes racines.  
   - **Feuille** : signes d’Eau (Cancer, Scorpion, Poissons) – favorise feuillage (salades, épinards).  
   - **Fleur** : signes d’Air (Gémeaux, Balance, Verseau) – favorise floraison et plantes ornementales.  
   - **Fruit** : signes de Feu (Bélier, Lion, Sagittaire) – favorise légumes-fruits (tomates, haricots)【24†L44-L53】.  

4. **Périgée et apogée** : La Lune suit une orbite elliptique (période anomalistique ≈ 27.55 j). Le **périgée** est le point où la Lune est la plus proche de la Terre, l’**apogée** le plus éloigné【18†L108-L112】. Chaque lunaison comporte un périgée et un apogée. On peut les repérer en cherchant les minima/maxima locaux de la distance Terre–Lune jour par jour. La tradition conseille d’**éviter** ces jours (trop d’énergie au périgée, croissance ralentie à l’apogée)【24†L66-L73】.  

5. **Nœuds lunaires** : Ce sont les deux points où l’orbite lunaire coupe l’écliptique (plan de l’orbite terrestre)【16†L155-L163】. Les nœuds correspondent aux périodes d’éclipses (noeud ascendant/descendant). Traditionnellement, on considère ces jours comme «perturbés» et on déconseille le jardinage【24†L66-L73】.

**Calculs utilisés (Skyfield)** : Le script Python charge l’éphéméride NASA DE421 pour Soleil, Terre, Lune. Il utilise `almanac.find_discrete` pour les **phases exactes** et les **nœuds**. Pour chaque jour (heure de référence = midi locale Europe/Paris), on calcule : l’illumination (via la séparation Soleil-Lune), la variation de déclinaison (montante/descendante), la longitude écliptique (pour le signe). Le code exemple montre :  

```python
# Phases exactes
f_phase = almanac.moon_phases(eph)
times, events = almanac.find_discrete(t0, t1, f_phase)
for t, ev in zip(times, events):
    local_day = t.utc_datetime().astimezone(TZ).date()
    phase_by_day[local_day] = ["Nouvelle Lune","1er Quart.","Pleine L.","Dernier Quart."][ev]
```
Cela enregistre l’événement de phase (le jour local de NL/Ple/Q1/Q3).  

```python
# Illumination et montante/descendante
e = earth.at(t); v_sun = e.observe(sun).apparent(); v_moon = e.observe(moon).apparent()
sep = v_sun.separation_from(v_moon).radians
illum = (1 - math.cos(sep)) / 2  # fraction éclairée
illum2 = (1 - math.cos(v_sun2.separation_from(v_moon2).radians)) / 2
croissante = "Croissante" if illum2 >= illum else "Décroissante"

dec = v_moon.radec()[1].degrees
dec2 = v_moon2.radec()[1].degrees
montante = "Montante" if dec2 >= dec else "Descendante"
```
On compare l’illumination et la déclinaison d’un jour à ceux du lendemain pour décider «croissante/décroissante» et «montante/descendante».  

```python
# Signe zodiacal (longitude écliptique)
lat, lon, dist = v_moon.ecliptic_latlon()
signe = SIGN_NAMES[int(lon.degrees // 30)]
type_jour = SIGN_TO_TYPE[signe]  # "Racine"/"Feuille"/"Fleur"/"Fruit"
```
Cela associe chaque jour à un «type de jour» agricole selon le signe (Taureau→Racine, etc【24†L44-L53】).  

Le calcul du **périgée/apogée** se fait manuellement : on mesure la distance Terre-Lune à midi chaque jour, puis on repère les minima/maxima locaux (via comparaison avec le jour précédent/suivant) pour marquer périgée et apogée. Ce choix manuel évite l’API `almanac.moon_distance` obsolète, tout en restant suffisant pour le jardinage (un point extrême par lunaison).  

## Liens avec le jardinage  
Les cycles ci-dessus se traduisent en règles traditionnelles (non vérifiées scientifiquement【6†L373-L381】) :  

- **Lune montante** : la sève monte, donc on **sème et récolte** (plantes aériennes, légumes-fruits)【7†L208-L214】【20†L24-L32】.  
- **Lune descendante** : la sève descend, donc on **plante, repique, taille, travaille le sol** (consolidation racinaire)【7†L208-L214】【20†L24-L32】.  
- **Croissante vs décroissante** : complément à montante/descendante. La lune croissante favorise les tiges/feuilles/fruits, la décroissante les racines【7†L208-L214】【20†L24-L32】.  
- **Jours racine/feuille/fleur/fruit** : selon le signe zodiacal, on privilégie les cultures correspondantes【24†L44-L53】 (par ex. Taureau/Vierge/Capricorne = légumes racines, Cancer/Scorpion/Poissons = salades et choux, Gémeaux/Balance/Verseau = fleurs, Bélier/Lion/Sagittaire = tomates et haricots).  
- **Éviter certains jours** : tradition recommande de ne rien faire lors des **nœuds lunaires, du périgée et de l’apogée**【24†L66-L73】. Par exemple, on évite semer au périgée (supposé trop d’énergie) et en période d’éclipse (nœuds)【22†L66-L73】.  

En résumé, on obtiendrait un tableau synthétique :  

| **Cycle lunaire**          | **Action jardin**                         | **Exemple**          |
|---------------------------|------------------------------------------|----------------------|
| Phase croissante          | Développement aérien (semis, greffe)     | Semis de tomates au 1er quartier【7†L208-L214】  |
| Phase décroissante        | Consolidation racinaire (plantation)     | Repiquage en lune descendante【7†L208-L214】     |
| Lune montante (ascendante)| Semis et récoltes (au-dessus du sol)      | Semer haricots en lune montante【7†L208-L214】   |
| Lune descendante          | Planter, tailler, travailler le sol       | Planter pommes de terre en lune descendante【7†L208-L214】 |
| Jour **Racine** (signe Terre)  | Légumes-racines (carottes, betteraves)    | Semez carottes (Lune en Vierge)【24†L44-L53】    |
| Jour **Feuille** (signe Eau)   | Feuillage (salades, épinards)             | Semez laitues (Lune en Cancer)【24†L44-L53】     |
| Jour **Fleur** (signe Air)     | Fleurs, plantes ornementales             | Repiquer vivaces (Lune en Gémeaux)【24†L50-L53】 |
| Jour **Fruit** (signe Feu)     | Légumes-fruits (tomates, haricots)       | Semis tomates (Lune en Lion)【24†L52-L55】      |
| **Nœuds lunaires**        | **Éviter le jardinage** (énergies perturbées) | 18+ mars (noeuds)【22†L66-L73】        |
| **Périgée / Apogée**      | **Éviter ou prudence** (croissance ralentie ou maladies) | Ex.: 25 mars (périgée)【22†L69-L73】    |

Ces recommandations proviennent de la tradition jardinière et sont souvent condensées dans des calendriers lunaires grand public【24†L44-L53】【22†L66-L73】.  

## Script Python : structure et explications  
Le script `lunar_calendar.py` donné utilise **Skyfield** pour la précision astronomique. Principaux points techniques :  
- **Dépendances** : `skyfield`, `pytz`, `numpy`. Le fichier d’éphémérides `de421.bsp` (NASA) couvre jusqu’en 2050 environ.  
- **Fuseau horaire** : on fixe l’heure locale «midi à Paris» pour chaque jour, afin de ne pas rater un changement de date à l’UTC. On convertit en UTC pour l’analyse Skyfield (voir `TZ.localize(datetime(...)).astimezone(pytz.utc)`).  
- **Phases exactes** : on utilise `almanac.moon_phases(eph)` et `find_discrete(t0,t1,f_phase)` pour obtenir les instants (UTC) des quatre phases principales. On associe ensuite la date locale correspondante :  

  ```python
  f_phase = almanac.moon_phases(eph)
  phase_times, phase_events = almanac.find_discrete(t0, t1, f_phase)
  phase_by_day = {}
  for t, ev in zip(phase_times, phase_events):
      local_day = t.utc_datetime().astimezone(TZ).date()
      phase_by_day[local_day] = ["Nouvelle Lune","Premier Quartier","Pleine Lune","Dernier Quartier"][int(ev)]
  ```
  Cette méthode assure la précision astronomique des phases (décalage horaire et lieux pris en compte).  

- **Illumination (pour «croissante/décroissante»)** : on calcule à midi la fraction illuminée de la Lune par rapport au Soleil vu de la Terre. La séparation angulaire géocentrique Lune–Soleil (radians) donne l’illumination via `(1 - cos(sep))/2`. On compare cette fraction au jour suivant pour déterminer si la Lune croît ou décroît.  

- **Montante/descendante** : on récupère la déclinaison géocentrique de la Lune (`v_moon.radec()[1].degrees`) pour deux jours consécutifs. Si elle augmente, on est en période «montante», sinon «descendante».  

- **Longitude écliptique (signe)** : Skyfield fournit la longitude écliptique (`v_moon.ecliptic_latlon()`). La division par 30° détermine le signe zodiacal (0=Bélier, 30=Taureau, etc.). On mappe ensuite le signe au type de jour (racine/feuille/fleur/fruit) via une table (comme vu ci-dessus【24†L44-L53】).  

- **Périgée/Apogée manuels** : comme la fonction `almanac.moon_distance` n’existait plus, on calcule la distance Terre–Lune chaque jour à midi. On parcourt ce tableau de distances pour repérer les minima locaux (périgée) et maxima locaux (apogée). C’est une approximation suffisante pour marquer environ un périgée et un apogée par mois.  

**Limites et précisions** :  
- L’algorithme suppose un calcul quotidien à midi : il peut ne pas être précis à l’heure, mais on obtient les bons jours. Pour une précision à l’heure près (rarement nécessaire pour le jardinage), on pourrait affiner la recherche d’événements.  
- Le fuseau Europe/Paris est appliqué partout pour obtenir la date locale. En hiver comme en été, on fixe à midi (CET ou CEST).  
- Les **jours racine/feuille/fleur/fruit** sont purement conventionnels (astrologiques)【24†L44-L53】. Le choix des signes et l’attribution aux «éléments» viennent de la tradition, pas de l’astronomie. D’autres écoles pourraient varier légèrement ces mappings.  
- Le script génère un JSON/CSV qui inclut, pour chaque date : phase, %illumination, status croissante/descroissante et montante/descendante, signe zodiacal et type de jour, périgée/apogée, nœud lunaire.  

Extrait du fichier JSON produit (format JSON compatible API) :  
```json
{
  "date": "2026-03-14",
  "phase": "",
  "illumination": 67.34,
  "croissante_decroissante": "Croissante",
  "montante_descendante": "Montante",
  "signe": "Taureau",
  "type_jour": "Racine",
  "perigee": false,
  "apogee": false,
  "noeud_lunaire": false
}
```

## Installation et test  
1. **Prérequis** : Python 3.9+ installé (nous avons testé sur Python 3.13). Ouvrir un terminal.  
2. **Environnement virtuel** (recommandé) :  
   ```bash
   python3 -m venv .venv  
   source .venv/bin/activate
   ```  
3. **Installer dépendances** :  
   ```bash
   pip install --upgrade pip  
   pip install skyfield numpy pytz
   ```  
4. **Vérifier** que `lunar_calendar.py` se trouve dans le dossier de travail.  
5. **Lancer le script** :  
   ```bash
   python lunar_calendar.py
   ```  
   – Au premier lancement, Skyfield télécharge `de421.bsp`.  
   – Le script affiche «Calendrier lunaire généré» et crée `calendrier_lunaire_2026.json`.  
6. **Vérifier le contenu** :  
   ```bash
   head -n 5 calendrier_lunaire_2026.json
   ```  
   ou  
   ```bash
   cat calendrier_lunaire_2026.json | jq .   # (avec jq pour formatage)
   ```  

Si une erreur survient (par ex. `ModuleNotFoundError`), vérifier l’environnement virtuel et l’installation des librairies.  

## Exemples d’usage et formats de sortie  
- Le script, en l’état, génère un **JSON** (tableau d’objets journaliers) et peut être modifié pour produire du CSV.  
- Exemple CSV attendu (point-virgule séparateur) :  
  ```
  date;phase_exacte;croissante_décroissante;montante_descendante;signe;jour_plante
  2026-03-14;;Croissante;Montante;Taureau;Racine
  2026-03-15;Dernier Quartier;Décroissante;Descendante;Bélier;Fruit
  ...
  ```  
- Ce fichier JSON/CSV peut être importé dans une base (SQLite) ou exposé via une API (FastAPI) pour alimenter un frontend.  

## Améliorations possibles et pièges à éviter  
- **CLI ou paramètres** : ajouter des arguments (`--start YEAR-MON-DAY --end ...`) et `--output` pour rendre le script plus flexible.  
- **FastAPI / Backend** : intégrer le calcul dans un endpoint (par ex. `/api/lune/{year}`) pour générer le calendrier à la demande ou en consulter un pré-calculé.  
- **Base de données** : pré-calculer 5-10 ans et stocker dans SQLite pour accès rapide (partition par année).  
- **Gestion du fuseau et locales** : tester en CET/CEST pour prendre en compte DST. Éviter l’heure d’hiver/été mal appliquée.  
- **Front-end** : colorer le calendrier (ex. style Gruvbox : orangé=Racine, vert=Feuille, violet=Fleur, jaune=Fruit, rouge discret=Nœud). Rendre responsive (mobile/tablette).  
- **Documentation** : ajouter un README dans le dépôt GitHub, expliquer les conventions (zodiaque, type de jour) et référencer les sources.  
- **Précision** : pour du calcul horaire fin, on pourrait itérer en minutes autour de l’heure approximative, mais pour le jardinage, le jour suffit.  

## Références et lectures suggérées  
- **Documentation Skyfield** – exemples de calcul d’angles et phases【14†L123-L131】.  
- **Science et scepticisme** – Détecteur de rumeurs SciencePresse (2022) et SNHF (2020) concluent à l’absence d’effet mesurable de la Lune sur les plantes【5†L108-L116】【6†L373-L381】.  
- **Guides en français** – Semencemag (2025) explique l’usage pratique (jours racine/feuille/fleur/fruit, nœuds, apogée, périgée)【24†L44-L53】【22†L66-L73】. Rustica/Gerbeaud publient chaque mois des calendriers lunaires détaillés (ex. Gerbeaud, semis en «jour feuille, lune montante»【7†L93-L101】).  
- **Éphémérides officielles** – US Naval Observatory (phases et fraction illuminée)【10†L86-L94】, NASA HORIZONS, etc.  
- **Recherche astronomique** – pour approfondir : littérature sur l’orbite lunaire, astronomie du calendrier, mais aussi le rapport SNHF «Jardiner avec la lune : mythe ou réalité» pour le contexte.  

Ce document vise à guider à la fois les développeurs (algorithmes, code) et les jardiniers (règles pratiques). Il reste essentiel d’expérimenter et d’adapter les recommandations à son jardin : un bon sol, de l’eau et du soleil restent les facteurs clés du succès, plus que toute influence lunaire【6†L390-L394】【22†L75-L84】.