Upda API and README

Author: AleMorales

.github/workflows/CI.yml

@@ -35,7 +35,7 @@ jobs:
         id: referencetests
         continue-on-error: true
         run: >
-          DISPLAY=:0 xvfb-run -s '-screen 0 1024x768x24' julia --color=yes -e 'using Pkg; Pkg.test("VPL", coverage=true)'
+          DISPLAY=:0 xvfb-run -s '-screen 0 1024x768x24' julia --color=yes -e 'using Pkg; Pkg.test("VirtualPlantLab", coverage=true)'
           && echo "TESTS_SUCCESSFUL=true" >> $GITHUB_ENV
         env:
           CI: true

Project.toml

@@ -1,7 +1,7 @@
-name = "VPL"
+name = "VirtualPlantLab"
 uuid = "b977ecfa-1b9a-418d-909d-4ebe565736ce"
 authors = ["Alejandro Morales Sierra <alejandro.moralessierra@wur.nl> and contributors"]
-version = "0.0.1"
+version = "0.0.2"
 
 [deps]
 PlantGeomPrimitives = "7eef3cc5-4580-4ff0-8f6f-933507db6664"
@@ -12,10 +12,10 @@ PlantViz = "358bd95d-d12c-439f-94b7-04b17e500c7f"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 
 [compat]
-PlantGeomPrimitives = "0.0.1"
-PlantGeomTurtle = "0.0.1"
-PlantGraphs = "0.0.1"
-PlantRayTracer = "0.0.1"
-PlantViz = "0.0.1"
+PlantGeomPrimitives = "0.0.2"
+PlantGeomTurtle = "0.0.2"
+PlantGraphs = "0.0.2"
+PlantRayTracer = "0.0.2"
+PlantViz = "0.0.2"
 Reexport = "1.2.2"
 julia = "1.9"

README.md

@@ -1,9 +1,56 @@
-# VPL
+# VirtualPlantLab
 
 [![Stable](https://img.shields.io/badge/docs-stable-blue.svg)](http://virtualplantlab.com/)
-[![CI](https://github.com/VirtualPlantLab/VPL.jl/actions/workflows/CI.yml/badge.svg)](https://github.com/VirtualPlantLab/VPL.jl/actions/workflows/CI.yml)
+[![CI](https://github.com/VirtualPlantLab/VirtualPlantLab.jl/actions/workflows/CI.yml/badge.svg)](https://github.com/VirtualPlantLab/VirtualPlantLab.jl/actions/workflows/CI.yml)
 [![SciML Code Style](https://img.shields.io/static/v1?label=code%20style&message=SciML&color=9558b2&labelColor=389826)](https://github.com/SciML/SciMLStyle)
 [![ColPrac: Contributor's Guide on Collaborative Practices for Community Packages](https://img.shields.io/badge/ColPrac-Contributor's%20Guide-blueviolet)](https://github.com/SciML/ColPrac)
 [![Aqua QA](https://raw.githubusercontent.com/JuliaTesting/Aqua.jl/master/badge.svg)](https://github.com/JuliaTesting/Aqua.jl)
 
-Main package in the [Virtual Plant Lab](http://virtualplantlab.com/).
+This is the main package in the [Virtual Plant Lab](http://virtualplantlab.com/) that users
+are meant to download and use. It is a meta-package that includes all the other packages
+in the VirtualPlantLab organization where the different features are implemented. The user
+does not need to be aware of the other packages, except in cases where methods need to be
+define for user-defined types (currently that is the case for `PlantGeomTurtle.feed!()`
+which is required to generate geometry from user-defined types).
+
+# 1. Instalation
+
+You can install the latest stable version of PlantGraphs.jl with the Julia package manager:
+
+```julia
+] add VirtualPlantLab
+```
+
+Or the development version directly from here:
+
+```julia
+import Pkg
+Pkg.add(url="https://github.com/VirtualPlantLab/VirtualPlantLab.jl", rev = "master")
+```
+or
+
+```julia
+] add VirtualPlantLab#master
+```
+
+# 2. Usage
+
+To start using VirtualPlantLab.jl, you need to load it first:
+
+```julia
+using VirtualPlantLab
+```
+
+The entire API of the Virtual Plant Lab will become available after loading.
+
+For people starting, it is recommended to follow the tutorials in the
+[documentation](http://virtualplantlab.com/). The entire API is also documented there.
+
+# 3. Additional packages
+
+The following packages are also of interest when building models with the Virtual Plant Lab:
+
+- [PlantSimEngine.jl](https://github.com/VirtualPlantLab/PlantSimEngine.jl)
+- [PlantBiophysics.jl](https://github.com/VEZY/PlantBiophysics.jl.git)
+- [SkyDomes.jl](https://github.com/VirtualPlantLab/SkyDomes.jl)
+- [Ecophys.jl](https://github.com/VirtualPlantLab/Ecophys.jl.git)

src/VPL.jl src/VirtualPlantLab.jlsrc/VPL.jl renamed to src/VirtualPlantLab.jl

@@ -1,8 +1,8 @@
-module VPL
+module VirtualPlantLab
 
 using Reexport
 
-# Load the VPL components
+# Load the VirtualPlantLab components
 @reexport using PlantGraphs
 @reexport using PlantGeomPrimitives
 @reexport using PlantGeomTurtle

test/algae.jl

@@ -10,10 +10,10 @@ The model described here is based on the non-branching model of [algae
 growth](https://en.wikipedia.org/wiki/L-system#Example_1:_Algae) proposed by
 Lindermayer as one of the first L-systems.
 
-First, we need to load the VPL metapackage, which will automatically load all
-the packages in the VPL ecosystem.
+First, we need to load the VirtualPlantLab metapackage, which will automatically load all
+the packages in the VirtualPlantLab ecosystem.
 =#
-using VPL
+using VirtualPlantLab
 
 #=
 The rewriting rules of the L-system are as follows:
@@ -24,14 +24,14 @@ The rewriting rules of the L-system are as follows:
 
 **rule 2**:  B $\rightarrow$ A
 
-In VPL, this L-system would be implemented as a graph where the nodes can be of
+In VirtualPlantLab, this L-system would be implemented as a graph where the nodes can be of
 type `A` or `B` and inherit from the abstract type `Node`. It is advised to
 include type definitions in a module to avoid having to restart the Julia
 session whenever we want to redefine them. Because each module is an independent
-namespace, we need to import `Node` from the VPL package inside the module:
+namespace, we need to import `Node` from the VirtualPlantLab package inside the module:
 =#
 module algae
-import VPL: Node
+import VirtualPlantLab: Node
 struct A <: Node end
 struct B <: Node end
 end
@@ -47,15 +47,15 @@ let
     axiom = algae.A()
 
     #=
-    The rewriting rules are implemented in VPL as objects of type `Rule`. In VPL, a
+    The rewriting rules are implemented in VirtualPlantLab as objects of type `Rule`. In VirtualPlantLab, a
     rewriting rule substitutes a node in a graph with a new node or subgraph and is
     therefore composed of two parts:
 
     1. A condition that is tested against each node in a graph to choose which nodes
        to rewrite.
     2. A subgraph that will replace each node selected by the condition above.
 
-    In VPL, the condition is split into two components:
+    In VirtualPlantLab, the condition is split into two components:
 
     1. The type of node to be selected (in this example that would be `A` or `B`).
     2. A function that is applied to each node in the graph (of the specified type)
@@ -68,7 +68,7 @@ let
     objects that inherit from `Node`. The operation `+` implies a linear
     relationship between two nodes and `[]` indicates branching.
 
-    The implementation of the two rules of algae growth model in VPL is as follows:
+    The implementation of the two rules of algae growth model in VirtualPlantLab is as follows:
     =#
     rule1 = Rule(algae.A, rhs = x -> algae.A() + algae.B())
     rule2 = Rule(algae.B, rhs = x -> algae.A())

test/context.jl

@@ -18,7 +18,7 @@ also to use properties of those neighbours in the right hand side component of
 the rule. This is know as "capturing the context" of the node being updated.
 This can be done by returning the additional nodes from the `lhs` component (in
 addition to `true` or `false`) and by accepting these additional nodes in the
-`rhs` component. In addition, we tell VPL that this rule is capturing the
+`rhs` component. In addition, we tell VirtualPlantLab that this rule is capturing the
 context with `captures = true`.
 
 In the example below, each `Cell` keeps track of a `state` variable (which is
@@ -30,9 +30,9 @@ parent node that was captured. Note that that now, the rhs component gets a new
 argument, which corresponds to the context of the father node captured in the
 lhs.
 =#
-using VPL
+using VirtualPlantLab
 module types
-using VPL
+using VirtualPlantLab
 struct Cell <: Node
     state::Int64
 end
@@ -82,7 +82,7 @@ let
     return collection of nodes rather than reconstruct the topology of a graph). If
     we need to process nodes in a particular order, then it is best to use a
     traversal algorithm on the graph that follows a particular order (for example
-    depth-first traversal with `traverseDFS()`). This algorithm requires a function
+    depth-first traversal with `traverse_dfs()`). This algorithm requires a function
     that applies to each node in the graph. In this simple example we can just store
     the `state` of each node in a vector (unlike Rules and Queries, this function
     takes the actual node as argument rather than a `Context` object, see the
@@ -91,13 +91,13 @@ let
 
     pop = Graph(axiom = axiom, rules = rule)
     states = Int64[]
-    traversedfs(pop, fun = node -> push!(states, node.state))
+    traverse_dfs(pop, fun = node -> push!(states, node.state))
     states
 
     # Now the states of the nodes are in the same order as they were created:
     rewrite!(pop)
     states = Int64[]
-    traversedfs(pop, fun = node -> push!(states, node.state))
+    traverse_dfs(pop, fun = node -> push!(states, node.state))
     states
 
 end

test/forest.jl

@@ -10,27 +10,27 @@ requires using the Distributions.jl package:
 The data types, rendering methods and growth rules are the same as in the binary
 tree example:
 =#
-using VPL
+using VirtualPlantLab
 using Distributions, ColorTypes
 import GLMakie
 import Base.Threads: @threads
 # Data types
 module TreeTypes
-import VPL
+import VirtualPlantLab
 # Meristem
-struct Meristem <: VPL.Node end
+struct Meristem <: VirtualPlantLab.Node end
 # Bud
-struct Bud <: VPL.Node end
+struct Bud <: VirtualPlantLab.Node end
 # Node
-struct Node <: VPL.Node end
+struct Node <: VirtualPlantLab.Node end
 # BudNode
-struct BudNode <: VPL.Node end
+struct BudNode <: VirtualPlantLab.Node end
 # Internode (needs to be mutable to allow for changes over time)
-Base.@kwdef mutable struct Internode <: VPL.Node
+Base.@kwdef mutable struct Internode <: VirtualPlantLab.Node
     length::Float64 = 0.10 # Internodes start at 10 cm
 end
 # Leaf
-Base.@kwdef struct Leaf <: VPL.Node
+Base.@kwdef struct Leaf <: VirtualPlantLab.Node
     length::Float64 = 0.20 # Leaves are 20 cm long
     width::Float64 = 0.1 # Leaves are 10 cm wide
 end
@@ -48,7 +48,7 @@ import .TreeTypes
 
 let
     # Create geometry + color for the internodes
-    function VPL.feed!(turtle::Turtle, i::TreeTypes.Internode, data)
+    function VirtualPlantLab.feed!(turtle::Turtle, i::TreeTypes.Internode, data)
         # Rotate turtle around the head to implement elliptical phyllotaxis
         rh!(turtle, data.phyllotaxis)
         HollowCylinder!(
@@ -63,7 +63,7 @@ let
     end
 
     # Create geometry + color for the leaves
-    function VPL.feed!(turtle::Turtle, l::TreeTypes.Leaf, data)
+    function VirtualPlantLab.feed!(turtle::Turtle, l::TreeTypes.Leaf, data)
         # Rotate turtle around the arm for insertion angle
         ra!(turtle, -data.leaf_angle)
         # Generate the leaf
@@ -80,7 +80,7 @@ let
     end
 
     # Insertion angle for the bud nodes
-    function VPL.feed!(turtle::Turtle, b::TreeTypes.BudNode, data)
+    function VirtualPlantLab.feed!(turtle::Turtle, b::TreeTypes.BudNode, data)
         # Rotate turtle around the arm for insertion angle
         ra!(turtle, -data.branch_angle)
     end
@@ -101,7 +101,7 @@ let
         node = parent(bud)
         # We count the number of internodes between node and the first Meristem
         # moving down the graph
-        check, steps = hasdescendant(node, condition = n -> data(n) isa TreeTypes.Meristem)
+        check, steps = has_descendant(node, condition = n -> data(n) isa TreeTypes.Meristem)
         steps = Int(ceil(steps / 2)) # Because it will count both the nodes and the internodes
         # Compute probability of bud break and determine whether it happens
         if check
@@ -282,20 +282,20 @@ let
     simplest approach is two use a special constructor `Rectangle` where one species
     a corner of the rectangle and two vectors defining the two sides of the vectors.
     Both the sides and the corner need to be specified with `Vec` just like in the
-    above when we determined the origin of each plant. VPL offers some shortcuts:
+    above when we determined the origin of each plant. VirtualPlantLab offers some shortcuts:
     `O()` returns the origin (`Vec(0.0, 0.0, 0.0)`), whereas `X`, `Y` and `Z`
     returns the corresponding axes and you can scale them by passing the desired
     length as input. Below, a rectangle is created on the XY plane with the origin
     as a corner and each side being 11 units long:
     =#
     soil = Rectangle(length = 21.0, width = 21.0)
     rotatey!(soil, pi / 2)
-    VPL.translate!(soil, Vec(0.0, 10.5, 0.0))
+    VirtualPlantLab.translate!(soil, Vec(0.0, 10.5, 0.0))
 
     #=
     We can now add the `soil` to the `scene` object with the `add!` function.
     =#
-    VPL.add!(scene, mesh = soil, color = RGB(1, 1, 0))
+    VirtualPlantLab.add!(scene, mesh = soil, color = RGB(1, 1, 0))
 
     #=
     We can now render the scene that combines the random forest of binary trees and

test/growthforest.jl

@@ -14,7 +14,7 @@ dimensions of the organs are updated accordingly (assuming a particular shape).
 
 The following packages are needed:
 =#
-using VPL, ColorTypes
+using VirtualPlantLab, ColorTypes
 using Base.Threads: @threads
 import Random
 using FastGaussQuadrature
@@ -37,28 +37,28 @@ module. The differences with respect to the previous example are:
 =#
 # Data types
 module TreeTypes
-using VPL
+using VirtualPlantLab
 using Distributions
 # Meristem
-Base.@kwdef mutable struct Meristem <: VPL.Node
+Base.@kwdef mutable struct Meristem <: VirtualPlantLab.Node
     age::Int64 = 0   # Age of the meristem
 end
 # Bud
-struct Bud <: VPL.Node end
+struct Bud <: VirtualPlantLab.Node end
 # Node
-struct Node <: VPL.Node end
+struct Node <: VirtualPlantLab.Node end
 # BudNode
-struct BudNode <: VPL.Node end
+struct BudNode <: VirtualPlantLab.Node end
 # Internode (needs to be mutable to allow for changes over time)
-Base.@kwdef mutable struct Internode <: VPL.Node
+Base.@kwdef mutable struct Internode <: VirtualPlantLab.Node
     age::Int64 = 0         # Age of the internode
     biomass::Float64 = 0.0 # Initial biomass
     length::Float64 = 0.0  # Internodes
     width::Float64 = 0.0  # Internodes
     sink::Exponential{Float64} = Exponential(5)
 end
 # Leaf
-Base.@kwdef mutable struct Leaf <: VPL.Node
+Base.@kwdef mutable struct Leaf <: VirtualPlantLab.Node
     age::Int64 = 0         # Age of the leaf
     biomass::Float64 = 0.0 # Initial biomass
     length::Float64 = 0.0  # Leaves
@@ -96,7 +96,7 @@ let
     the previous example.
     =#
     # Create geometry + color for the internodes
-    function VPL.feed!(turtle::Turtle, i::TreeTypes.Internode, vars)
+    function VirtualPlantLab.feed!(turtle::Turtle, i::TreeTypes.Internode, vars)
         # Rotate turtle around the head to implement elliptical phyllotaxis
         rh!(turtle, vars.phyllotaxis)
         HollowCylinder!(
@@ -111,7 +111,7 @@ let
     end
 
     # Create geometry + color for the leaves
-    function VPL.feed!(turtle::Turtle, l::TreeTypes.Leaf, vars)
+    function VirtualPlantLab.feed!(turtle::Turtle, l::TreeTypes.Leaf, vars)
         # Rotate turtle around the arm for insertion angle
         ra!(turtle, -vars.leaf_angle)
         # Generate the leaf
@@ -128,7 +128,7 @@ let
     end
 
     # Insertion angle for the bud nodes
-    function VPL.feed!(turtle::Turtle, b::TreeTypes.BudNode, vars)
+    function VirtualPlantLab.feed!(turtle::Turtle, b::TreeTypes.BudNode, vars)
         # Rotate turtle around the arm for insertion angle
         ra!(turtle, -vars.branch_angle)
     end
@@ -406,11 +406,11 @@ let
     using a dedicated graph and generate a `Scene` object which can later be
     merged with the rest of scene generated in daily step:
     =#
-    Base.@kwdef struct Soil <: VPL.Node
+    Base.@kwdef struct Soil <: VirtualPlantLab.Node
         length::Float64
         width::Float64
     end
-    function VPL.feed!(turtle::Turtle, s::Soil, vars)
+    function VirtualPlantLab.feed!(turtle::Turtle, s::Soil, vars)
         Rectangle!(
             turtle,
             length = s.length,