diff --git a/src/openalea/archicrop/archicrop.py b/src/openalea/archicrop/archicrop.py
index 8043076..7a08720 100644
--- a/src/openalea/archicrop/archicrop.py
+++ b/src/openalea/archicrop/archicrop.py
@@ -47,7 +47,8 @@ def __init__(self,
                  plant_orientation=30,
                  reduction_factor=1,
                  daily_dynamics=None,
-                 inter_row=0.4):
+                 inter_row=0.4,
+                 max_nb_leaves=0):
         """
         Initialize a plant generated by ArchiCrop model.
 
@@ -131,6 +132,9 @@ def __init__(self,
 
         self.inter_row = inter_row
 
+        # CP added it
+        self.max_nb_leaves = max_nb_leaves
+
 
     def generate_potential_plant(self):
         """
@@ -170,7 +174,9 @@ def generate_potential_plant(self):
                         tiller_delay=self.tiller_delay,
                         tiller_angle=self.tiller_angle,
                         tropism_coefficient=self.tropism_coefficient,
-                        plant_orientation=self.plant_orientation)
+                        plant_orientation=self.plant_orientation,
+                        max_nb_leaves=self.max_nb_leaves,
+                        )
     
     def grow_plant(self, rate=False, distribution_function=demand_dist_bis):
         """
diff --git a/src/openalea/archicrop/cereal_plant.py b/src/openalea/archicrop/cereal_plant.py
index 2d80f99..ae489c7 100644
--- a/src/openalea/archicrop/cereal_plant.py
+++ b/src/openalea/archicrop/cereal_plant.py
@@ -286,7 +286,8 @@ def cereal(nb_phy, phyllochron, plastochron, stem_duration, leaf_duration,
             tropism_coefficient,
             plant_orientation=45,
             spiral=True,
-            classic=False):
+            classic=False,
+            max_nb_leaves=0):
     """
     Generate a MTG representation of cereals
 
@@ -317,6 +318,7 @@ def cereal(nb_phy, phyllochron, plastochron, stem_duration, leaf_duration,
     :param plant_orientation: float, orientation of the plant (in °)
     :param spiral: bool, whether the phyllotaxy is spiral or not
     :param classic: bool, whether to use the classic MTG interpreter or not
+    :param max_nb_leaves: int, max number of leaves to generate (for all axes), 0 for no limit
 
     Returns:
     :return: MTG, a geometric-based MTG representation of cereals
@@ -411,7 +413,7 @@ def cereal(nb_phy, phyllochron, plastochron, stem_duration, leaf_duration,
         axis: 
         [
             vid for vid in g.components(axis)
-            if g.node(vid).label.startswith("Leaf")
+            if g.label(vid).startswith("Leaf")
         ]
         for axis in axes
     }
@@ -425,7 +427,41 @@ def cereal(nb_phy, phyllochron, plastochron, stem_duration, leaf_duration,
         ]
         for axis in axes
     }
-    # total_nb_leaves = sum(nb_leaves_per_axis.values())
+    total_nb_leaves = sum(nb_leaves_per_axis.values())
+    if max_nb_leaves > 0 and total_nb_leaves > max_nb_leaves:
+        # remove leaves based on some criteria: 1. oldest to youngest, 2. lowest to highest, 3. higher order
+        leaves = [(axis, vid) for axis in axes for vid in leaves_per_axis[axis]]
+        leaf_age = dict()
+        start_tts = g.property('start_tt')
+        for lid in leaves:
+            vid = lid[1]
+            leaf_age.setdefault(start_tts[vid], []).append(lid)
+
+        ages = list(leaf_age.keys())
+        ages.sort()
+
+        count = total_nb_leaves - max_nb_leaves
+        remove_leaves = []
+        for _age in ages:
+            leaf_ids = leaf_age[_age]
+            n = len(leaf_ids)
+            if n >= count:
+                remove_leaves.extend(leaf_ids[:count])
+            else:
+                remove_leaves.extend(leaf_ids)
+            count -= n
+
+            if count <= 0:
+                break
+
+        print(f'Remove {len(remove_leaves)} vertices !!!')
+        for axis_id, leaf_id in remove_leaves:
+            g.remove_tree(leaf_id)
+            leaves_per_axis[axis_id].remove(leaf_id)
+            nb_leaves_per_axis[axis_id]-=1    
+
+        total_nb_leaves = sum(nb_leaves_per_axis.values())
+        assert(total_nb_leaves == max_nb_leaves)
 
     # Compute reduction factor for each axis (main axis: 1, tillers: reduction_factor^order)
     axis_factors = {
diff --git a/tutorials/figure_4_rice_mtg.ipynb b/tutorials/figure_4_rice_mtg.ipynb
new file mode 100644
index 0000000..822d98c
--- /dev/null
+++ b/tutorials/figure_4_rice_mtg.ipynb
@@ -0,0 +1,674 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "31e7c70c-f264-40d7-9287-4ae1f8b30979",
+   "metadata": {},
+   "source": [
+    "# ArchiCrop tutorial - Cereals"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf0852fd-8b75-4db8-b1b2-396dd7d93c1e",
+   "metadata": {},
+   "source": [
+    "This notebook is a tutorial for generating any cereal plant architecture using ArchiCrop. \n",
+    "\n",
+    "\n",
+    "Examples are given for sorghum, maize, wheat and rice."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fe31c5a6-c8c0-43c9-b623-bbc7e4573b11",
+   "metadata": {},
+   "source": [
+    "## 0. Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "7ba99dee-5c5b-41f6-b32a-85bc95be9544",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from __future__ import annotations\n",
+    "\n",
+    "import os\n",
+    "import sys\n",
+    "from pathlib import Path\n",
+    "from datetime import date\n",
+    "sys.path.append('../data')\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from openalea.widgets.plantgl import *  # noqa: F403\n",
+    "\n",
+    "from openalea.archicrop.archicrop import ArchiCrop\n",
+    "from openalea.archicrop.cereal_leaf import parametric_cereal_leaf\n",
+    "from openalea.archicrop.geometry import leaf_mesh, stem_mesh\n",
+    "from openalea.archicrop.display import build_scene, display_scene\n",
+    "from openalea.archicrop.stics_io import read_sti_file, read_xml_file\n",
+    "from openalea.plantgl.all import Color3, Material, Scene\n",
+    "\n",
+    "%gui qt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "68692878-1e3c-46ef-b436-2bc2ff221254",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "today_str = date.today().strftime(\"%Y-%m-%d\")\n",
+    "my_dir = Path(f\"simulations_ArchiCrop/{today_str}\")\n",
+    "os.makedirs(str(my_dir), exist_ok=True)\n",
+    "\n",
+    "m = Material(Color3(0,80,0))\n",
+    "\n",
+    "def save(name, species):\n",
+    "    Viewer.grids.setXYPlane(False)\n",
+    "    Viewer.grids.setYZPlane(False)\n",
+    "    Viewer.grids.setXZPlane(False)\n",
+    "    zero = (0,30,0)\n",
+    "    if name == 'leaf' or 'stem' or 'phytomer':\n",
+    "        if species == 'wheat' or 'rice':\n",
+    "            pos = (0,-100,80)\n",
+    "            tar = (0,0,20)\n",
+    "        else:\n",
+    "            pos = (0,-500,100)\n",
+    "            tar = (0,0,60)\n",
+    "        # Viewer.camera.set(zero, 0, 0)\n",
+    "        Viewer.camera.lookAt(pos, tar)\n",
+    "    elif name == 'axis' or 'plant':\n",
+    "        if species == 'wheat' or 'rice':\n",
+    "            pos = (0,-1000,100)\n",
+    "        else:\n",
+    "            pos = (0,-1200,200)\n",
+    "        # Viewer.camera.set(zero, 0, 0)\n",
+    "        Viewer.camera.lookAt(pos, (0,0,0))\n",
+    "    elif name == 'crop':\n",
+    "        pos = (0,-2000,-600)\n",
+    "        # Viewer.camera.set(zero, 0, 0)\n",
+    "        Viewer.camera.lookAt(pos, (0,0,0))\n",
+    "    # Viewer.frameGL.saveImage(f\"D:/PhD_Oriane/simulations_ArchiCrop/{today_str}/{species}_{name}.png\")\n",
+    "\n",
+    "def view(mesh, name, species):\n",
+    "    if isinstance(mesh, list):\n",
+    "        shape = [Shape(sp,m) for sp in mesh]\n",
+    "        # PlantGL(Scene(shape))\n",
+    "        Viewer.display(Scene(shape))\n",
+    "    else:\n",
+    "        shape = Shape(mesh,m)\n",
+    "        Viewer.display(shape)\n",
+    "    save(name, species)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c8cad4ae-0e0a-4693-a4ed-4494e9a3dbf3",
+   "metadata": {},
+   "source": [
+    "## 1. Set plant architectural parameters\n",
+    "\n",
+    "Set topological, geometrical and developmental parameters, in a range corresponding a given species, found in literature."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "fc27b380-3989-4cec-842c-ef92d36a4490",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from archi_dict import archi_sorghum, archi_maize, archi_wheat, archi_rice\n",
+    "\n",
+    "archi_species = {\"sorghum\": archi_sorghum, \"maize\": archi_maize, \"wheat\": archi_wheat, \"rice\": archi_rice}\n",
+    "species = \"rice\"\n",
+    "archi = archi_species[species]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "d92459b4-a91f-4c83-b597-f4df5d669552",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def params(species):\n",
+    "    stem_diameter = archi_species[species]['diam_base']\n",
+    "    stem_length = archi_species[species]['height'] / (archi_species[species]['nb_phy'] - 5)\n",
+    "    leaf_length = 70 if species == 'sorghum' else 80 if species == 'maize' else 30 if species == 'wheat' else 40 # if species == 'rice'\n",
+    "    insertion_angle = archi_species[species]['insertion_angle']\n",
+    "    scurv = archi_species[species]['scurv']\n",
+    "    curvature = archi_species[species]['curvature']\n",
+    "    wl = archi_species[species]['wl']\n",
+    "    stem_diameter = archi_species[species]['diam_base']\n",
+    "    stem_length = archi_species[species]['height'] / archi_species[species]['nb_phy']\n",
+    "    return stem_diameter, stem_length, leaf_length, insertion_angle, scurv, curvature, wl, stem_diameter, stem_length"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e376ffe8-ab2f-4322-a443-57bf69e399d4",
+   "metadata": {},
+   "source": [
+    "## 4. Plot 3D organs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "78b60aed-c920-406b-a1d4-45342b7f745c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def simple_leaf(leaf, leaf_length, wl, stem_diameter,  ratio=1):\n",
+    "    total_length = leaf_length\n",
+    "    lw_ratio = 1/wl\n",
+    "    L_shape = total_length\n",
+    "    Lw_shape = total_length / lw_ratio\n",
+    "    length = total_length * ratio\n",
+    "    s_base = 0.0\n",
+    "    s_top = 1.0\n",
+    "    return leaf_mesh(leaf, L_shape, Lw_shape, length, s_base, s_top, stem_diameter=stem_diameter)\n",
+    "\n",
+    "def a_leaf(species):   \n",
+    "    leaf = parametric_cereal_leaf(insertion_angle=insertion_angle, scurv=scurv, curvature=curvature, klig=0.6, swmax=0.55, f1=0.64, f2=0.92)\n",
+    "    mesh_leaf = simple_leaf(leaf, leaf_length, wl, stem_diameter) \n",
+    "    return mesh_leaf, \"leaf\"\n",
+    "\n",
+    "# for species in archi_species:\n",
+    "stem_diameter, stem_length, leaf_length, insertion_angle, scurv, curvature, wl, stem_diameter, stem_length = params(species)\n",
+    "mesh, name = a_leaf(species)\n",
+    "shape_leaf = Shape(mesh,m)\n",
+    "# PlantGL(shape_leaf)\n",
+    "view(mesh, name, species)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "69879395-3ca6-4f6e-ae93-b896a5cba89d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def a_stem(species):\n",
+    "    mesh_stem = stem_mesh(length=stem_length, visible_length=stem_length, stem_diameter=stem_diameter, classic=True)\n",
+    "    # shape_stem = Shape(mesh_stem,m)\n",
+    "    # PlantGL(shape_stem)\n",
+    "    return mesh_stem, \"stem\"\n",
+    "\n",
+    "# for species in archi_species:\n",
+    "stem_diameter, stem_length, leaf_length, insertion_angle, scurv, curvature, wl, stem_diameter, stem_length = params(species)\n",
+    "mesh, name = a_stem(species)\n",
+    "view(mesh, name, species)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66cfbd39-c61d-4f57-b259-157f3aa1f91c",
+   "metadata": {},
+   "source": [
+    "## 5. Plot 3D phytomers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "27441672-4f5c-4815-bcf2-754e1e46f311",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def a_phytomer(species):\n",
+    "    mesh = [Translated(0,0,0,a_stem(species)[0]),Translated(0,0,stem_length,a_leaf(species)[0])]\n",
+    "    # shape = [Shape(sp,m) for sp in s]\n",
+    "    # PlantGL(Scene(shape))\n",
+    "    return mesh, \"phytomer\"\n",
+    "\n",
+    "# for species in archi_species:\n",
+    "stem_diameter, stem_length, leaf_length, insertion_angle, scurv, curvature, wl, stem_diameter, stem_length = params(species)\n",
+    "mesh, name = a_phytomer(species)\n",
+    "view(mesh, name, species)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e38b7ffd-baef-43c4-bd84-ac42a59dd821",
+   "metadata": {},
+   "source": [
+    "## 6. Plot 3D stems"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "ab1faa84-6fca-4358-9fc2-312cd25f1fe1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# for species, archi in archi_species.items():\n",
+    "archi_stem = archi.copy()\n",
+    "archi_stem['nb_tillers'] = 0\n",
+    "archi_stem['leaf_area'] = archi['leaf_area'] / (archi['nb_tillers']+1) / archi['reduction_factor']\n",
+    "axis = ArchiCrop(**archi_stem)\n",
+    "axis.generate_potential_plant()\n",
+    "g_axis = axis.g\n",
+    "scene, _ = build_scene(g_axis, leaf_material = m, stem_material = m)\n",
+    "Viewer.display(scene)\n",
+    "save(name='axis', species=species)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3511cbd6-7cb1-49b6-ada8-568d9cdb0f40",
+   "metadata": {},
+   "source": [
+    "## 7. Plot 3D plants"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "09ca7584-8085-4e17-b494-674736b4f7a5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# for species, archi in archi_species.items():\n",
+    "archi['nb_tillers']=6\n",
+    "plant = ArchiCrop(**archi)\n",
+    "plant.generate_potential_plant()\n",
+    "g = plant.g\n",
+    "scene, _ = build_scene(g, leaf_material = m, stem_material = m)\n",
+    "# scene.add(Shape(Translated((leaf_length,0,0), Oriented(Vector3((0,1,0)), Vector3((-1,0,0)), Cylinder(radius=2, height=50))), Material(Color3((0,0,0)))))\n",
+    "Viewer.display(scene)\n",
+    "save(name='plant', species=species)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "fb9e2ad2-378c-4ec0-a448-5adeca5075a6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'nb_phy': 14,\n",
+       " 'nb_short_phy': 5,\n",
+       " 'short_phy_len': 3,\n",
+       " 'height': 110,\n",
+       " 'stem_q': 1,\n",
+       " 'diam_base': 1.0,\n",
+       " 'diam_top': 0.5,\n",
+       " 'leaf_area': 3000,\n",
+       " 'rmax': 0.78,\n",
+       " 'skew': 0.0001,\n",
+       " 'wl': 0.03,\n",
+       " 'klig': 0.6,\n",
+       " 'swmax': 0.55,\n",
+       " 'f1': 0.64,\n",
+       " 'f2': 0.92,\n",
+       " 'insertion_angle': 20,\n",
+       " 'scurv': 0.6,\n",
+       " 'curvature': 20,\n",
+       " 'phyllotactic_angle': 180,\n",
+       " 'phyllotactic_deviation': 90,\n",
+       " 'phyllochron': 60,\n",
+       " 'stem_duration': 1.6,\n",
+       " 'leaf_duration': 1.6,\n",
+       " 'nb_tillers': 6,\n",
+       " 'tiller_angle': 15,\n",
+       " 'tiller_delay': 1,\n",
+       " 'reduction_factor': 0.93,\n",
+       " 'tropism_coefficient': 0.12}"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "archi"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "6962e10a-81fa-4c9f-800a-546ed46261db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Export g and scene to disc...\n",
+    "#g.display()\n",
+    "from openalea.mtg.io import write_mtg\n",
+    "def save_mtg(g, scene):\n",
+    "    g.properties()['Id']={}\n",
+    "    ids = g.properties()['Id']\n",
+    "    for vid in g.vertices(): \n",
+    "        ids[vid]=vid\n",
+    "\n",
+    "    def bools(g):\n",
+    "        for p in ['is_green', 'grow', 'dead', 'senescence']:\n",
+    "            _prop = g.properties()[p]\n",
+    "            for vid in _prop:\n",
+    "                _prop[vid] = int(bool(_prop[vid]))\n",
+    "    \n",
+    "    bools(g)\n",
+    "    props = [\n",
+    "        ('Id','INT'),\n",
+    "     ('rank', 'INT'),\n",
+    "     ('length','REAL'),\n",
+    "     ('visible_length','REAL'),\n",
+    "     ('is_green','INT'),\n",
+    "     ('stem_diameter','REAL'),\n",
+    "     ('azimuth','REAL'),\n",
+    "     ('grow','INT'),\n",
+    "     ('age','REAL'),\n",
+    "     ('tiller_angle','REAL'),\n",
+    "     ('leaf_area','REAL'),\n",
+    "     ('visible_leaf_area','REAL'),\n",
+    "     ('senescent_area','REAL'),\n",
+    "     ('senescent_length','REAL'),\n",
+    "     ('shape_max_width','REAL'),\n",
+    "     ('dead','INT'),\n",
+    "     ('inclination','REAL'),\n",
+    "     ('senescence', 'INT')\n",
+    "    ] \n",
+    "\n",
+    "    mtg_lines=write_mtg(g, props)\n",
+    "    fn = my_dir / 'rice.mtg'\n",
+    "    if fn.exists():\n",
+    "        fn.unlink(missing_ok=True)\n",
+    "\n",
+    "    fn.write_text(mtg_lines)\n",
+    "    print(f'Write MTG in {str(fn)}')\n",
+    "\n",
+    "    for sh in scene:\n",
+    "        sh.setName(f'vid_{sh.id}')\n",
+    "\n",
+    "    fn = my_dir / 'rice.obj'\n",
+    "    if fn.exists():\n",
+    "        fn.unlink(missing_ok=True)\n",
+    "    scene.save(str(my_dir/'rice.obj'))\n",
+    "    \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fbae406b-d4a9-45d2-86ce-12586700e97a",
+   "metadata": {},
+   "source": [
+    "## 8. Plot 3D crops"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "c7a994b9-aab5-4794-adf2-b85eac5b154f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from openalea.archicrop.stand import agronomic_plot\n",
+    "import random\n",
+    "\n",
+    "density = {\"sorghum\": 5.4, \"maize\": 6, \"wheat\": 70, \"rice\": 20} # plants/m2\n",
+    "inter_row = {\"sorghum\": 0.8, \"maize\": 0.6, \"wheat\": 0.175, \"rice\": 0.1} # m\n",
+    "# for species, archi in archi_species.items():\n",
+    "plant = ArchiCrop(**archi)\n",
+    "plant.generate_potential_plant()\n",
+    "g = plant.g\n",
+    "nplants, positions, domain, domain_area, unit = agronomic_plot(length=3, width=3, density=density[species], inter_row=inter_row[species], noise=0.1)\n",
+    "scene, labels = build_scene(g, positions, orientation=[360*random.gauss(mu=0.0, sigma=1.0) for i in range(len(positions))], leaf_material=m, stem_material=m, senescence=False)\n",
+    "Viewer.display(scene)\n",
+    "save(name='crop', species=species)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "42f38485-e7b6-4c5e-a200-35e4789d2d15",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "b2873d59-416a-4f3f-b797-2d814c6eca77",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def logistic_curve_exact(S, N, k=10, x0=0.7):\n",
+    "    x = np.linspace(0, 1, N)\n",
+    "    \n",
+    "    y = 1 / (1 + np.exp(-k * (x - x0)))\n",
+    "    \n",
+    "    # normalize to [0, 1]\n",
+    "    y = (y - y[0]) / (y[-1] - y[0])\n",
+    "    \n",
+    "    return S * y\n",
+    "\n",
+    "N = 100\n",
+    "\n",
+    "la = logistic_curve_exact(S=archi['leaf_area'], N=N)\n",
+    "h = logistic_curve_exact(S=archi['height'], N=N)\n",
+    "\n",
+    "archi['leaf_area'] = archi['leaf_area'] * 1.5\n",
+    "archi['height'] = archi['height'] * 1.5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "ef773e5e-22e3-4b60-b633-733f7aecbcad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "emergence = 0\n",
+    "end_juv = np.argmax(la)/2\n",
+    "max_lai = np.argmax(la) \n",
+    "\n",
+    "T = (archi['nb_phy']-1)*60+60*1.6\n",
+    "tt = np.linspace(0, T, N)\n",
+    "\n",
+    "daily_dynamics = {\n",
+    "    i+1: {\n",
+    "        \"Date\": i+1,\n",
+    "        \"Thermal time\": tt[i],\n",
+    "        \"Thermal time increment\": tt[i]-tt[i-1] if i>0 else tt[i],\n",
+    "        \"Phenology\": (\n",
+    "            'germination' if i+1 < emergence else\n",
+    "            'juvenile' if emergence <= i+1 < end_juv else\n",
+    "            'exponential' if end_juv <= i+1 < max_lai else\n",
+    "            'repro'\n",
+    "        ),\n",
+    "        \"Plant leaf area\": la[i],  \n",
+    "        \"Leaf area increment\": la[i] - la[i-1] if i > 0 else la[i],\n",
+    "        \"Plant senescent leaf area\": 0, \n",
+    "        \"Senescent leaf area increment\": 0,\n",
+    "        \"Plant height\": h[i],\n",
+    "        \"Height increment\": h[i] - h[i-1] if i > 0 else h[i]\n",
+    "    }\n",
+    "    for i in range(N)\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "b48c4783-a2cd-433e-95a5-96da5cfa504f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rice = ArchiCrop(\n",
+    "    daily_dynamics=daily_dynamics,\n",
+    "    **archi\n",
+    ")\n",
+    "rice.generate_potential_plant()\n",
+    "growing_rice = rice.grow_plant()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "17944b93-f84a-4026-8550-2aae50a37c16",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e7db3925a83e4879afab43003a5444f7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Plot(antialias=3, axes=['x', 'y', 'z'], axes_helper=1.0, axes_helper_colors=[16711680, 65280, 255], background…"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "times = [cum for i, cum in enumerate(tt) if i%10==0]\n",
+    "mean_time = sum(times) / len(times)\n",
+    "\n",
+    "positions = [(0, 0.5 * (t - mean_time), 0) for t in times]\n",
+    "\n",
+    "nice_green = Color3((30, 80, 0))\n",
+    "scene, _ = build_scene([g for i,g in enumerate(list(growing_rice.values())) if i%10==0], position=positions, senescence=True, leaf_material = Material(nice_green), stem_material=Material(nice_green))\n",
+    "PlantGL(scene)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "78be17c8-60f9-4c0d-9e67-bfa03bd3c072",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(2, 1, figsize=(12, 6), sharex=True)  # 1 row, 2 columns\n",
+    "\n",
+    "rh = [sum([vl \n",
+    "            for vid, vl in gp.properties()[\"visible_length\"].items() \n",
+    "            if gp.node(vid).label.startswith(\"Stem\")]) \n",
+    "            for gp in growing_rice.values()]\n",
+    "rla = [sum([vl \n",
+    "            for vid, vl in gp.properties()[\"visible_leaf_area\"].items()])\n",
+    "            for gp in growing_rice.values()]\n",
+    "\n",
+    "axes[0].plot(tt, rla,  color=\"green\", alpha=0.6)\n",
+    "axes[0].plot(tt, la, color=\"black\", alpha=0.1)\n",
+    "\n",
+    "axes[1].plot(tt, rh, color=\"orange\", alpha=0.6)\n",
+    "axes[1].plot(tt, h, color=\"black\", alpha=0.1)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "\n",
+    "# Show the plot\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "369730b0-24ca-4530-a641-a9f12138e283",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'nb_phy': 14,\n",
+       " 'nb_short_phy': 5,\n",
+       " 'short_phy_len': 3,\n",
+       " 'height': 110,\n",
+       " 'stem_q': 1,\n",
+       " 'diam_base': 1.0,\n",
+       " 'diam_top': 0.5,\n",
+       " 'leaf_area': 3000,\n",
+       " 'rmax': 0.78,\n",
+       " 'skew': 0.0001,\n",
+       " 'wl': 0.03,\n",
+       " 'klig': 0.6,\n",
+       " 'swmax': 0.55,\n",
+       " 'f1': 0.64,\n",
+       " 'f2': 0.92,\n",
+       " 'insertion_angle': 20,\n",
+       " 'scurv': 0.6,\n",
+       " 'curvature': 20,\n",
+       " 'phyllotactic_angle': 180,\n",
+       " 'phyllotactic_deviation': 90,\n",
+       " 'phyllochron': 60,\n",
+       " 'stem_duration': 1.6,\n",
+       " 'leaf_duration': 1.6,\n",
+       " 'nb_tillers': 19,\n",
+       " 'tiller_angle': 15,\n",
+       " 'tiller_delay': 1,\n",
+       " 'reduction_factor': 0.93,\n",
+       " 'tropism_coefficient': 0.12}"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "archi"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "381fd58b-6661-4ee1-aa16-a6bfa2db5983",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.13"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "state": {},
+    "version_major": 2,
+    "version_minor": 0
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tutorials/figure_4_wheat.ipynb b/tutorials/figure_4_wheat.ipynb
index a3471ee..ac00d9d 100644
--- a/tutorials/figure_4_wheat.ipynb
+++ b/tutorials/figure_4_wheat.ipynb
@@ -241,7 +241,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 11,
    "id": "ab1faa84-6fca-4358-9fc2-312cd25f1fe1",
    "metadata": {},
    "outputs": [],
@@ -268,7 +268,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 19,
    "id": "09ca7584-8085-4e17-b494-674736b4f7a5",
    "metadata": {},
    "outputs": [],
@@ -293,7 +293,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 21,
    "id": "c7a994b9-aab5-4794-adf2-b85eac5b154f",
    "metadata": {},
    "outputs": [],
@@ -308,26 +308,70 @@
     "plant.generate_potential_plant()\n",
     "g = plant.g\n",
     "nplants, positions, domain, domain_area, unit = agronomic_plot(length=3, width=3, density=density[species], inter_row=inter_row[species], noise=0.1)\n",
-    "scene, labels = build_scene(g, positions, orientation=[360*random.gauss() for i in range(len(positions))], leaf_material=m, stem_material=m, senescence=False)\n",
+    "scene, labels = build_scene(g, positions, orientation=[360*random.gauss(mu=0.0, sigma=1.0) for i in range(len(positions))], leaf_material=m, stem_material=m, senescence=False)\n",
     "Viewer.display(scene)\n",
     "save(name='crop', species=species)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "id": "42f38485-e7b6-4c5e-a200-35e4789d2d15",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'nb_phy': 10,\n",
+       " 'nb_short_phy': 5,\n",
+       " 'short_phy_len': 3,\n",
+       " 'height': 90,\n",
+       " 'stem_q': 1,\n",
+       " 'diam_base': 0.8,\n",
+       " 'diam_top': 0.3,\n",
+       " 'leaf_area': 1500,\n",
+       " 'rmax': 0.83,\n",
+       " 'skew': 0.001,\n",
+       " 'wl': 0.079,\n",
+       " 'klig': 0.6,\n",
+       " 'swmax': 0.55,\n",
+       " 'f1': 0.64,\n",
+       " 'f2': 0.92,\n",
+       " 'insertion_angle': 40,\n",
+       " 'scurv': 0.7,\n",
+       " 'curvature': 140,\n",
+       " 'phyllotactic_angle': 180,\n",
+       " 'phyllotactic_deviation': 90,\n",
+       " 'phyllochron': 40,\n",
+       " 'stem_duration': 1.6,\n",
+       " 'leaf_duration': 1.6,\n",
+       " 'nb_tillers': 6,\n",
+       " 'tiller_angle': 5,\n",
+       " 'tiller_delay': 1,\n",
+       " 'reduction_factor': 0.8,\n",
+       " 'tropism_coefficient': 0.12}"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "archi"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "id": "b2873d59-416a-4f3f-b797-2d814c6eca77",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "archi['scurv'] = 0.7\n",
+    "archi['curvature'] = 30\n",
+    "archi['insertion_angle'] = 15"
+   ]
   },
   {
    "cell_type": "code",
@@ -354,7 +398,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.13.11"
+   "version": "3.10.13"
   },
   "widgets": {
    "application/vnd.jupyter.widget-state+json": {