Open Transport.gsz

The Transport model extends the Flower aging model by implementing a physiologically-based system for sugar transport from photosynthetically active leaves through the plant architecture to developing fruits. This creates a more realistic simulation of source-sink relationships in the virtual plant.

The model introduces a new parameter as (assimilate storage) to track sugar content in different organs:

module Internode(super.length, int age, int rank, float as) extends Cylinder(length, 0.1);
module Leaf(super.length, super.width, float al, int age, float as, int rank) extends Box(length, width, 0.01);
module Fruit(float size, int age, float as) ==> Sphere(size).(setShader(RED));

Note that we now track assimilates (as) in three types of modules: leaves (where they are produced), internodes (where they are transported), and fruits (where they accumulate).

A maintenance respiration constant has been added to simulate the metabolic cost of keeping tissues alive (L. 78):

const float MR = 0.01; //maintenance respiration

This is applied to internodes during growth to simulate sugar consumption:

itn:Internode ::> {
    itn[age]++;
    if(itn[as]>0) {itn[as] *= (1-MR); }
    itn[length] += logistic(1, itn[age], 10, 0.1);
}

The main novelty of the present model is the implementation of a diffusion-based transport system. The transport occurs with a diffusion constant that controls the rate (L. 75):

const float DIFF_CONST = 0.001;

The transport is invoked periodically in the grow() method - every 24 timesteps to simulate hourly transport (L. 138-143):

if(time % 24 == 0) {
    for(int hour = 0; hour < 24; hour++) {
        transport();
    }
}

Three types of transport are implemented using user-defined edge relations:

a) Leaf to Internode Transport (L. 251-258):

lf:Leaf <-minDescendants- itn:Internode ::> {
    if(lf[as] > 0.01) { // Keep minimum for leaf maintenance
        float exportable = lf[as] - 0.01;
        float r = DIFF_CONST * exportable;
        lf[as] -= r;
        itn[as] += r;
    }
}

This rule ensures leaves retain a minimum amount (0.01) for maintenance while exporting the surplus.

b) Internode to Internode Transport (L. 260-268):

i_top:Internode <-minDescendants- i_bottom:Internode ::> {
    if((i_bottom[as] - i_top[as])<=0) { 
        float r = DIFF_CONST * (i_top[as] - i_bottom[as]);
        i_bottom[as] :+= r;
        i_top[as] :-= r;
    }
    else if ((i_bottom[as] - i_top[as])>0) { 
        float r = DIFF_CONST * (i_bottom[as] - i_top[as]);
        i_bottom[as] :-= r;
        i_top[as] :+= r;
    }
}

This bidirectional transport follows the concentration gradient between successive internodes.

c) Internode to Fruit Transport (L. 269-275):

itn:Internode -minDescendants-> fr:Fruit ::> {
    if(itn[as]>0) {
        float r = DIFF_CONST * itn[as];
        itn[as] :-= r;
        fr[as] :+= r;
        println("sugar import into fruit: " + r);
    }
}

The model now makes fruit formation dependent on available sugar in the plant (L. 165-172):

fl:Flower(t, m), (t >= m) ==> 
    {float sugar = sum((* lf:Leaf *)[as]);
    println(sugar);
    } 
    if(probability(0.6)) (Fruit(0.01,1,0.1))
    else if(probability(0.4)) ();

Sugar availability is calculated by summing all leaf assimilates before deciding on fruit formation.

Multiple fruits compete for available resources using an age-based weighting system (L. 209-225):

fr:Fruit ::> {
    float totalSugar = sum((* lf1:Leaf *)[as]);
    long fruitCount = count((* fr2:Fruit *));
 
    // Simple age-based competition (younger fruits get more resources)
    float ageWeight = Math.exp(-0.05 * fr[age]);
    float totalAgeWeight = 0;
    for ((* fr2:Fruit *)) {
        totalAgeWeight += Math.exp(-0.05 * fr2[age]);
    }
 
    float sugar = (totalAgeWeight > 0) ? 
        (totalSugar * ageWeight) / totalAgeWeight : totalSugar / fruitCount;

Younger fruits receive proportionally more resources through exponential age weighting, simulating their stronger sink strength.

Internodes change color based on their sugar content, providing visual feedback of the transport process:

itn.(setShader(new RGBAShader(itn[as]*2000.0, itn[as]*1000, itn[as])));

1. Run the model and observe sugar flow: Watch how internodes change color as sugar moves through them. 2. Modify DIFF_CONST: Try values between 0.0001 and 0.01. How does this affect: o Speed of sugar movement? o Final fruit size? o Number of successfully developed fruits? 3. Change transport frequency: Modify the condition if(time % 24 == 0) to different values (e.g., % 12 for twice-daily transport). What impact does this have? 4. Adjust maintenance respiration: Change MR from 0.01 to 0.05. How does increased respiration affect fruit development?

This transport model introduces key physiological concepts: • Source-sink relationships: Leaves act as sources, fruits as sinks • Phloem transport: Simplified as diffusion along concentration gradients • Competition for resources: Multiple sinks compete for limited assimilates • Maintenance respiration: Realistic metabolic costs • Sink strength: Younger fruits have stronger sink strength