def test_toString(self): """ tests __str__ output """ otp = rb.OrganRandomParameter(rb.Organism()) otp.name = "the great organ" otp.organType = 1 otp.subType = 2 self.assertEqual(otp.__str__(False), "Name: the great organ, organType: 1, subType, 2", "toString: value unexpected")
def root_example_rtp(self): """ an example used in the tests below, a main root with laterals """ self.plant = rb.Organism( ) # Root has no dependency on RootSystem anymore p0 = rb.RootRandomParameter(self.plant) p0.name, p0.type, p0.la, p0.lb, p0.nob, p0.ln, p0.r, p0.dx = "taproot", 1, 1, 10, 20, ( 89. / 19.), 1, 0.5 p0.successor = a2i([2]) # to rb.std_int_double_() p0.successorP = a2v([1.]) # rb.std_vector_double_() p1 = rb.RootRandomParameter(self.plant) p1.name, p1.type, p1.la, p1.ln, p1.r, p1.dx = "lateral", 2, 25, 0, 2, 0.1 self.p0, self.p1 = p0, p1 # Python will garbage collect them away, if not stored self.plant.setOrganRandomParameter( self.p0) # the organism manages the type parameters self.plant.setOrganRandomParameter(self.p1) self.param0 = self.p0.realize( ) # set up root by hand (without a root system) self.param0.la = 0 # its important parent has zero length, otherwise creation times are messed up self.param0.lb = 0 # param0 is stored, because otherwise garbage collection deletes it, an program will crash <--- parentroot = rb.Root(1, self.param0, True, True, 0., 0., rb.Vector3d(0, 0, -1), 0, 0, False, 0) parentroot.setOrganism(self.plant) parentroot.addNode(rb.Vector3d(0, 0, -3), 0) # there is no nullptr in Python self.root = rb.Root(self.plant, self.p0.subType, rb.Vector3d(0, 0, -1), 0, parentroot, 0, 0) self.root.setOrganism(self.plant)
def test_realize(self): """ calls realize """ otp = rb.OrganRandomParameter(rb.Organism()) otp.subType = 2 p = otp.realize(); self.assertEqual(p.__class__.__name__, "OrganSpecificParameter", "realize: unexpected class type") self.assertEqual(p.subType, 2, "realize: unexpected sub type")
def test_parameter(self): """ tests getParameter() """ plant = rb.Organism() srp = rb.SeedRandomParameter(plant) srp.firstB = 0.123 srp.delaySBs = 12 ot = srp.getParameter("organType") # test defaults st = srp.getParameter("subType") nz = srp.getParameter("nz") firstB = srp.getParameter("firstB") delaySBs = srp.getParameter("delaySB_dev") firstB2 = srp.getParameter( "firstB_mean" ) # we can always add "_mean" to avoid naming conflicts self.assertEqual(ot, 1., "getParameter: value unexpected") self.assertEqual(st, -1., "getParameter: value unexpected") self.assertEqual(nz, 1., "getParameter: value unexpected") self.assertEqual(firstB, 0.123, "getParameter: value unexpected") self.assertEqual(firstB, firstB2, "getParameter: value unexpected") self.assertEqual(delaySBs, 12, "getParameter: value unexpected") srp.firstB = 123 # change values srp.delaySBs = 456 firstB = srp.getParameter("firstB") delaySBs = srp.getParameter("delaySB_dev") self.assertEqual(firstB, 123, "getParameter: value unexpected") self.assertEqual(delaySBs, 456, "getParameter: value unexpected")
def test_toString(self): """ tests __str__ output """ self.rtp = rb.RootRandomParameter(rb.Organism()) self.add_successors() rtp = self.rtp # rename rtp.name = "the root" self.assertEqual(rtp.__str__(False), "Name: the root, organType: 2, subType, -1", "toString: value unexpected")
def test_parameter(self): """ tests getParameter() """ otp = rb.OrganRandomParameter(rb.Organism()) otp.organType = 1 otp.subType = 2 ot = otp.getParameter("organType") st = otp.getParameter("subType") self.assertEqual(ot, 1., "getParameter: value unexpected") self.assertEqual(st, 2., "getParameter: value unexpected")
def test_constructors(self): """ tests three different kinds of constructors """ human1 = rb.Organism() otp = rb.OrganRandomParameter(human1) human1.setOrganRandomParameter(otp) op = otp.realize() # 1. constructor from scratch hand = rb.Organ(human1.getOrganIndex(), op, True, True, 0, 15., False, 0) hand.setOrganism(human1) # 2. used in simulation (must have parent, since there is no nullptr in Pyhton) thumb = rb.Organ(human1, hand, 0, 0, 4) little_finger = rb.Organ(human1, hand, 0, 0, 3) hand.addChild(thumb) hand.addChild(little_finger) # 3. deep copy (with a factory function) human2 = rb.Organism() hand2 = hand.copy(human2) self.assertEqual(str(hand), str(hand2), "deep copy: the organs shold be equal") self.assertIsNot(hand.getParam(), hand2.getParam(), "deep copy: organs have same parameter set")
def test_toString(self): """ tests __str__ output """ self.srp = rb.SeedRandomParameter(rb.Organism()) srp = self.srp # rename srp.name = "the seed" # print(srp.__str__(False)) # print(srp) self.assertEqual(srp.__str__(False), "Name: the seed, organType: 1, subType, -1", "toString: value unexpected")
def root_example(self): """ example root parameters used below """ self.plant = rb.Organism() self.rtp = rb.RootRandomParameter(self.plant) self.rtp.la = 1.5 self.rtp.lb = 5.5 self.rtp.ln = 1.25 self.rtp.lns = 0.12 self.rtp.nob = 8 self.rtp.subType = 1
def test_constructors(self): """ tests constructor and copy """ plant = rb.Organism() otp = rb.OrganRandomParameter(plant) self.assertEqual(otp.name, "organ", "copy: default value unexpected") self.assertEqual(otp.organType, 0, "copy: default value unexpected") self.assertEqual(otp.subType, 0, "copy: default value unexpected") otp2 = otp.copy(plant) self.assertIsNot(otp, otp2, "copy: organ type parameter set is not copied") self.assertEqual(otp2.name, otp.name, "copy: value unexpected") self.assertEqual(otp2.organType, otp.organType, "copy: value unexpected") self.assertEqual(otp2.subType, otp.subType, "copy: value unexpected")
def shoot_example(self): """ example root parameters used below """ self.plant = rb.Organism() self.srp = rb.SeedRandomParameter(self.plant) self.srp.firstB = 10 self.srp.delayB = 7 self.srp.nC = 5 self.srp.firstSB = 21 self.srp.delaySB = 4 self.srp.delayRC = 15 self.srp.nz = 1. self.srp.subType = 0
def hand_example(self): """ an example used in the tests below, a hand with two fingers """ self.human1 = rb.Organism() # same example as in test_constructor ... otp = rb.OrganRandomParameter(self.human1) self.human1.setOrganRandomParameter(otp) op = otp.realize() self.hand = rb.Organ(self.human1.getOrganIndex(), op, True, True, 0, 15., False, 0) self.hand.setOrganism(self.human1) self.thumb = rb.Organ(self.human1, self.hand, 0, 0, 4) # delayedfor 4 days self.little_finger = rb.Organ(self.human1, self.hand, 0, 0, 3) # delayed for 3 days self.hand.addChild(self.thumb) self.hand.addChild(self.little_finger)
def test_organ_type_parameters(self): """ test ability to set, get, read, and write type parameters """ human1 = rb.Organism() # same example as in test_constructor ... otp1 = rb.OrganRandomParameter(human1) otp1.name = "nose" otp1.subType = 1 otp2 = rb.OrganRandomParameter(human1) otp2.subType = 2 otp2.name = "eye" human1.setOrganRandomParameter(otp1) # set human1.setOrganRandomParameter(otp2) otps = human1.getOrganRandomParameter(rb.OrganTypes.organ) self.assertEqual(otps[0].name, "nose", "otp: name not expected ") self.assertEqual(otps[1].name, "eye", "otp: name not expected ") otp3 = rb.OrganRandomParameter(human1) otp3.organType = rb.OrganTypes.root otp3.subType = 1 otp3.name = "rootyhand" human1.setOrganRandomParameter(otp3) human1.writeParameters("human.xml") human2 = rb.Organism() # read again prototype1 = rb.OrganRandomParameter(human2) prototype1.organType = rb.OrganTypes.organ prototype2 = rb.OrganRandomParameter(human2) prototype2.organType = rb.OrganTypes.root human2.setOrganRandomParameter( prototype1 ) # set prototypes for reading, subTypes are overwritten if equal human2.setOrganRandomParameter(prototype2) human2.readParameters("human.xml") otp1 = human2.getOrganRandomParameter(rb.OrganTypes.organ, 1) otp2 = human2.getOrganRandomParameter(rb.OrganTypes.organ, 2) self.assertEqual(otp1.name, "nose", "otp: name not expected ") self.assertEqual(otp2.name, "eye", "otp: name not expected ") self.assertEqual(otp1.subType, 1, "otp: subType not expected ") self.assertEqual(otp2.subType, 2, "otp: subType not expected ") rtp = human2.getOrganRandomParameter(rb.OrganTypes.root, 1) self.assertEqual(rtp.name, "rootyhand", "otp: name not expected ") self.assertEqual(rtp.subType, 1, "otp: subType not expected ")
def test_xml(self): """ write the organ type parameter as xml, and rereads it """ plant = rb.Organism() otp = rb.OrganRandomParameter(plant) otp.name = "the great organ" otp.organType = 1 # seed otp.subType = 2 otp.writeXML("organ.xml") otp2 = rb.OrganRandomParameter(plant) otp2.readXML("organ.xml") self.assertEqual(otp2.name, otp.name, "xml: value unexpected") self.assertEqual(otp2.organType, otp.organType, "xml: value unexpected") self.assertEqual(otp2.subType, otp.subType, "xml: value unexpected")
def test_constructors(self): """ tests constructor and copy """ plant = rb.Organism() srp = rb.SeedRandomParameter(plant) srp.firstB = 123 srp.firstBs = 456 srp.nz = 789 srp2 = srp.copy(plant) self.assertIsNot(srp, srp2, "copy: organ type parameter set is not copied") self.assertEqual(srp2.name, srp.name, "copy: value unexpected") self.assertEqual(srp2.organType, srp.organType, "copy: value unexpected") self.assertEqual(srp2.subType, srp.subType, "copy: value unexpected") self.assertEqual(srp2.firstB, srp.firstB, "copy: value unexpected") self.assertEqual(srp2.firstBs, srp.firstBs, "copy: value unexpected") self.assertEqual(srp2.nz, srp.nz, "copy: value unexpected")
def test_copy(self): """ checks if the organism is properly copied """ self.hand_example() self.add_nodes() human2 = rb.Organism(self.human1) # copy constructor self.assertIsNot(self.human1, human2, "copy: not a copy") self.assertEqual(self.human1.rand(), human2.rand(), "copy: random generator seed was not copied") o1 = self.human1.getOrgans() # check organs o2 = human2.getOrgans() self.assertEqual(len(o2), 3, "copy: unexpected number of organs") for i in range(0, len(o1)): self.assertIsNot(o1[i], o2[i], "copy: organ is not copied") p1 = self.human1.getOrganRandomParameter(0) p2 = human2.getOrganRandomParameter(0) for i in range(0, len(p1)): self.assertIsNot(p1[i], p2[i], "copy: OrganTypeParameters is not copied")
def test_constructors(self): """ tests constructor and copy """ plant = rb.Organism() otp = rb.RootRandomParameter(plant) otp.theta = 123 otp.thetas = 456 otp.gf = 789 otp2 = otp.copy(plant) self.assertIsNot(otp, otp2, "copy: organ type parameter set is not copied") self.assertEqual(otp2.name, otp.name, "copy: value unexpected") self.assertEqual(otp2.organType, otp.organType, "copy: value unexpected") self.assertEqual(otp2.subType, otp.subType, "copy: value unexpected") self.assertEqual(otp2.a, otp.a, "copy: value unexpected") self.assertEqual(otp2.theta, otp.theta, "copy: value unexpected") self.assertEqual(otp2.thetas, otp.thetas, "copy: value unexpected") self.assertEqual(otp2.gf, otp.gf, "copy: value unexpected")
def test_constructors(self): """ tests three different kinds of constructors """ self.root_example_rtp() # 1. constructor from scratch param = self.p0.realize() root = rb.Root(1, param, True, True, 0., 0., rb.Vector3d(0, 0, -1), 0, 0, False, 0) root.setOrganism(self.plant) root.addNode(rb.Vector3d(0, 0, -3), 0) # parent must have at least one nodes # 2. used in simulation (must have parent, since there is no nullptr in Pyhton) root2 = rb.Root(self.plant, self.p1.subType, rb.Vector3d(0, 0, -1), 0, root, 0, 0) root.addChild(root2) # 3. deep copy (with a factory function) plant2 = rb.Organism() root3 = root.copy(plant2) self.assertEqual(str(root), str(root3), "deep copy: the organs shold be equal") self.assertIsNot(root.getParam(), root3.getParam(), "deep copy: organs have same parameter set")
def test_parameter(self): """ tests getParameter() """ rtp = rb.RootRandomParameter(rb.Organism()) rtp.lns = 0.123 rtp.la = 12 ot = rtp.getParameter("organType") # test defaults st = rtp.getParameter("subType") gf = rtp.getParameter("gf") ln = rtp.getParameter("ln") lns = rtp.getParameter("ln_dev") la = rtp.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") rtp.theta = 123 # change values rtp.thetas = 456 theta = rtp.getParameter("theta") thetas = rtp.getParameter("theta_dev") self.assertEqual(theta, 123, "getParameter: value unexpected") self.assertEqual(thetas, 456, "getParameter: value unexpected")