GroIMP wiki

part of grogra.de

User Tools

Site Tools

You are here: GroIMP documentation » 🎓 User tutorials » Exercises for M2BV » Sources, sinks and assimilate transport in a virtual plant
Trace:
02_user_tutorials:exercises:exercise:start

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
02_user_tutorials:exercises:exercise:start [2026/09/28 09:55] – barley196502_user_tutorials:exercises:exercise:start [2026/09/30 21:38] (current) – barley1965
Line 1: Line 1:
 ====== Sources, sinks and assimilate transport in a virtual plant ====== ====== Sources, sinks and assimilate transport in a virtual plant ======
  
-//Master 2, specialties "Seed Science and Plant Propagation" and "Plant Health". Duration: about 2 hours. Work in pairs.//+//Master 2 BV, specialties “SEPPRO&SPP” and “Santé des Plantes - PHP”. Duration: about 2 hours. You may work alone or in pairs.//
  
 ===== Learning objectives ===== ===== Learning objectives =====
Line 8: Line 8:
   * explain how a functional–structural plant model (FSPM) links **light interception → photosynthesis → transport → growth of sinks**;   * explain how a functional–structural plant model (FSPM) links **light interception → photosynthesis → transport → growth of sinks**;
   * identify, in real model code, where each of these processes is computed and which organs act as **sources** or **sinks**;   * identify, in real model code, where each of these processes is computed and which organs act as **sources** or **sinks**;
 +  * explain the difference between the **potential** growth of an organ and its **actual** growth when sugar is limiting;
   * run a model experiment rigorously: **predict, run, observe, explain**;   * run a model experiment rigorously: **predict, run, observe, explain**;
-  * modify the model to represent a situation from your own field (a pest or disease, or seed/fruit set);+  * modify the model to represent a situation from your own field (a pest or disease, or fruit and seed set);
   * critically judge what a model does and does not represent.   * critically judge what a model does and does not represent.
  
Line 17: Line 18:
  
 ^ Part ^ Content ^ Time ^ ^ Part ^ Content ^ Time ^
-| 0 | Setup: open and run the model | 10 min |+| 0 | Setup: open and start the model | 10 min |
 | 1 | The biology in brief | 10 min | | 1 | The biology in brief | 10 min |
 | 2 | The model at a glance | 15 min | | 2 | The model at a glance | 15 min |
-| 3 | Run and observe | 15 min |+| 3 | Observe the reference run | 15 min |
 | 4 | Reading the code: production, transport, use | 25 min | | 4 | Reading the code: production, transport, use | 25 min |
 | 5 | Virtual experiments | 25 min | | 5 | Virtual experiments | 25 min |
 | 6 | Your specialty: plant health **or** seed science | 15 min | | 6 | Your specialty: plant health **or** seed science | 15 min |
 | 7 | Synthesis | 5 min | | 7 | Synthesis | 5 min |
-| (Bonus) | Connect transport to fruit growth | for fast groups |+| (Bonus) | Let organs catch up: developmental plasticity | for fast groups |
  
 ---- ----
Line 34: Line 35:
   - The model code is in the file ''Example1.rgg''. Open it in the text editor (//Panels → Explorers → Files//, then double-click the file).   - The model code is in the file ''Example1.rgg''. Open it in the text editor (//Panels → Explorers → Files//, then double-click the file).
   - In the toolbar of the 3D view you will find buttons for the **public** methods of the model. Here there is one: ''grow''. Each click on ''grow'' = **one time step = one hour** of simulated time.   - In the toolbar of the 3D view you will find buttons for the **public** methods of the model. Here there is one: ''grow''. Each click on ''grow'' = **one time step = one hour** of simulated time.
-  - To reset the plant to its initial state, use the reset/"init" button (this executes the ''init()'' method). **Also, every time you save the code (Ctrl+S), the model is recompiled and reset.** +  - To reset the plant to its initial state, use the reset button (this executes the ''init()'' method). **Every time you save the code (Ctrl+S), the model is also recompiled and reset.** 
-  - Click ''grow'' a few times, then run it repeatedly (run/loop button) and stop it after ~100 steps.+  - Click ''grow'' a few times, then **start a long run** (run/loop button). Let it run to about **step 600** (≈ 25 days) while you work on Parts 1 and 2. You will need the result in Part 3.
  
-Three charts open automatically:+Four charts open automatically:
 ^ Chart ^ What it shows ^ ^ Chart ^ What it shows ^
 | //Light intercepted by canopy// | total light absorbed by all leaves during the last hour | | //Light intercepted by canopy// | total light absorbed by all leaves during the last hour |
-| //Canopy photosynthesis// | total amount of sugar **stored** in all leaves (stock, not the hourly production!) |+| //Canopy photosynthesis// | total amount of sugar **stored** in all leaves, in mg (a stock, not the hourly production!) |
 | //Fruit growth// | size of every fruit over time (one series per fruit) | | //Fruit growth// | size of every fruit over time (one series per fruit) |
 +| //Distribution of sugar in the internodes// | sugar content (mg) of every internode at the current step, plotted against its rank |
  
 **Colour code in the 3D view** (false colours, for display only): **Colour code in the 3D view** (false colours, for display only):
   * Leaves: colour depends on the light they absorbed.   * Leaves: colour depends on the light they absorbed.
-  * Internodes: colour depends on their sugar content – the brighter, the more sugar.+  * Internodes: colour depends on their sugar content.
   * The brown floor is made of light-absorbing tiles; bright tiles receive more light.   * The brown floor is made of light-absorbing tiles; bright tiles receive more light.
  
-The ''println'' messages (e.g. "sugar import into fruit") appear in the **XL Console** window.+**The XL Console.** Messages from the model appear here. You can also type queries into it, for example: 
 +<code java> 
 +((* Example1.Fruit *)[size])      // size of every fruit 
 +((* Example1.Fruit *)[as])        // sugar stock of every fruit 
 +count((* Example1.Fruit *))       // number of fruits 
 +</code>
  
 ===== Part 1 – The biology in brief (10 min) ===== ===== Part 1 – The biology in brief (10 min) =====
Line 65: Line 72:
 ^ Module ^ Role ^ Important attributes ^ ^ Module ^ Role ^ Important attributes ^
 | ''Bud'' | apical meristem; produces new metamers | ''rank'' (position on the axis), ''phyllo'' (countdown until next metamer), ''order'' (1 = main stem, 2 = branch, 3 = dormant bud) | | ''Bud'' | apical meristem; produces new metamers | ''rank'' (position on the axis), ''phyllo'' (countdown until next metamer), ''order'' (1 = main stem, 2 = branch, 3 = dormant bud) |
-| ''Internode'' | stem segment; **transport pathway and small sink** | ''length'', ''age'', ''rank'', ''as'' (assimilate content) |+| ''Internode'' | stem segment; **transport pathway and sink** | ''length'', ''age'', ''rank'', ''as'' (assimilate content, mg) |
 | ''Node'' | attachment point of a leaf and a lateral bud | – | | ''Node'' | attachment point of a leaf and a lateral bud | – |
-| ''Leaf'' | **source** (and sink while young) | ''length'', ''width'', ''al'' (absorbed light), ''age'', ''as'' (assimilate content) | +| ''Leaf'' | **source** (and sink while young) | ''length'', ''width'', ''al'' (absorbed light), ''age'', ''as'' (assimilate content, mg) | 
-| ''Flower'' | becomes a fruit if enough sugar is available | ''age'', ''max_age'' |+| ''Flower'' | becomes a fruit if enough sugar is available, otherwise it is shed | ''age'', ''max_age'' |
 | ''Fruit'' | **main sink** | ''size'', ''age'', ''as'', ''no'' (fruit number) | | ''Fruit'' | **main sink** | ''size'', ''age'', ''as'', ''no'' (fruit number) |
 | ''Tile'' | light-absorbing ground | ''al'' | | ''Tile'' | light-absorbing ground | ''al'' |
Line 77: Line 84:
 <code java> <code java>
 public void grow () { public void grow () {
-    run();            // 1. architecture: new metamers, flowers, fruits, leaf death+    run();            // 1. architecture: new metamers, flowers, fruit set, leaf death
     lm.compute();     // 2. light model: ray tracing of the whole scene     lm.compute();     // 2. light model: ray tracing of the whole scene
     absorbAndGrow();  // 3. light absorption, photosynthesis, organ growth     absorbAndGrow();  // 3. light absorption, photosynthesis, organ growth
-    if (time % 24 == 0) {                       // 4. once every 24 steps ... +    //if(time % 24 == 0) { 
-        for (int hour = 0; hour < 24; hour++) { +        //for(int hour = 0; hour < 24; hour++) { 
-            transport();                        //    ... 24 rounds of transport +            transport();   // 4. one round of transport per hour 
-        } +       // } 
-    }+    //}
     updateChart();    // 5. charts     updateChart();    // 5. charts
     time++;     time++;
Line 90: Line 97:
 </code> </code>
  
-**Q4.** One step represents one hour (constant ''DURATION'' = 3600 s). How often is sugar actually transported in this model? Is this realistic? What could be the reason for this choice?+**Q4.** In an earlier version of the model, the lines now commented out were active: transport happened 24 times in a row, but only once every 24 steps. A young leaf is a sink only during its first ~13 hours. What problem did this cause? Why is it important that the time step of transport matches the time scale of the processes it feeds?
  
 ==== 2.3 How the plant is built ==== ==== 2.3 How the plant is built ====
Line 98: Line 105:
 <code java> <code java>
 Bud(r, p, o), (r < 10 && p == 0 && o < 3) ==> Bud(r, p, o), (r < 10 && p == 0 && o < 3) ==>
-    RV(-0.1) Internode(0.1, 1, r, 0.1) Node+    RV(-0.1) Internode(0.1, 1, r, (r==1 && o==1) ? 0.2 : 0.0) Node
     [ RL(BRANCH_ANGLE) Bud(r, PHYLLOCHRON, o+1) ]   // lateral bud -> branch     [ RL(BRANCH_ANGLE) Bud(r, PHYLLOCHRON, o+1) ]   // lateral bud -> branch
     [ LFA(1) Leaf(0.1, 0.07, 0, 1, 0, r) ]          // leaf     [ LFA(1) Leaf(0.1, 0.07, 0, 1, 0, r) ]          // leaf
-    RH(GOLDEN_ANGLE) RV(-0.1) Internode(0.1, 1, r, 0.1)+    RH(GOLDEN_ANGLE) RV(-0.1) Internode(0.1, 1, r, (r==1 && o==1) ? 0.1 : 0.0)
     Bud(r+1, PHYLLOCHRON, o);                       // the apex continues     Bud(r+1, PHYLLOCHRON, o);                       // the apex continues
 </code> </code>
Line 109: Line 116:
 **Q6.** When ''rank'' reaches 10, the bud turns into a ''Flower''. How many flowers do you expect on the plant? (Hint: look at the condition ''o < 3'' and at the order given to the main stem in ''init()''.) **Q6.** When ''rank'' reaches 10, the bud turns into a ''Flower''. How many flowers do you expect on the plant? (Hint: look at the condition ''o < 3'' and at the order given to the main stem in ''init()''.)
  
-===== Part 3 – Run and observe (15 min) =====+**Q7.** Only the first two internodes of the main stem (''r==1 && o==1'') start with some sugar; all other new organs start empty. What does this initial sugar represent biologically? Why is it a good idea not to give every new organ a "start capital"?
  
-Reset the model and run it for about **300 steps** (≈ 12 days). Observe the 3D view, the charts and the console.+===== Part 3 – Observe the reference run (15 min) ===== 
 + 
 +Look at your run (about 600 steps). Use the 3D view, the charts and the console queries.
  
 Fill in: Fill in:
Line 117: Line 126:
 | Step at which the first flower appears | | | Step at which the first flower appears | |
 | Step at which the first fruit appears | | | Step at which the first fruit appears | |
-| Number of fruits at step 300 | |+| Number of flowers / number of fruits | | 
 +| Final size of each fruit (console query) | |
 | Shape of the fruit growth curves (linear? S-shaped? all the same?) | | | Shape of the fruit growth curves (linear? S-shaped? all the same?) | |
-| Where are the internodes brightest (most sugar)? Top, bottom, main stem, branches? | |+| Sugar distribution in the internodes: at which ranks is it highest? | |
 | Which leaves absorb the most light? | | | Which leaves absorb the most light? | |
  
-**Q7.** Do all flowers become fruits at the same time? Why not? (You will find the rule in Part 4.4.)+**Q8.** The internode sugar chart shows the highest sugar content in the **middle** ranks, not at the base or at the top. Propose an explanation. (Think about which leaves are mature and well lit, and which organs at the top are consuming sugar.)
  
 ===== Part 4 – Reading the code: production, transport, use (25 min) ===== ===== Part 4 – Reading the code: production, transport, use (25 min) =====
Line 140: Line 150:
 ''ppfd'' is the photon flux density received by the leaf (µmol photons m⁻² s⁻¹), CER is the CO₂ exchange rate (µmol CO₂ m⁻² s⁻¹). ''FMAX'' = 20, ''DARK_RESPIRATION_RATE'' = 0.5, ''PHOTO_EFFICIENCY'' = 0.85. ''ppfd'' is the photon flux density received by the leaf (µmol photons m⁻² s⁻¹), CER is the CO₂ exchange rate (µmol CO₂ m⁻² s⁻¹). ''FMAX'' = 20, ''DARK_RESPIRATION_RATE'' = 0.5, ''PHOTO_EFFICIENCY'' = 0.85.
  
-  * **Q8.** What is the value of CER in darkness (ppfd = 0)? What does a negative value mean for the leaf? +  * **Q9.** What is the value of CER in darkness (ppfd = 0)? What does a negative value mean for the leaf? 
-  * **Q9.** What value does CER approach when ppfd becomes very large? Sketch the curve. +  * **Q10.** What value does CER approach when ppfd becomes very large? Sketch the curve. 
-  * **Q10.** The function ''calculatePS'' then converts CER into kilograms of glucose produced by one leaf in one hour. Which three quantities is CER multiplied by? (Look at the code.)+  * **Q11.** The function ''calculatePS'' converts CER into milligrams of glucose produced by one leaf in one hour. Which quantities is CER multiplied by? (Look at the code.)
  
 In ''absorbAndGrow()'', every leaf adds its production to its own stock: ''lf[as] += calculatePS(...)''. In ''absorbAndGrow()'', every leaf adds its production to its own stock: ''lf[as] += calculatePS(...)''.
Line 148: Line 158:
 ==== 4.2 Transport ==== ==== 4.2 Transport ====
  
-The method ''transport()'' contains three rules. Read them carefully.+The method ''transport()'' contains three rules. The rate constants are defined at the top of the file: 
 + 
 +<code java> 
 +const float LEAF_EXPORT  = 0.05;  // fraction of leaf stock exported per hour 
 +const float D_PHLOEM     = 0.2;   // exchange between adjacent internodes 
 +const float FRUIT_UNLOAD = 0.1;   // unloading into the fruit per hour 
 +</code>
  
 **Rule 1 – between a leaf and the internode that carries it** **Rule 1 – between a leaf and the internode that carries it**
 <code java> <code java>
-lf:Leaf <-minDescendants- itn:Internode ::> { +lf:Leaf -ancestor-> itn:Internode ::> { 
-    if (lf[as] > 0.01 && lf[age] >= 10) {        // mature leaf: EXPORT +    boolean sink = lf[length] < 1.0;   // about 1/3 of final length 
-        float exportable = lf[as] - 0.01; +    if (!sink && lf[as] > 0.001) {            // mature leaf: EXPORT 
-        float r = DIFF_CONST * exportable; +        float r = LEAF_EXPORT * lf[as]; 
-        lf[as] -= r;   itn[as] += r; +        lf[as] -= r;  itn[as] += r; 
-    } else if (itn[as] > 0.01 && lf[age] < 10) { // young leaf: IMPORT +    } 
-        float exportable = itn[as] - 0.01; +    else if (sink && itn[as] > 0.001) {       // young leaf: IMPORT 
-        float r = DIFF_CONST * exportable; +        float r = LEAF_EXPORT * itn[as]; 
-        lf[as] += r;   itn[as] -= r;+        lf[as] += r;  itn[as] -= r;
     }     }
 } }
 </code> </code>
  
-**Rule 2 – between two successive internodes** (simplified here, same meaning as in the model)+**Rule 2 – between two successive internodes**
 <code java> <code java>
-i_top:Internode <-minDescendants- i_bottom:Internode ::> { +i_top:Internode -ancestor-> i_bottom:Internode ::> { 
-    float r = DIFF_CONST * (i_top[as] - i_bottom[as]);+    float r = D_PHLOEM * (i_top[as] - i_bottom[as]);
     i_bottom[as] :+= r;     i_bottom[as] :+= r;
     i_top[as]    :-= r;     i_top[as]    :-= r;
Line 174: Line 190:
 </code> </code>
  
-**Rule 3 – from an internode to a fruit**+**Rule 3 – from an internode into the fruit it carries**
 <code java> <code java>
-itn:Internode -minDescendants-> fr:Fruit ::> { +itn:Internode -successor-> fr:Fruit ::> { 
-    if (itn[as] > 0) { +    float r = FRUIT_UNLOAD * Math.max(0, itn[as] - fr[as]); 
-        float r = DIFF_CONST * itn[as]; +    itn[as] :-= r; 
-        itn[as] :-= r;   fr[as] :+= r; +    fr[as]  :+= r;
-    }+
 } }
 </code> </code>
  
-//Reading tip:// ''a:Leaf <-minDescendants- b:Internode'' means "b is an Internode found by going **down** from the leaf a towards the base" – i.e. the internode below the leaf. ''DIFF_CONST'' = 0.002 is the fraction of the difference (or of the stock) that moves per transport round.+//Reading tips:// ''a -ancestor-> b:Internode'' means "starting from a, go **down** towards the base and take the first Internode you meet". ''a -successor-> b'' means "b follows a directly". The operators '':+='' and '':-='' collect all changes and apply them together at the end of the step, so the result does not depend on the order in which the rules are applied.
  
-  * **Q11.** At what age does a leaf switch from sink to source in this model? Why do leaves keep a reserve of 0.01? +  * **Q12.** When does a leaf switch from sink to source in this model? Why is a criterion based on leaf **size** closer to the biology than one based on leaf **age**? 
-  * **Q12.** In Rule 2, can sugar move **upwards** as well as **downwards**? What decides the direction? Which physical process does this rule resemble (hint: Fick's law)? +  * **Q13.** In Rule 2, can sugar move **upwards** as well as **downwards**? What decides the direction? Which physical process does this rule resemble (hint: Fick's law)? 
-  * **Q13.** Compare Rule 1 (export) and Rule 2. Does the export of a mature leaf depend on how much sugar is already in the internode? Is that consistent with the Münch model? +  * **Q14.** Does the export of a mature leaf (Rule 1) depend on how much sugar is already in the internode? Is that consistent with the Münch model? 
-  * **Q14.** In Rule 3, which quantity drives the flux into the fruit: the fruit's demand, or the internode's stock? What would a "strong" sink look like in this model?+  * **Q15.** In Rule 3, the flux into the fruit depends on the **difference** between the internode and the fruit. What happens to the flux when a fruit uses its sugar quickly? What does this tell you about what makes a sink "strong"?
  
-==== 4.3 Use: maintenance and growth ====+==== 4.3 Use: potential and actual growth ====
  
-  * Internodes lose 1 % of their sugar per step (''MR'', maintenance respiration) and grow in length depending on their sugar content (''itn[as]''). +Internodes and fruits grow with the same logic. Here is the internode version: 
-  * Leaves grow following a logistic curve (look at the leaf part of ''absorbAndGrow()''). + 
-  * Fruits grow in the ''fr:Fruit ::> { ... }'' block of ''absorbAndGrow()''.+<code java> 
 +itn:Internode ::> { 
 +    itn[age]++; 
 +    itn[as] *= (1 - MR);                                     // maintenance respiration 
 +    float potential = logistic(INT_MAX_LENGTH, itn[age], 20, 0.2); // growth if sugar were unlimited 
 +    float demand = potential * GROWTH_COST;                  // sugar needed for that growth 
 +    float f = (demand > 0) ? Math.min(1.0, itn[as] / demand) : 0;  // fraction of demand satisfied 
 +    itn[length] += potential * f;                            // actual growth 
 +    itn[as]     -= demand * f;                               // sugar consumed 
 +} 
 +</code>
  
-**Q15 – Detective question.** Look closely at the fruit block. Where does the variable ''sugar'' that drives fruit growth come from? Is it the sugar ''fr[as]'' delivered by transport (Rule 3)? Is the sugar used by the fruit removed from anywhere?+The fruit block is identical, with ''FRUIT_MAX_SIZE'' and ''FRUIT_COST''.
  
-**Q16.** Does leaf growth depend on the amount of sugar in the leaf? (Read the comment in the code, then read the code itself.)+  * **Q16.** Explain in your own words what ''potential'', ''demand'' and ''f'' are. What is the value of ''f'' when the organ has more sugar than it needs? When it has none? 
 +  * **Q17.** The potential growth depends only on the organ's **age**. If an internode receives no sugar during its first 40 hours, can it catch up later? Is this realistic? 
 +  * **Q18.** Growth **consumes** sugar (last line). Using your answer to Q15, explain why this consumption is what makes sugar flow towards growing organs. 
 +  * **Q19.** An internode needs ''INT_MAX_LENGTH × GROWTH_COST'' = 1.5 mg of sugar for its whole growth. Compare with the values in the internode sugar chart. Is this plant limited by its **sources** or by its **sinks**? 
 +  * **Q20.** Does **leaf** growth depend on the amount of sugar in the leaf? (Read the comment in the code, then the code itself.)
  
 ==== 4.4 Fruit set ==== ==== 4.4 Fruit set ====
  
 <code java> <code java>
-fl:Flower(t, m)(* <-minDescendants- Node -minDescendants-> lf:Leaf *), +fl:Flower(t, m)(* -ancestor-> itn:Internode *), (t >= m && t < m+2) ==> 
-    (t >= m && t < m+2) ==> +    { float sugar = itn[as]; println("flower sugar: " + sugar); } 
-    { float sugar = lf[as]; } +    if (sugar > FRUIT_SET_THRESHOLD) ( {noFrts++;} Fruit(0.01, 1, 0.1, noFrts) );
-    if (sugar > 0) ( {noFrts++;} Fruit(0.01, 1, 0.1, noFrts) ) +
-    else (fl);+
 </code> </code>
  
-**Q17.** In words: under which condition does a flower become a fruit? Which leaf is checked? What happens to a flower when the condition is not met?+**Q21.** In words: under which condition does a flower become a fruit? Where is the sugar measured? What happens to a flower when the condition is not met? (Hint: what is on the right-hand side of the rule in that case?)
  
 ===== Part 5 – Virtual experiments (25 min) ===== ===== Part 5 – Virtual experiments (25 min) =====
  
 Method, for **each** experiment: Method, for **each** experiment:
-  - Write your **prediction** //before// running (effect on fruit number, fruit size, internode sugar, total leaf sugar). +  - Write your **prediction** //before// running (effect on fruit number, fruit size, internode length, sugar distribution). 
-  - Change **one** value only, save (the model resets), run 300 steps.+  - Change **one** value only, save (the model resets), run to step 600.
   - Record the result, then **restore the original value**.   - Record the result, then **restore the original value**.
  
-Every group does **E1**, plus **two** other experiments of its choice.+A run takes several minutes, so the experiments are shared out between the pairs. Your teacher will tell you which ones to do; the results are pooled at the end.
  
-^ Exp. ^ What to change ^ Where ^ +^ Exp. ^ What to change ^ Question behind it ^ 
-| E1 | ''DIFF_CONST'': 0.002 → 0.02, then → 0.0002 | constants at the top | +| E1 | ''D_PHLOEM'': 0.2 → 0.02 | How far can sugar travel in the stem? | 
-| E2 | Lamp power: ''setPower(200.0)'' → 50.0 | module ''MyLamp'' | +| E2 | ''MR'': 0.002 → 0.02 | What does respiration cost the plant? | 
-| E3 | Sink–source transition: leaf age ''10'' → ''30'' (two places in Rule 1) | ''transport()'' | +| E3 | ''LEAF_EXPORT'': 0.05 → 0.01 | What if leaves keep their sugar? | 
-| E4 | Maintenance respiration ''MR'': 0.01 → 0.05 | constants | +| E4 | Lamp power: ''setPower(200.0)'' → 100.0 (module ''MyLamp'') | Source limitation | 
-| E5 | Transport every hour instead of 24 rounds once a day: in ''grow()'', replace the whole ''if (time % 24 == 0) {...}'' block by a single line ''transport();'' | ''grow()'' | +| E5 | ''FRUIT_COST'': 250 → 500 | A more demanding sink | 
-| E6 | Phyllochron: ''PHYLLOCHRON'' 25 → 15 | constants |+| E6 | Sink–source transition: ''lf[length] < 1.0'' → ''< 2.0'' (Rule 1) | Longer sink phase of young leaves | 
 +| E7 | ''FRUIT_SET_THRESHOLD'': 3.5 → 1.0, then → 10 | Fruit set vs. abortion |
  
 Results table (one line per run): Results table (one line per run):
-^ Exp. ^ Value ^ Prediction ^ Nb fruits (step 300) ^ Size of largest fruit ^ Internode colour ^ Total leaf sugar (chart) ^ Explanation ^+^ Exp. ^ Value ^ Prediction ^ Nb fruits ^ Mean fruit size ^ Internode sugar profile ^ Plant height / internode length ^ Explanation ^
 | Ref | – | – | | | | | | | Ref | – | – | | | | | |
-| E1 | 0.02 | | | | | | | 
-| E1 | 0.0002 | | | | | | | 
 | | | | | | | | | | | | | | | | | |
 | | | | | | | | | | | | | | | | | |
  
-**Q18.** Was any result the opposite of your prediction? Use your answer to Q15 to explain it.+**Q22.** Which experiments changed **fruit size**, and which changed **fruit number**? Why are these two responses controlled by different parts of the model? 
 + 
 +**Q23.** Was any result the opposite of your prediction? Explain it using the code.
  
 ===== Part 6 – Your specialty (15 min) ===== ===== Part 6 – Your specialty (15 min) =====
Line 250: Line 278:
 At the top of the file, next to the other constants, add: At the top of the file, next to the other constants, add:
 <code java> <code java>
-const float APHID_RATE = 0.02;   // fraction of internode sugar taken per transport round+const float APHID_RATE = 0.02;   // fraction of internode sugar taken per hour
 float aphidSugar = 0;            // total sugar taken by the aphids float aphidSugar = 0;            // total sugar taken by the aphids
 </code> </code>
Line 263: Line 291:
 </code> </code>
  
-Print the total at each step: add ''println("aphids: " + aphidSugar);'' in ''grow()''. Compare with the reference run. Then try rank 8 instead of 3 (closer to the flowers).+Print the total at each step: add ''println("aphids: " + aphidSugar);'' in ''grow()''. Compare with the reference run. Then move the colony to rank 9, just below the flowers.
  
-**A2. Defoliation by a leaf disease.** Remove all leaves of rank ≤ 4 at step 150. Add this rule in ''run()'':+**A2. Defoliation by a leaf disease.** Remove all leaves of rank ≤ 4 at step 200. Add this rule in ''run()'':
 <code java> <code java>
-lf:Leaf, (time == 150 && lf[rank] <= 4) ==> ;+lf:Leaf, (time == 200 && lf[rank] <= 4) ==> ;
 </code> </code>
  
Line 273: Line 301:
  
 **Questions:** **Questions:**
-  * **QA1.** Which intervention reduced fruit set / fruit growth the most? Was the position of the aphid colony important? Why?+  * **QA1.** Which intervention reduced fruit number or fruit size the most? Was the position of the aphid colony important? Why?
   * **QA2.** Which of A1, A2, A3 reduces the //source//, which adds a //sink//? Why is it useful for a plant pathologist to make this distinction?   * **QA2.** Which of A1, A2, A3 reduces the //source//, which adds a //sink//? Why is it useful for a plant pathologist to make this distinction?
-  * **QA3.** What would you need to add to the model to represent the aphid population growing over time?+  * **QA3.** What would you need to add to the model to represent an aphid population that grows over time?
  
 ==== Track B – Seed Science and Plant Propagation ==== ==== Track B – Seed Science and Plant Propagation ====
  
-**B1. Fruit thinning.** Remove every second fruit at step 250. Add this rule in ''run()'':+**B1. Fruit thinning.** Remove every second fruit at step 360. Add this rule in ''run()'':
 <code java> <code java>
-fr:Fruit, (time == 250 && fr[no] % 2 == 0) ==> ;+fr:Fruit, (time == 360 && fr[no] % 2 == 0) ==> ;
 </code> </code>
-Compare the size of the remaining fruits with the reference run.+Compare the final size of the remaining fruits with the reference run.
  
-**B2. Fruit abortion threshold.** In the fruit-set rule (Part 4.4), a flower sets fruit as soon as ''sugar > 0''. Replace ''0'' with a threshold, e.g. ''sugar > 0.05'', and then with a larger value. Record how the number of fruits and the time of fruit set change.+**B2. Fruit set threshold.** Run experiment E7 if nobody else has. How do the number of fruits and the mean fruit size change together?
  
-**B3. Competition among fruits.** In the fruit block of ''absorbAndGrow()'', the sugar share of each fruit is weighted by ''Math.exp(-0.05 * fr[age])''. This gives **younger** fruits priority. Set the factor to ''0'' (equal shares), then to ''+0.05'' (older fruits get priority).+**B3. Variable developmental speed.** In the reference plant, all branches develop in step, so all fruits have almost the same age. Make development less regular: in the metamer rule (Part 2.3), replace **both** occurrences of ''PHYLLOCHRON'' by ''irandom(PHYLLOCHRON-8, PHYLLOCHRON+8)''. Run the model twice and compare the spread of fruit sizes (largest minus smallest) with the reference run.
  
 **Questions:** **Questions:**
   * **QB1.** Is there a trade-off between the number and the size of fruits? Show it with your results.   * **QB1.** Is there a trade-off between the number and the size of fruits? Show it with your results.
-  * **QB2.** In real plants, the first-set fruits usually dominate later ones. Which setting of B3 is closest to this? What are the consequences for seed-lot uniformity?+  * **QB2.** In B3, do early-set or late-set fruits end up larger? Why? What are the consequences for seed-lot uniformity?
   * **QB3.** A seed producer wants large, uniform seeds. Based on the model, what would you advise, and what is missing from the model to give a reliable answer?   * **QB3.** A seed producer wants large, uniform seeds. Based on the model, what would you advise, and what is missing from the model to give a reliable answer?
  
 ===== Part 7 – Synthesis (5 min) ===== ===== Part 7 – Synthesis (5 min) =====
  
-  * **Q19.** Draw a diagram (boxes and arrows) of the sugar flows in the model **as it is coded**: production → stocks → transport → use. Mark any place where sugar appears or disappears without an arrow. +  * **Q24.** Draw a diagram (boxes and arrows) of the sugar flows in the model: production → stocks → transport → use. Mark every place where sugar enters or leaves the system. 
-  * **Q20.** List two strengths and two limitations of this model for studying source–sink relations.+  * **Q25.** List two strengths and two limitations of this model for studying source–sink relations.
  
-===== Bonus – Make fruits grow on the sugar they actually receive =====+===== Bonus – Let organs catch up: developmental plasticity =====
  
-For fast groups (this is a "new functionality" task). At present, fruits grow from the sugar stored in //all// leaves, which is never consumed (see Q15), while the sugar delivered by Rule 3 (''fr[as]'') is not used.+For fast groups. At present an internode's potential growth depends on its calendar age (Q17): if it is starved during its growth window, the loss is permanent. Real organs can often delay their development instead.
  
-Modify the fruit block in ''absorbAndGrow()'' so that: +Hints: 
-  - the fruit computes its **potential** growth for this step (you can keep the ''logistic(...)'' call with a fixed maximum), +  - Give ''Internode'' a new variable for its **developmental age**: change the module declaration to ''module Internode(super.length, int age, int rank, float as) extends Cylinder(length, 0.1) { float dev; }''. 
-  - it converts potential growth into a **sugar demand** (introduce a constant, e.g. ''SUGAR_PER_SIZE''), +  - In the internode block, use ''itn[dev]'' instead of ''itn[age]'' to compute the potential. 
-  - it grows only as much as its stock ''fr[as]'' allows, and **removes** the sugar used from ''fr[as]''.+  - At the end of the block, let development advance only as fast as growth is satisfied: ''itn[dev] += f;'' 
 +  - The function ''logistic'' expects an ''int'' for time. Change its declaration to ''float time''.
  
-Then repeat experiment E1. Do the results now match your original predictions?+Compare the internode lengths along the main stem with the reference run. Where does the change have the largest effect?
  
 ===== Before the exam ===== ===== Before the exam =====
  
 This exercise is not handed in, but the questions above cover the kind of reasoning expected in the exam: explaining source–sink relations, reading a simple model rule, and predicting and interpreting the outcome of a virtual experiment. Keep your answers and tables as revision notes. This exercise is not handed in, but the questions above cover the kind of reasoning expected in the exam: explaining source–sink relations, reading a simple model rule, and predicting and interpreting the outcome of a virtual experiment. Keep your answers and tables as revision notes.
 +
02_user_tutorials/exercises/exercise/start.1790589358.txt.gz · Last modified: by barley1965