def root_example_rrp(self):
""" an example used in the tests below, a main root with laterals """
self.plant = pb.Organism(
) # store organism (not owned by Organ, or OrganRandomParameter)
p0 = pb.RootRandomParameter(self.plant)
p0.name, p0.subType, p0.la, p0.lb, p0.lmax, p0.ln, p0.r, p0.dx = "taproot", 1, 10., 1., 100., 1., 1.5, 0.5
p0.successor = [2]
p0.successorP = [1.]
p1 = pb.RootRandomParameter(self.plant)
p1.name, p1.subType, p1.lmax, p1.r, p1.dx = "lateral", 2, 25., 2., 0.1
self.p0, self.p1 = p0, p1 # needed at later point
self.plant.setOrganRandomParameter(
p0) # the organism manages the type parameters and takes ownership
self.plant.setOrganRandomParameter(p1)
srp = pb.SeedRandomParameter(self.plant)
self.plant.setOrganRandomParameter(srp)
param0 = p0.realize() # set up root by hand (without a root system)
param0.la, param0.lb = 0, 0 # its important parent has zero length, otherwise creation times are messed up
parentroot = pb.Root(1, param0, True, True, 0., 0.,
pb.Vector3d(0, 0, -1), 0, 0, False,
0) # takes ownership of param0
parentroot.setOrganism(self.plant)
parentroot.addNode(pb.Vector3d(0, 0, -3),
0) # there is no nullptr in Python
self.parentroot = parentroot # store parent (not owned by child Organ)
self.root = pb.Root(self.plant, p0.subType, pb.Vector3d(0, 0, -1), 0,
self.parentroot, 0, 0)
self.root.setOrganism(self.plant)
def test_initialize(self):
""" test initialization (! most important) """
srp = self.get_srp()
seed = pb.Seed(self.plant)
# print(seed)
tap_rp = pb.RootRandomParameter(self.plant)
tap_rp.name = "taproot"
tap_rp.subType = seed.tapType # 1
basal_rp = pb.RootRandomParameter(self.plant)
basal_rp.name = "basalroot"
basal_rp.subType = seed.basalType # 4
shootborne_rp = pb.RootRandomParameter(self.plant)
shootborne_rp.name = "shootborneroot"
shootborne_rp.subType = seed.shootborneType # 5
self.plant.setOrganRandomParameter(tap_rp)
self.plant.setOrganRandomParameter(basal_rp)
self.plant.setOrganRandomParameter(shootborne_rp)
seed.initialize(False) # A CRootBox initializations (now StemRandomParameter set)
# print("CRootBox initialization (including shootborne)")
organs = seed.baseOrgans()
st_ = []
ot_ = []
for o in organs:
st_ .append(o.getParameter("subType"))
ot_ .append(o.getParameter("organType"))
norc = int(((365 - srp.firstSB) / srp.delayRC) + 0.5)
self.assertEqual(norc, seed.getNumberOfRootCrowns(), "wrong number of root crowns")
maxB = min(srp.maxB, int(((365 - srp.firstB) / srp.delayB) + 0.5))
self.assertEqual(len(st_), norc * srp.nC + 1 + maxB, "wrong number of roots created")
seed = pb.Seed(self.plant)
stem_rp = pb.StemRandomParameter(self.plant)
stem_rp.name = "stem"
stem_rp.subType = seed.mainStemType # 1
tiller_rp = pb.StemRandomParameter(self.plant)
tiller_rp.name = "tiller"
tiller_rp.subType = seed.tillerType # 4
self.plant.setOrganRandomParameter(stem_rp)
self.plant.setOrganRandomParameter(tiller_rp)
seed.initialize(False) # A CPlantBox initializations (now StemRandomParameter set)
organs = seed.baseOrgans()
# print("CPlantBox initialization (no shootborne, since they emerge from the stem)")
st_ = []
ot_ = []
for o in organs:
# print(o)
st_ .append(o.getParameter("subType"))
ot_ .append(o.getParameter("organType"))
st = [1.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 1.0, 4.0, 4.0, 4.0]
ot = [2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 3.0, 3.0, 3.0, 3.0]
for i in range(0, len(organs)):
self.assertEqual(st_[i], st[i], "no tap root produced")
self.assertEqual(ot_[i], ot[i], "tap root produced wrong organ type")
def test_parameter(self):
""" tests getParameter() """
self.plant = pb.Organism()
rrp = pb.RootRandomParameter(self.plant)
rrp.lns = 0.123
rrp.la = 12
ot = rrp.getParameter("organType") # test defaults
st = rrp.getParameter("subType")
gf = rrp.getParameter("gf")
ln = rrp.getParameter("ln")
lns = rrp.getParameter("ln_dev")
la = rrp.getParameter(
"la_mean") # we can always add "_mean" to avoid naming conflicts
self.assertEqual(ot, 2., "getParameter: value unexpected")
self.assertEqual(st, -1., "getParameter: value unexpected")
self.assertEqual(gf, 1., "getParameter: value unexpected")
self.assertEqual(ln, 1., "getParameter: value unexpected")
self.assertEqual(lns, 0.123, "getParameter: value unexpected")
self.assertEqual(la, 12, "getParameter: value unexpected")
rrp.theta = 123 # change values
rrp.thetas = 456
theta = rrp.getParameter("theta")
thetas = rrp.getParameter("theta_dev")
self.assertEqual(theta, 123, "getParameter: value unexpected")
self.assertEqual(thetas, 456, "getParameter: value unexpected")
def root_example_rrp2(self):
""" an example used in the tests below, a main root with laterals """
self.plant = pb.RootSystem(
) # store organism (not owned by Organ, or OrganRandomParameter)
p0 = pb.RootRandomParameter(self.plant)
p0.name, p0.subType, p0.la, p0.lb, p0.lmax, p0.ln, p0.lnk, p0.r, p0.dx, p0.dxMin = "taproot", 1, 0.95, 0.8, 10., 1.05, 0.01, 0.8, 0.25, 0.2
p0.successor = [2]
p0.successorP = [1.]
p1 = pb.RootRandomParameter(self.plant)
p1.name, p1.subType, p1.lmax, p1.r, p1.dx = "lateral", 2, 2., 2., 2.
self.plant.setOrganRandomParameter(
p0) # the organism manages the type parameters and takes ownership
self.plant.setOrganRandomParameter(p1)
srp = pb.SeedRandomParameter(self.plant)
self.plant.setOrganRandomParameter(srp)
print("root p0, initial parameters: lmax = ", p0.lmax, ", lb = ",
p0.lb, ", la = ", p0.la, ", ln = ", p0.ln)
param0 = p0.realize() # set up root by hand (without a root system)
print("root p0, realized parameters: lmax = ",
sum((sum(param0.ln), param0.lb, param0.la)), ", lb = ",
param0.lb, ", la = ", param0.la, ", mean ln = ",
np.mean(param0.ln))
if ((param0.lb % p0.dx > 0) and (param0.lb % p0.dx < p0.dxMin * 0.99)):
print("lb value does not fit with dx and dxMin")
print(param0.lb % p0.dx)
if ((param0.la % p0.dx > 0) and (param0.la % p0.dx < p0.dxMin * 0.99)):
print("la value does not fit with dx and dxMin")
print(param0.la % p0.dx)
if (any([(lni % p0.dx > 0 and lni % p0.dx < p0.dxMin * 0.99)
for lni in param0.ln])):
print("ln value does not fit with dx and dxMin")
param0.la, param0.lb = 0, 0 # its important parent has zero length, otherwise creation times are messed up
parentroot = pb.Root(1, param0, True, True, 0., 0.,
pb.Vector3d(0, 0, -1), 0, 0, False,
0) # takes ownership of param0
parentroot.setOrganism(self.plant)
parentroot.addNode(pb.Vector3d(0, 0, -1),
0) # there is no nullptr in Python
self.parentroot = parentroot # store parent (not owned by child Organ)
self.root = pb.Root(self.plant, p0.subType, pb.Vector3d(0, 0, -1), 0,
self.parentroot, 0, 0)
self.root.setOrganism(self.plant)
self.p0 = p0
def test_toString(self):
""" tests __str__ output """
self.rrp = pb.RootRandomParameter(pb.Organism())
rrp = self.rrp # rename
rrp.name = "the root"
self.assertEqual(rrp.__str__(False),
"name: the root, organType: 2, subType: -1.",
"toString: value unexpected")
def rs_example_rtp(self):
""" an example used in some of the tests below, 100 basals with laterals """
self.rs = pb.RootSystem()
srp = pb.SeedRandomParameter(self.rs)
srp.subType = 0
srp.seedPos = pb.Vector3d(0., 0., -3.)
srp.maxB = 100
srp.firstB = 10
srp.delayB = 3
self.rs.setRootSystemParameter(srp)
p0 = pb.RootRandomParameter(self.rs)
p0.name, p0.subType, p0.la, p0.lmax, p0.ln, p0.r, p0.dx = "taproot", 1, 10, 101, 89. / 19., 1, 0.5
p0.lb = 2
p0.successor = [2]
p0.successorP = [1.]
p1 = pb.RootRandomParameter(self.rs)
p1.name, p1.subType, p1.la, p1.ln, p1.r, p1.dx = "lateral", 2, 25, 0, 2, 0.1
self.p0, self.p1, self.srp = p0, p1, srp # Python will garbage collect them away, if not stored
self.rs.setOrganRandomParameter(p0) # the organism manages the type parameters
self.rs.setOrganRandomParameter(p1)
def root_example(self):
""" example root parameters used below """
self.plant = pb.Organism()
self.rrp = pb.RootRandomParameter(self.plant)
self.rrp.la = 1.5
self.rrp.lb = 5.5
self.rrp.ln = 1.25
self.rrp.lns = 0.12
self.rrp.lmax = 7 * self.rrp.ln + self.rrp.la + self.rrp.lb
self.rrp.subType = 1
self.rrp.successor = [4, 5, 6]
self.rrp.successorP = [0.4, 0.1, 0.5]
self.rrp.ldelay = 5
self.rrp.ldelays = 2
def test_constructors(self):
""" tests constructor and copy """
plant = pb.Organism()
rrp = pb.RootRandomParameter(plant)
rrp.theta = 123
rrp.thetas = 456
rrp.gf = 789
otp2 = rrp.copy(plant)
self.assertIsNot(rrp, otp2,
"copy: organ type parameter set is not copied")
self.assertEqual(otp2.name, rrp.name, "copy: value unexpected")
self.assertEqual(otp2.organType, rrp.organType,
"copy: value unexpected")
self.assertEqual(otp2.subType, rrp.subType, "copy: value unexpected")
self.assertEqual(otp2.a, rrp.a, "copy: value unexpected")
self.assertEqual(otp2.theta, rrp.theta, "copy: value unexpected")
self.assertEqual(otp2.thetas, rrp.thetas, "copy: value unexpected")
self.assertEqual(otp2.gf, rrp.gf, "copy: value unexpected")
def open_folder(self, folder_name):
""" see RsmlData.open_rsml() in src/python_modules/rsml_data.py
"""
self.rsmls = [] # delete old data
self.folder_name = folder_name
for root, subdirs, files in os.walk(folder_name):
for filename in files:
if filename.endswith('.rsml'):
file_path = os.path.join(root, filename)
print()
print('file %s (full path: %s)\n' % (filename, file_path))
print()
self.file_names.append(filename)
file_data = RsmlData()
file_data.open_rsml(file_path)
if not "order" in file_data.properties: # check if orders were created, if not create tag
file_data.properties[
"order"] = rsml_reader.get_root_orders(
file_data.properties)
self.rsmls.append(file_data)
try:
if file_data.tagnames[1]:
self.times.append(file_data.max_ct
) # check for creation_time tag
# self.times.append(11.) # TESTING
else:
s = filename.split(".")
str = ''.join(
[n for n in s[0][-3:] if n.isdigit()])
self.times.append(int(str))
except:
print("filename", filename)
self.times.append(0)
self.estimates = [None] * len(self.times)
self.parameters = [
pb.RootRandomParameter(self.plant) for _ in range(0, 10)
]
self.create_length() # add a length tag to properties
self.initialize_roots_() # find base roots
def test_xml(self):
""" write the organ as xml, and rereads it """
self.root_example()
rrp = self.rrp # rename
rrp.name = "lateral"
rrp.subType = 2
rrp.writeXML("root.xml")
otp2 = pb.RootRandomParameter(self.plant)
otp2.readXML("root.xml")
self.assertEqual(otp2.ldelay, rrp.ldelay, "xml: value unexpected")
self.assertEqual(otp2.ldelays, rrp.ldelays, "xml: value unexpected")
self.assertEqual(otp2.name, rrp.name, "xml: value unexpected")
self.assertEqual(otp2.organType, rrp.organType,
"xml: value unexpected")
self.assertEqual(otp2.subType, rrp.subType, "xml: value unexpected")
self.assertEqual(otp2.nob(), rrp.nob(),
"xml: value unexpected") # value
self.assertEqual(otp2.lns, rrp.lns, "xml: value unexpected") # dev
for i in range(0, 3):
self.assertEqual(otp2.successor[i], rrp.successor[i],
"xml: value unexpected")
for i in range(0, 3):
self.assertAlmostEqual(otp2.successorP[i], rrp.successorP[i], 7,
"xml: value unexpected")
super(Boundary_Elongation_Impedance, self).__init__()
self.geometry = geometry
self.impedance = impedance
def getValue(self, pos, root):
# print("Root", root)
# print("Root tip position", pos)
d = self.geometry.getDist(pos)
if d < 0:
return 1.
else:
return 1. * self.impedance
rs = pb.RootSystem()
p0, p1, p2 = pb.RootRandomParameter(rs), pb.RootRandomParameter(
rs), pb.RootRandomParameter(rs)
""" tap root """
p0.name, p0.subType = "taproot", 1
p0.successor, p0.successorP = [2], [1] # add successors
p0.dx = 0.5 # [cm] axial resolution
# from faba_taproot, faba_laterals
p0.a, p0.a_s = 0.125, 0.017 # [cm] radius TODO
p0.lb, p0.lbs = 1.007, 0.492 # [cm] basal zone
p0.la, p0.las = 9.973, 1.992 # [cm] apical zone
p0.ldelay, p0.ldelays = 5.112, 0.5 # [d] delay
p0.lmax = 150 # [cm] maximal root length, number of lateral branching nodes = round((lmax-lb-la)/ln) + 1
p0.ln, p0.lns = 0.157, 0.224 # [cm] inter-lateral distance (16 branching nodes)
p0.theta = 0. # [rad]
p0.r = 2.071 # [cm/day] initial growth rate
# visual comparison
"""everything from scratch (without parameter files)"""
import sys
sys.path.append("../../..")
import plantbox as pb
import vtk_plot as vp
import matplotlib.pyplot as plt
import numpy as np
rs = pb.RootSystem()
p0 = pb.RootRandomParameter(rs) # with default values,
p1 = pb.RootRandomParameter(rs) # all standard deviations are 0
p0.name = "taproot"
p0.a = 0.2 # [cm] radius
p0.subType = 1 # [-] index starts at 1
p0.lb = 5 # [cm] basal zone
p0.la = 10 # [cm] apical zone
p0.lmax = 30 # [cm] maximal root length, number of lateral branching nodes = round((lmax-lb-la)/ln) + 1
p0.ln = 1. # [cm] inter-lateral distance (16 branching nodes)
p0.theta = 0. # [rad]
p0.r = 1 # [cm/day] initial growth rate
p0.dx = 10 # [cm] axial resolution
p0.successor = [2] # add successors
p0.successorP = [1] # probability that successor emerges
p0.tropismT = pb.TropismType.gravi #
p0.tropismN = 1.8 # [-] strength of tropism
p0.tropismS = 0.2 # [rad/cm] maximal bending
p1.name = "lateral"
import sys
from cmath import pi
sys.path.append("../../..")
import plantbox as pb
import numpy as np
import matplotlib.pyplot as plt
path = "../../modelparameter/rootsystem/"
rs = pb.RootSystem()
################### set parameters ##########################################
# Root random parameter
p0 = pb.RootRandomParameter(rs) # with default values,
p0.name = "taproot"
p0.a = 0.2 # cm radius
p0.subType = 1
p0.lb = 1
p0.la = 10
p0.lmax = 200
p0.ln = 20.
p0.theta = 0.
p0.r = 2.0 # initial growth rate
p0.dx = 0.5
p0.gf = 2
p0.tropismT = pb.TropismType.gravi
p0.tropismN = 1.
p0.tropismS = 0.0
def create_basil(): plant = pb.Plant() p0 = pb.RootRandomParameter(plant) # with default values, p1 = pb.RootRandomParameter(plant) # all standard deviations are 0 s2 = pb.StemRandomParameter(plant) s3 = pb.StemRandomParameter(plant) l1 = pb.LeafRandomParameter(plant) p0.name = "taproot" p0.a = 0.2 # [cm] radius p0.subType = 1 # [-] index starts at 1 p0.lb = 5 # [cm] basal zone p0.la = 10 # [cm] apical zone p0.lmax = 30 # [cm] maximal root length, number of lateral branching nodes = round((lmax-lb-la)/ln) + 1 p0.ln = 1. # [cm] inter-lateral distance (16 branching nodes) p0.theta = 0. # [rad] p0.r = 1 # [cm/day] initial growth rate p0.dx = 10 # [cm] axial resolution p0.successor = [2] # add successors p0.successorP = [1] # probability that successor emerges p0.tropismT = pb.TropismType.gravi # p0.tropismN = 1.8 # [-] strength of tropism p0.tropismS = 0.2 # [rad/cm] maximal bending p1.name = "lateral" p1.a = 0.1 # [cm] radius p1.subType = 2 # [1] index starts at 1 p1.lmax = 15 # # [cm] apical zone p1.lmaxs = 0.15 # [cm] standard deviation of the apical zone p1.theta = 90. / 180. * np.pi # [rad] p1.r = 2 # initial growth rate p1.dx = 1 # [cm] axial resolution p1.tropismT = pb.TropismType.gravi # exo p1.tropismN = 2 # [-] strength of tropism p1.tropismS = 0.1 # [rad/cm] maximal bending s2.name = "mainstem" s2.subType = 1 s2.lmax = 25 # s2.lmaxs = 1 s2.lb = 3 s2.la = 0 s2.ln = 3 # This value is normally the Inter-lateral distance [cm], but with decussate plant, this value is # multiplied by 2 s2.lnf = 5 # This value means "successors in a decussate position" s2.RotBeta = 1 s2.BetaDev = 0 s2.InitBeta = 0 s2.gf = 1 s2.successor = [2] s2.successorP = [1] s2.tropismT = 4 # s2.theta = 1/6 s2.theta = 0 s2.tropismN = 18 s2.tropismS = 0.01 s3.name = "invisible" # The invisible stem representing the bud of the leaf s3.subType = 2 s3.la = 0 s3.ln = 0 s3.lmax = 5 s3.RotBeta = 1 s3.BetaDev = 0 s3.InitBeta = 0.5 s3.tropismS = 0 s3.lnf = 5 l1.name = 'basil' l1.subType = 2 l1.lb = 2 l1.la = 0.2 l1.lmax = 5 l1.r = 0.5 l1.RotBeta = 0.5 l1.BetaDev = 0 l1.InitBeta = 0.5 l1.tropismT = 1 l1.tropismN = 5 l1.tropismS = 0.1 l1.theta = 0.35 l1.thetas = 0.05 l1.gf = 1 l1.lnf = 5 # If not precised, it will not be possible to do the opposite decussate arrangement plant.setOrganRandomParameter(p0) plant.setOrganRandomParameter(p1) plant.setOrganRandomParameter(s2) plant.setOrganRandomParameter(s3) plant.setOrganRandomParameter(l1) srp = pb.SeedRandomParameter(plant) # with default values # srp.seedPos = pb.Vector3d(10, 10, -3.) # [cm] seed position srp.seedPos = pb.Vector3d(0, 0, -3.) # [cm] seed position srp.maxB = 0 # [-] number of basal roots (neglecting basal roots and shoot borne) srp.firstB = 10. # [day] first emergence of a basal root srp.delayB = 3. # [day] delay between the emergence of basal roots plant.setOrganRandomParameter(srp) return plant
def create_arabidopsis(): plant = pb.Plant() p0 = pb.RootRandomParameter(plant) # with default values, p1 = pb.RootRandomParameter(plant) # all standard deviations are 0 s1 = pb.StemRandomParameter(plant) s2 = pb.StemRandomParameter(plant) s3 = pb.StemRandomParameter(plant) s4 = pb.StemRandomParameter(plant) l1 = pb.LeafRandomParameter(plant) p0.name = "taproot" p0.a = 0.2 # [cm] radius p0.subType = 1 # [-] index starts at 1 p0.lb = 5 # [cm] basal zone p0.la = 10 # [cm] apical zone p0.lmax = 30 # [cm] maximal root length, number of lateral branching nodes = round((lmax-lb-la)/ln) + 1 p0.ln = 1. # [cm] inter-lateral distance (16 branching nodes) p0.theta = 0. # [rad] p0.r = 1 # [cm/day] initial growth rate p0.dx = 10 # [cm] axial resolution p0.successor = [2] # add successors p0.successorP = [1] # probability that successor emerges p0.tropismT = pb.TropismType.gravi # p0.tropismN = 1.8 # [-] strength of tropism p0.tropismS = 0.2 # [rad/cm] maximal bending p1.name = "lateral" p1.a = 0.1 # [cm] radius p1.subType = 2 # [1] index starts at 1 p1.lmax = 15 # # [cm] apical zone p1.lmaxs = 0.15 # [cm] standard deviation of the apical zone p1.theta = 90. / 180. * np.pi # [rad] p1.r = 2 # initial growth rate p1.dx = 1 # [cm] axial resolution p1.tropismT = pb.TropismType.gravi # exo p1.tropismN = 2 # [-] strength of tropism p1.tropismS = 0.1 # [rad/cm] maximal bending s1.name = "mainstem" s1.subType = 1 s1.lmax = 25 s1.lmaxs = 1 s1.lb = 0 s1.lbs = 0.1 s1.la = 3 s1.las = 0.1 s1.ln = 3 s1.lns = 0.2 s1.lnf = 0 # 1 peut être cool s1.RotBeta = 0 s1.BetaDev = 0 s1.InitBeta = 0 s1.gf = 1 s1.successor = [3, 2] s1.successorP = [0.3, 0.7] # s1.successor = [3] # s1.successorP = [1] s1.tropismT = 1 s1.theta = 0. s1.thetas = 0.05 s1.tropismN = 2 s1.tropismS = 0.005 s1.r = 1 s1.rs = 0.05 s2.name = "secondary_stem" s2.subType = 3 s2.lmax = 7 s2.lmaxs = 0.2 s2.lb = 0 s2.la = 2 s2.ln = 2 s2.lns = 0.1 s2.lnf = 0 s2.RotBeta = 2 / 3 s2.BetaDev = 0.1 s2.InitBeta = 0 s2.gf = 1 s2.successor = [2] s2.successorP = [1] s2.tropismT = 4 s2.theta = 0.3 s2.thetas = 0.02 s2.tropismN = 18 s2.tropismS = 0.01 s2.r = 0.5 s2.rs = 0.02 s3.name = "invisible stem" s3.subType = 2 s3.lmax = 5 s3.la = 0 s3.ln = 0 s3.RotBeta = 2/3 s3.BetaDev = 0 s3.InitBeta = 0. s3.lb = 0 s3.la = 0 s3.ln = 0 s3.lnf = 0 s3.RotBeta = 2 / 3 s3.BetaDev = 0 s3.InitBeta = 0 s3.gf = 1 s3.tropismT = 1 s3.theta = 0.3 s3.tropismN = 18 s3.tropismS = 0.01 s3.r = 1 l1.name = 'leaf_under_second_stem' l1.subType = 2 l1.lb = 2 l1.la = 0.2 l1.lmax = 5 l1.lmaxs = 0.1 l1.r = 0.5 l1.rs = 0.02 l1.RotBeta = 0.5 l1.BetaDev = 0 l1.InitBeta = 0. l1.tropismT = 1 l1.tropismN = 5 l1.tropismS = 0.15 l1.theta = 0.35 l1.gf = 1 s4.name = "rosette" # Cannot be a leaf organ because we can only create 1 leaf organ subType s4.subType = 4 s4.lmax = 10 s4.lmaxs = 0.2 s4.lb = 1 s4.la = 0 s4.ln = 2 s4.lnf = 0 s4.RotBeta = 3 / 5 s4.BetaDev = 0.02 s4.InitBeta = 0 s4.gf = 1 s4.tropismT = 1 s4.theta = 0.3 s4.thetas = 0.02 s4.tropismN = 18 s4.tropismS = 0.01 s4.r = 0.5 s4.rs = 0.02 plant.setOrganRandomParameter(p0) plant.setOrganRandomParameter(p1) plant.setOrganRandomParameter(s1) plant.setOrganRandomParameter(s2) plant.setOrganRandomParameter(s3) plant.setOrganRandomParameter(s4) plant.setOrganRandomParameter(l1) srp = pb.SeedRandomParameter(plant) # with default values srp.seedPos = pb.Vector3d(0., 0., -3.) # [cm] seed position srp.maxB = 0 # [-] number of basal roots (neglecting basal roots and shoot borne) srp.firstB = 10. # [day] first emergence of a basal root srp.delayB = 3. # [day] delay between the emergence of basal roots srp.maxTil = 10 plant.setOrganRandomParameter(srp) return plant
sys.path.append("../../../src/python_modules")
import plantbox as pb
import matplotlib.pyplot as plt
import numpy as np
fig, axes = plt.subplots(2, 3, figsize=(15, 7))
rs = pb.RootSystem()
srp = pb.SeedRandomParameter(rs)
srp.firstB, srp.delayB, srp.maxB = 1., 1., 0
rs.setRootSystemParameter(srp)
dx0, dx1 = 100, 1 # very large resolution for taproot
theta = 70 / 180 * np.pi
p0 = pb.RootRandomParameter(rs)
p0.name, p0.subType, p0.lmax, p0.r, p0.dx, p0.theta = "taproot", 1, 50., 2., dx0, 0. # parameters as before
p0.tropismT, p0.tropismN, p0.tropismS = pb.TropismType.gravi, 2, 0.1
p0.successor, p0.successorP = [2], [1.] # set up successors
p0.lns = 0. # test with other values...
p0.lb, p0.la = 0., 0.
rs.setOrganRandomParameter(p0)
p1 = pb.RootRandomParameter(rs)
p1.name, p1.subType, p1.lmax, p1.r, p1.dx, p1.theta = "lateral", 2, 30., 1., dx1, theta
p1.tropismT, p1.tropismN, p1.tropismS = pb.TropismType.exo, 2, 0.2
rs.setOrganRandomParameter(p1)
ln_ = [4., 2.] # inter lateral distance
lnk_ = [-2. / 45., 0, 2. / 45] # slope
import sys; sys.path.append(".."); sys.path.append("../../src/python_modules"); sys.path.append("../../")
import numpy as np
import matplotlib.pyplot as plt
import plantbox as pb
import vtk_plot as vp
plant = pb.Plant()
seed_rp = pb.SeedRandomParameter(plant)
seed_rp.subType = 0
plant.setOrganRandomParameter(seed_rp)
root_rp = pb.RootRandomParameter(plant)
root_rp.subType = 1
root_rp.lmax = 1
root_rp.r = 0.1
root_rp.theta = 0
plant.setOrganRandomParameter(root_rp)
stem_rp = pb.StemRandomParameter(plant)
stem_rp.subType = 1
stem_rp.la = 1.
stem_rp.lb = 5
stem_rp.lmax = 7.5
stem_rp.ln = 1
stem_rp.theta = 0
stem_rp.successor = [2]
stem_rp.successorP = [1]
plant.setOrganRandomParameter(stem_rp)
