@woosh/meep-engine 3.56.0 → 3.58.0

package/src/generation/foliage/config/ShootGrowthConfig.js

@@ -0,0 +1,200 @@
+import { assert } from "../../../core/assert.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
+import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
+
+/**
+ * How a species' twig systems grow together, season by season, in the light they make for each other (see
+ * `tree_skeleton_grow_shoots`): how old the tree is, how fast its leader grows, and how a shoot's vigour follows the
+ * light it receives.
+ *
+ * Vigour is the bifurcation ratio Rb, the net shoots a shoot leaves a year (Niinemets & Lukjanova 2003, New Phytol.
+ * 158: 75-89). It rises with light: from 1, where shoots just replace themselves, at {@link compensation_light}, to the
+ * gross yield of the unit the shoot grew on at {@link saturation_light}, flat above, and below 1 in deeper shade, where a
+ * branch thins and dies. So in full light a shoot keeps every shoot its buds grow (`shoot_expected_yield`), and only
+ * shade sheds them. The defaults are chosen; each preset says where its own come from.
+ */
+export class ShootGrowthConfig {
+    /**
+     * Length (m) the leader grows a year once the tree is tall, {@link leader_unit}. It dates the framework: every
+     * branch elongates at this rate from when its parent's growth reached where it joins, so the framework is as old as
+     * its longest path from the base took to grow.
+     * @type {number}
+     */
+    leader_growth = 0.3;
+
+    /**
+     * How far below {@link leader_growth} a seedling's leader grows: at height 0 the leader grows `leader_growth / (1 +
+     * leader_onset)` a year (see {@link leader_unit}). 0 grows it at `leader_growth` from the first year.
+     * @type {number}
+     */
+    leader_onset = 0;
+
+    /**
+     * Height (m) over which the leader's shortfall below {@link leader_growth} falls by `e` (see {@link leader_unit}).
+     * @type {number}
+     */
+    leader_height_scale = 1;
+
+    /**
+     * Seasons the tree grows. The framework the generator graph lays is as old as it took to grow
+     * ({@link leader_growth}); a tree older than that grows on, its framework's tips extending as shoots for the seasons
+     * left. 0 grows no longer than the framework took.
+     * @type {number}
+     */
+    age = 0;
+
+    /**
+     * Apical control `λ` of the Borchert-Honda allocation (Borchert & Honda 1984; Palubicki et al. 2009, ACM Trans.
+     * Graph. 28(3): 58): the light a tree's shoots receive is summed down to its base and shared back up, and at each
+     * node the axis that goes on takes a share weighted `λ`, its laterals `1 - λ`. A shoot grows its demographic
+     * length times the vigour it receives per unit of its own light, relative to the most vigorous shoot's. 0.5 shares
+     * by light alone, which gives every shoot the same: the demography's lengths unchanged.
+     * @type {number}
+     */
+    apical_control = 0.5;
+
+    /**
+     * Relative irradiance (1 under open sky) at which a shoot just replaces itself: Rb = 1.
+     * @type {number}
+     */
+    compensation_light = 0.22;
+
+    /**
+     * Relative irradiance at and above which a shoot grows at its full {@link vigour}.
+     * @type {number}
+     */
+    saturation_light = 0.30;
+
+    /**
+     * Clumping of leaves within a voxel of the light field (Omega): 1 spreads them at random, below 1 bunches them on
+     * their shoots, which lets more light through.
+     * @type {number}
+     */
+    leaf_clumping = 1.0;
+
+    /**
+     * Edge (m) of a voxel of the light field: the scale over which leaf area is averaged. 0.25 m is chosen, about a
+     * shoot system's.
+     * @type {number}
+     */
+    light_cell = 0.25;
+
+    /**
+     * Length (m) the leader of a tree `height` metres tall grows in a year: the logistic `leader_growth / (1 +
+     * leader_onset exp(-height / leader_height_scale))` by which Flower-Ellis et al. (1976) hold a young tree's height
+     * growth to its height (Kellomäki & Kurttio 1991, For. Ecol. Manage. 43: 103-123, Eq. 6).
+     * @param {number} height
+     * @returns {number}
+     */
+    leader_unit(height) {
+        return this.leader_growth / (1 + this.leader_onset * Math.exp(-Math.max(0, height) / this.leader_height_scale));
+    }
+
+    /**
+     * Net shoots a shoot leaves a year at relative irradiance `light`, where in full light it would keep all `gross`
+     * of the new shoots its buds grow.
+     * @param {number} light
+     * @param {number} gross new shoots its buds grow a year
+     * @returns {number}
+     */
+    net_yield(light, gross) {
+        const span = Math.max(1e-6, this.saturation_light - this.compensation_light);
+        const slope = (gross - 1) / span;
+        return Math.max(0, Math.min(gross, 1 + (light - this.compensation_light) * slope));
+    }
+
+    /**
+     * @param {Partial<ShootGrowthConfig>} [options]
+     * @returns {ShootGrowthConfig}
+     */
+    static from(options = {}) {
+        const r = new ShootGrowthConfig();
+        r.applyOverrides(options);
+        return r;
+    }
+
+    /**
+     * @param {Partial<ShootGrowthConfig>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides = {}) {
+        if (overrides === null || overrides === undefined) {
+            return this;
+        }
+        if (overrides.leader_growth !== undefined) this.leader_growth = Math.max(0.01, overrides.leader_growth);
+        if (overrides.leader_onset !== undefined) this.leader_onset = Math.max(0, overrides.leader_onset);
+        if (overrides.leader_height_scale !== undefined) this.leader_height_scale = Math.max(1e-3, overrides.leader_height_scale);
+        if (overrides.age !== undefined) this.age = Math.max(0, overrides.age | 0);
+        if (overrides.apical_control !== undefined) this.apical_control = Math.min(0.999, Math.max(0.001, overrides.apical_control));
+        if (overrides.compensation_light !== undefined) this.compensation_light = Math.min(1, Math.max(0, overrides.compensation_light));
+        if (overrides.saturation_light !== undefined) this.saturation_light = Math.min(1, Math.max(0, overrides.saturation_light));
+        if (overrides.leaf_clumping !== undefined) this.leaf_clumping = Math.min(1, Math.max(0, overrides.leaf_clumping));
+        if (overrides.light_cell !== undefined) this.light_cell = Math.max(0.02, overrides.light_cell);
+        return this;
+    }
+
+    /**
+     * @param {ShootGrowthConfig} other
+     * @returns {this}
+     */
+    copy(other) {
+        assert.defined(other, 'other');
+        this.leader_growth = other.leader_growth;
+        this.leader_onset = other.leader_onset;
+        this.leader_height_scale = other.leader_height_scale;
+        this.age = other.age;
+        this.apical_control = other.apical_control;
+        this.compensation_light = other.compensation_light;
+        this.saturation_light = other.saturation_light;
+        this.leaf_clumping = other.leaf_clumping;
+        this.light_cell = other.light_cell;
+        return this;
+    }
+
+    /**
+     * @returns {ShootGrowthConfig}
+     */
+    clone() {
+        return new ShootGrowthConfig().copy(this);
+    }
+
+    /**
+     * @param {ShootGrowthConfig} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) return true;
+        if (!other || !other.isShootGrowthConfig) return false;
+        return this.leader_growth === other.leader_growth
+            && this.leader_onset === other.leader_onset
+            && this.leader_height_scale === other.leader_height_scale
+            && this.age === other.age
+            && this.apical_control === other.apical_control
+            && this.compensation_light === other.compensation_light
+            && this.saturation_light === other.saturation_light
+            && this.leaf_clumping === other.leaf_clumping
+            && this.light_cell === other.light_cell;
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        let h = computeHashFloat(this.leader_growth);
+        h = hash_mix2(h, computeHashFloat(this.leader_onset));
+        h = hash_mix2(h, computeHashFloat(this.leader_height_scale));
+        h = hash_mix2(h, this.age);
+        h = hash_mix2(h, computeHashFloat(this.apical_control));
+        h = hash_mix2(h, computeHashFloat(this.compensation_light));
+        h = hash_mix2(h, computeHashFloat(this.saturation_light));
+        h = hash_mix2(h, computeHashFloat(this.leaf_clumping));
+        h = hash_mix2(h, computeHashFloat(this.light_cell));
+        return h;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+ShootGrowthConfig.prototype.isShootGrowthConfig = true;

package/src/generation/foliage/config/ShootSystemRule.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Shoot system edge of the generator graph: every living branch grown by generator `source` carries a shoot system
+ * grown year by year from its own buds, each lateral a branch of the generator `target` names for its mother's order;
+ * the branch grows on from its tip when the tree is older than it (see `tree_skeleton_grow_shoots`).
+ *
+ * The model is the oak's [BB2000, BB1998], generalised: each year every living axis grows a terminal extension unit,
+ * and the buds on its units grow into long shoots (the spring after, or the same season), short shoots, or nothing,
+ * by bud zone and branching order. How many seasons, and how many new shoots survive in the light they get, is the
+ * species' `ShootGrowthConfig`. Per-order lists are indexed from order 1 (the carrier is `carrier_order`), and
+ * orders past their end take their last value.
+ *
+ * The defaults are pedunculate and sessile oak, from the peripheral branches of mature crowns measured by
+ * Buck-Sorlin & Bell (2000), Models of crown architecture in Quercus petraea and Q. robur: shoot lengths and bud
+ * numbers, Forestry 73(1): 1-19 [BB2000], and the shoot shedding of a free-standing Q. robur measured by
+ * Buck-Sorlin & Bell (1998), A quantification of shoot shedding in pedunculate oak (Quercus robur L.), Botanical
+ * Journal of the Linnean Society 127: 371-391 [BB1998].
+ */
+export class ShootSystemRule {
+    /**
+     * @param {Partial<ShootSystemRule>} [options]
+     * @returns {ShootSystemRule}
+     */
+    static from(options?: Partial<ShootSystemRule>): ShootSystemRule;
+    /**
+     * Carrier branch generator index into `TreeSpeciesConfig.branches`.
+     * @type {number}
+     */
+    source: number;
+    /**
+     * Generator index of the long shoots grown on a mother of each order, which shapes how they look (radial segments,
+     * bark, tropisms). Each greater than `source`. A carrier's own extension keeps the carrier's generator.
+     * @type {number[]}
+     */
+    target: number[];
+    /**
+     * Generator index of the short shoots, so foliage rules can tell them apart (`FoliageSpawnRule.short_shoot`).
+     * Greater than `source`. Used by zones whose buds grow short shoots.
+     * @type {number}
+     */
+    short_target: number;
+    /**
+     * Highest branching order a shoot may reach within the system [BB2000 p. 15].
+     * @type {number}
+     */
+    max_order: number;
+    /**
+     * Branching order of the carrier, in the numbering of the rule's per-order lists: where a source counts orders
+     * from the stem, a carrier deep in the framework starts deep in its lists. Oak's are counted from the branch
+     * measured [BB2000 p. 7], so its carriers are order 1.
+     * @type {number}
+     */
+    carrier_order: number;
+    /**
+     * Mean length (m) of an axis's terminal extension unit, before {@link terminal_length_slope}, per order of the
+     * axis: 11.7 cm at the first order [BB2000 p. 11], shorter by 0.644 an order [BB2000 p. 9].
+     * @type {number[]}
+     */
+    terminal_length: number[];
+    /**
+     * Mean length of a terminal extension unit per metre of the axis's previous unit, per order of the axis: a
+     * terminal unit is `terminal_length + terminal_length_slope * previous unit` long on average. Oak's do not
+     * follow their previous unit.
+     * @type {number[]}
+     */
+    terminal_length_slope: number[];
+    /**
+     * Longest extension unit (m) per order: 30 cm at the first order, falling to 8 cm at the fourth [BB2000 p. 9].
+     * @type {number[]}
+     */
+    max_unit_length: number[];
+    /**
+     * Probability of failure `p` of the negative binomial count of centimetres a unit grows past its first, per
+     * order; orders past the list are Poisson [BB2000 p. 10-11, Fig. 6].
+     * @type {number[]}
+     */
+    length_negative_binomial_p: number[];
+    /**
+     * Mean length (m) of an extension unit per order of the axis, at which a living shoot's yield of new shoots is
+     * counted ({@link shoot_expected_yield}), and against which a shoot's length ranks it for shedding: 5.9 cm on branch
+     * o1b1 [BB2000 Table 4], where oak's outgrowth shares were counted.
+     * @type {number[]}
+     */
+    mean_unit_length: number[];
+    /**
+     * Lateral bud zones along an extension unit. Oak's: the pseudo-whorl of "almost always four" subapical buds at
+     * 0.8-0.99 of the unit [BB2000 p. 7, 11, 17], 1.17 of which grow out on branch o1b1 [BB2000 p. 11]; and the
+     * median buds at 0.3-0.55, as many as `l = 0.98 m - 2.70` (cm) gives over all orders [BB2000 Table 5], 0.38 of
+     * whose 8.5 grow out [BB2000 p. 11, Tables 4, 5]. Their laterals average 6.2 and 5.2 cm at the first order
+     * [BB2000 p. 11].
+     * @type {ShootBudZone[]}
+     */
+    zones: ShootBudZone[];
+    /**
+     * Length (m) a short shoot grows a year. Used by zones whose buds grow short shoots.
+     * @type {number}
+     */
+    short_shoot_growth: number;
+    /**
+     * Share of short shoots alive one year that are alive the next. Used by zones whose buds grow short shoots.
+     * @type {number}
+     */
+    short_shoot_survival: number;
+    /**
+     * Angle (radians) between a lateral and its mother shoot, per mother order.
+     * @type {number[]}
+     */
+    insertion_angle: number[];
+    /**
+     * How a mother's buds turn around it, node to node.
+     * @type {PhyllotaxisMode|number}
+     */
+    phyllotaxis_mode: PhyllotaxisMode | number;
+    /**
+     * @param {Partial<ShootSystemRule>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides?: Partial<ShootSystemRule>): this;
+    /**
+     * @param {ShootSystemRule} other
+     * @returns {this}
+     */
+    copy(other: ShootSystemRule): this;
+    /**
+     * @returns {ShootSystemRule}
+     */
+    clone(): ShootSystemRule;
+    /**
+     * @param {ShootSystemRule} other
+     * @returns {boolean}
+     */
+    equals(other: ShootSystemRule): boolean;
+    /**
+     * @returns {number}
+     */
+    hash(): number;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isShootSystemRule: boolean;
+}
+import { ShootBudZone } from "./ShootBudZone.js";
+import { PhyllotaxisMode } from "./PhyllotaxisMode.js";
+//# sourceMappingURL=ShootSystemRule.d.ts.map

package/src/generation/foliage/config/ShootSystemRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShootSystemRule.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/ShootSystemRule.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;;;GAgBG;AACH;IAyHI;;;OAGG;IACH,sBAHW,QAAQ,eAAe,CAAC,GACtB,eAAe,CAM3B;IAhID;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX;;;;OAIG;IACH,QAFU,MAAM,EAAE,CAEL;IAEb;;;;OAIG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,WAFU,MAAM,CAEU;IAE1B;;;;;OAKG;IACH,eAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,iBAFU,MAAM,EAAE,CAEuB;IAEzC;;;;;OAKG;IACH,uBAFU,MAAM,EAAE,CAEU;IAE5B;;;OAGG;IACH,iBAFU,MAAM,EAAE,CAEsB;IAExC;;;;OAIG;IACH,4BAFU,MAAM,EAAE,CAEwB;IAE1C;;;;;OAKG;IACH,kBAFU,MAAM,EAAE,CAES;IAE3B;;;;;;;OAOG;IACH,OAFU,YAAY,EAAE,CAkBtB;IAEF;;;OAGG;IACH,oBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,sBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,iBAFU,MAAM,EAAE,CAEO;IAEzB;;;OAGG;IACH,kBAFU,eAAe,GAAC,MAAM,CAEgB;IAYhD;;;OAGG;IACH,2BAHW,QAAQ,eAAe,CAAC,GACtB,IAAI,CAgChB;IAED;;;OAGG;IACH,YAHW,eAAe,GACb,IAAI,CAoBhB;IAED;;OAEG;IACH,SAFa,eAAe,CAM3B;IAED;;;OAGG;IACH,cAHW,eAAe,GACb,OAAO,CAuBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAoBlB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;6BAxS4B,mBAAmB;gCADhB,sBAAsB"}

package/src/generation/foliage/config/ShootSystemRule.js

@@ -0,0 +1,320 @@
+import { assert } from "../../../core/assert.js";
+import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
+import { computeHashFloatArray } from "../../../core/math/hash/computeHashFloatArray.js";
+import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
+import { PhyllotaxisMode } from "./PhyllotaxisMode.js";
+import { ShootBudZone } from "./ShootBudZone.js";
+
+/**
+ * Factor on oak shoot length per branching order: the longest shoot falls from 30 cm at order 1 to 8 cm at order 4
+ * [BB2000 p. 9], (8 / 30)^(1/3).
+ * @type {number}
+ */
+const OAK_ORDER_LENGTH_RATIO = 0.644;
+
+/**
+ * Highest branching order of the oak's twig system: up to 7 orders were found on a branch [BB2000 p. 15].
+ * @type {number}
+ */
+const OAK_MAX_ORDER = 7;
+
+/**
+ * `value * 0.644^(order - 1 + offset)` for orders 1 to 7: the oak's per-order lengths, which shrink by
+ * {@link OAK_ORDER_LENGTH_RATIO} an order [BB2000 p. 9].
+ * @param {number} value
+ * @param {number} offset
+ * @returns {number[]}
+ */
+function oak_by_order(value, offset) {
+    const out = [];
+    for (let k = 0; k < OAK_MAX_ORDER; k++) {
+        out.push(value * Math.pow(OAK_ORDER_LENGTH_RATIO, k + offset));
+    }
+    return out;
+}
+
+/**
+ * Shoot system edge of the generator graph: every living branch grown by generator `source` carries a shoot system
+ * grown year by year from its own buds, each lateral a branch of the generator `target` names for its mother's order;
+ * the branch grows on from its tip when the tree is older than it (see `tree_skeleton_grow_shoots`).
+ *
+ * The model is the oak's [BB2000, BB1998], generalised: each year every living axis grows a terminal extension unit,
+ * and the buds on its units grow into long shoots (the spring after, or the same season), short shoots, or nothing,
+ * by bud zone and branching order. How many seasons, and how many new shoots survive in the light they get, is the
+ * species' `ShootGrowthConfig`. Per-order lists are indexed from order 1 (the carrier is `carrier_order`), and
+ * orders past their end take their last value.
+ *
+ * The defaults are pedunculate and sessile oak, from the peripheral branches of mature crowns measured by
+ * Buck-Sorlin & Bell (2000), Models of crown architecture in Quercus petraea and Q. robur: shoot lengths and bud
+ * numbers, Forestry 73(1): 1-19 [BB2000], and the shoot shedding of a free-standing Q. robur measured by
+ * Buck-Sorlin & Bell (1998), A quantification of shoot shedding in pedunculate oak (Quercus robur L.), Botanical
+ * Journal of the Linnean Society 127: 371-391 [BB1998].
+ */
+export class ShootSystemRule {
+    /**
+     * Carrier branch generator index into `TreeSpeciesConfig.branches`.
+     * @type {number}
+     */
+    source = 2;
+
+    /**
+     * Generator index of the long shoots grown on a mother of each order, which shapes how they look (radial segments,
+     * bark, tropisms). Each greater than `source`. A carrier's own extension keeps the carrier's generator.
+     * @type {number[]}
+     */
+    target = [3];
+
+    /**
+     * Generator index of the short shoots, so foliage rules can tell them apart (`FoliageSpawnRule.short_shoot`).
+     * Greater than `source`. Used by zones whose buds grow short shoots.
+     * @type {number}
+     */
+    short_target = 3;
+
+    /**
+     * Highest branching order a shoot may reach within the system [BB2000 p. 15].
+     * @type {number}
+     */
+    max_order = OAK_MAX_ORDER;
+
+    /**
+     * Branching order of the carrier, in the numbering of the rule's per-order lists: where a source counts orders
+     * from the stem, a carrier deep in the framework starts deep in its lists. Oak's are counted from the branch
+     * measured [BB2000 p. 7], so its carriers are order 1.
+     * @type {number}
+     */
+    carrier_order = 1;
+
+    /**
+     * Mean length (m) of an axis's terminal extension unit, before {@link terminal_length_slope}, per order of the
+     * axis: 11.7 cm at the first order [BB2000 p. 11], shorter by 0.644 an order [BB2000 p. 9].
+     * @type {number[]}
+     */
+    terminal_length = oak_by_order(0.117, 0);
+
+    /**
+     * Mean length of a terminal extension unit per metre of the axis's previous unit, per order of the axis: a
+     * terminal unit is `terminal_length + terminal_length_slope * previous unit` long on average. Oak's do not
+     * follow their previous unit.
+     * @type {number[]}
+     */
+    terminal_length_slope = [0];
+
+    /**
+     * Longest extension unit (m) per order: 30 cm at the first order, falling to 8 cm at the fourth [BB2000 p. 9].
+     * @type {number[]}
+     */
+    max_unit_length = oak_by_order(0.30, 0);
+
+    /**
+     * Probability of failure `p` of the negative binomial count of centimetres a unit grows past its first, per
+     * order; orders past the list are Poisson [BB2000 p. 10-11, Fig. 6].
+     * @type {number[]}
+     */
+    length_negative_binomial_p = [0.58, 0.60];
+
+    /**
+     * Mean length (m) of an extension unit per order of the axis, at which a living shoot's yield of new shoots is
+     * counted ({@link shoot_expected_yield}), and against which a shoot's length ranks it for shedding: 5.9 cm on branch
+     * o1b1 [BB2000 Table 4], where oak's outgrowth shares were counted.
+     * @type {number[]}
+     */
+    mean_unit_length = [0.059];
+
+    /**
+     * Lateral bud zones along an extension unit. Oak's: the pseudo-whorl of "almost always four" subapical buds at
+     * 0.8-0.99 of the unit [BB2000 p. 7, 11, 17], 1.17 of which grow out on branch o1b1 [BB2000 p. 11]; and the
+     * median buds at 0.3-0.55, as many as `l = 0.98 m - 2.70` (cm) gives over all orders [BB2000 Table 5], 0.38 of
+     * whose 8.5 grow out [BB2000 p. 11, Tables 4, 5]. Their laterals average 6.2 and 5.2 cm at the first order
+     * [BB2000 p. 11].
+     * @type {ShootBudZone[]}
+     */
+    zones = [
+        ShootBudZone.from({
+            u_min: 0.8,
+            u_max: 0.99,
+            buds: [4],
+            long: [0.29],
+            length: oak_by_order(0.062, 1)
+        }),
+        ShootBudZone.from({
+            u_min: 0.3,
+            u_max: 0.55,
+            buds: [2.70 / 0.98],
+            buds_per_metre: [100 / 0.98],
+            long: [0.045],
+            length: oak_by_order(0.052, 1)
+        })
+    ];
+
+    /**
+     * Length (m) a short shoot grows a year. Used by zones whose buds grow short shoots.
+     * @type {number}
+     */
+    short_shoot_growth = 0.002;
+
+    /**
+     * Share of short shoots alive one year that are alive the next. Used by zones whose buds grow short shoots.
+     * @type {number}
+     */
+    short_shoot_survival = 0.6;
+
+    /**
+     * Angle (radians) between a lateral and its mother shoot, per mother order.
+     * @type {number[]}
+     */
+    insertion_angle = [0.75];
+
+    /**
+     * How a mother's buds turn around it, node to node.
+     * @type {PhyllotaxisMode|number}
+     */
+    phyllotaxis_mode = PhyllotaxisMode.SpiralGolden;
+
+    /**
+     * @param {Partial<ShootSystemRule>} [options]
+     * @returns {ShootSystemRule}
+     */
+    static from(options = {}) {
+        const r = new ShootSystemRule();
+        r.applyOverrides(options);
+        return r;
+    }
+
+    /**
+     * @param {Partial<ShootSystemRule>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides = {}) {
+        if (overrides === null || overrides === undefined) {
+            return this;
+        }
+        if (overrides.source !== undefined) this.source = overrides.source | 0;
+        if (overrides.target !== undefined) {
+            assert.isArray(overrides.target, 'target');
+            assert.greaterThan(overrides.target.length, 0, 'target.length');
+            this.target = overrides.target.map(t => t | 0);
+        }
+        if (overrides.short_target !== undefined) this.short_target = overrides.short_target | 0;
+        if (overrides.max_order !== undefined) this.max_order = Math.max(1, overrides.max_order | 0);
+        if (overrides.carrier_order !== undefined) this.carrier_order = Math.max(1, overrides.carrier_order | 0);
+        if (overrides.terminal_length !== undefined) this.terminal_length = list(overrides.terminal_length, 0);
+        if (overrides.terminal_length_slope !== undefined) this.terminal_length_slope = list(overrides.terminal_length_slope, 0);
+        if (overrides.max_unit_length !== undefined) this.max_unit_length = list(overrides.max_unit_length, 0.01);
+        if (overrides.length_negative_binomial_p !== undefined) {
+            assert.isArray(overrides.length_negative_binomial_p, 'length_negative_binomial_p');
+            this.length_negative_binomial_p = overrides.length_negative_binomial_p.map(p => Math.min(0.999, Math.max(0.001, p)));
+        }
+        if (overrides.mean_unit_length !== undefined) this.mean_unit_length = list(overrides.mean_unit_length, 1e-3);
+        if (overrides.zones !== undefined) {
+            assert.isArray(overrides.zones, 'zones');
+            this.zones = overrides.zones.map(z => ShootBudZone.from(z));
+        }
+        if (overrides.short_shoot_growth !== undefined) this.short_shoot_growth = Math.max(1e-4, overrides.short_shoot_growth);
+        if (overrides.short_shoot_survival !== undefined) this.short_shoot_survival = Math.min(1, Math.max(0, overrides.short_shoot_survival));
+        if (overrides.insertion_angle !== undefined) this.insertion_angle = list(overrides.insertion_angle, 0);
+        if (overrides.phyllotaxis_mode !== undefined) this.phyllotaxis_mode = overrides.phyllotaxis_mode;
+        return this;
+    }
+
+    /**
+     * @param {ShootSystemRule} other
+     * @returns {this}
+     */
+    copy(other) {
+        assert.defined(other, 'other');
+        this.source = other.source;
+        this.target = other.target.slice();
+        this.short_target = other.short_target;
+        this.max_order = other.max_order;
+        this.carrier_order = other.carrier_order;
+        this.terminal_length = other.terminal_length.slice();
+        this.terminal_length_slope = other.terminal_length_slope.slice();
+        this.max_unit_length = other.max_unit_length.slice();
+        this.length_negative_binomial_p = other.length_negative_binomial_p.slice();
+        this.mean_unit_length = other.mean_unit_length.slice();
+        this.zones = other.zones.map(z => z.clone());
+        this.short_shoot_growth = other.short_shoot_growth;
+        this.short_shoot_survival = other.short_shoot_survival;
+        this.insertion_angle = other.insertion_angle.slice();
+        this.phyllotaxis_mode = other.phyllotaxis_mode;
+        return this;
+    }
+
+    /**
+     * @returns {ShootSystemRule}
+     */
+    clone() {
+        const r = new ShootSystemRule();
+        r.copy(this);
+        return r;
+    }
+
+    /**
+     * @param {ShootSystemRule} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) return true;
+        if (!other || !other.isShootSystemRule) return false;
+        if (this.zones.length !== other.zones.length) return false;
+        for (let i = 0; i < this.zones.length; i++) {
+            if (!this.zones[i].equals(other.zones[i])) return false;
+        }
+        return this.source === other.source
+            && isArrayEqualStrict(this.target, other.target)
+            && this.short_target === other.short_target
+            && this.max_order === other.max_order
+            && this.carrier_order === other.carrier_order
+            && isArrayEqualStrict(this.terminal_length, other.terminal_length)
+            && isArrayEqualStrict(this.terminal_length_slope, other.terminal_length_slope)
+            && isArrayEqualStrict(this.max_unit_length, other.max_unit_length)
+            && isArrayEqualStrict(this.length_negative_binomial_p, other.length_negative_binomial_p)
+            && isArrayEqualStrict(this.mean_unit_length, other.mean_unit_length)
+            && this.short_shoot_growth === other.short_shoot_growth
+            && this.short_shoot_survival === other.short_shoot_survival
+            && isArrayEqualStrict(this.insertion_angle, other.insertion_angle)
+            && this.phyllotaxis_mode === other.phyllotaxis_mode;
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        let h = hash_mix2(this.source, computeHashFloatArray(this.target));
+        h = hash_mix2(h, this.short_target);
+        h = hash_mix2(h, this.max_order);
+        h = hash_mix2(h, this.carrier_order);
+        h = hash_mix2(h, computeHashFloatArray(this.terminal_length));
+        h = hash_mix2(h, computeHashFloatArray(this.terminal_length_slope));
+        h = hash_mix2(h, computeHashFloatArray(this.max_unit_length));
+        h = hash_mix2(h, computeHashFloatArray(this.length_negative_binomial_p));
+        h = hash_mix2(h, computeHashFloatArray(this.mean_unit_length));
+        for (let i = 0; i < this.zones.length; i++) {
+            h = hash_mix2(h, this.zones[i].hash());
+        }
+        h = hash_mix2(h, computeHashFloat(this.short_shoot_growth));
+        h = hash_mix2(h, computeHashFloat(this.short_shoot_survival));
+        h = hash_mix2(h, computeHashFloatArray(this.insertion_angle));
+        h = hash_mix2(h, this.phyllotaxis_mode | 0);
+        return h;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+ShootSystemRule.prototype.isShootSystemRule = true;
+
+/**
+ * @param {number[]} values
+ * @param {number} min
+ * @returns {number[]}
+ */
+function list(values, min) {
+    assert.isArray(values, 'values');
+    assert.greaterThan(values.length, 0, 'values.length');
+    return values.map(v => Math.max(min, v));
+}