Colony events

Introduction

This vignette will introduce you to honeybee colony events. SIMplyBee implements the most important natural events like swarming, supersedure, and collapse of the colony, and a beekeeping management practice called splitting. All functions that implement colony events work both on Colony and MultiColony objects.

First, we start by loading the package.

library(package = "SIMplyBee")
#> Loading required package: AlphaSimR
#> Loading required package: R6
#> 
#> Attaching package: 'SIMplyBee'
#> The following object is masked from 'package:base':
#> 
#>     split

The code below generates 6 colonies so we can demonstrate various colony events.

founderGenomes <- quickHaplo(nInd = 30, nChr = 1, segSites = 100)
SP <- SimParamBee$new(founderGenomes)
basePop <- createVirginQueens(founderGenomes)
drones <- createDrones(basePop[1:10], n = 1000)
fatherGroups <- pullDroneGroupsFromDCA(drones, n = 30, nDrones = 10)

# Create Colony and MultiColony class, cross them and build them up
colony <- createColony(x = basePop[11])
colony <- cross(colony, drones = fatherGroups[[1]], checkCross = "warning")
colony <- buildUp(colony, nWorkers = 100, nDrones = 20)

apiary <- createMultiColony(basePop[12:17])
apiary <- cross(apiary, drones = fatherGroups[2:7], checkCross = "warning")
apiary <- buildUp(apiary, nWorkers = 100, nDrones = 20, exact = TRUE)

Swarming

Swarming is the process through which honeybee colonies produce new colonies. When a honeybee colony outgrows its hive, becomes too congested, or too populated for the queen’s pheromones to spread among workers, then the swarming begins. The workers start building swarm cells for new virgin queens. When the queen is ready, she leaves the hive and is followed by about 70% of the workers in a massive cloud of flying bees, the swarm (Rangel and Seeley, 2012). The swarm will cluster on a nearby tree or bush and remain there until they find a suitable new home.

The virgin queens developing in the old hive are daughters of the queen that swarmed and are attended by the remnant workers that did not leave with the swarm. After few days, the new virgin queens begin to emerge. Typically, the first queen to emerge will kill the rest of virgin queens to assume the role as the new queen for the colony. She will then go on a mating flight to find drones to mate with to begin laying eggs and rebuilding the workforce in the colony (Clemson Cooperative Extension, 2021; Rangel and Seeley, 2012).

In SIMplyBee, function swarm() simulates swarming (Figure 1). The function takes a Colony class object and a percentage p of workers that leave with the swarm. The function returns a list with two Colony class objects, swarm and remnant. The swarm contains the old queen and p percentage of workers that left the hive. The remnant contains the rest of workers (1-p), all the drones, and virgin queens that are daughters of the old queen that swarmed.

Swarm function

Swarming a Colony

Let’s swarm our colony:

tmp <- swarm(colony, p = 0.4)
tmp
#> $swarm
#> An object of class "Colony" 
#> Id: 8 
#> Location: 0 0 
#> Queen: 11 
#> Number of fathers: 10 
#> Number of workers: 40 
#> Number of drones: 0 
#> Number of virgin queens: 0 
#> Has split: FALSE 
#> Has swarmed: TRUE 
#> Has superseded: FALSE 
#> Has collapsed: FALSE 
#> Is productive: FALSE 
#> 
#> $remnant
#> An object of class "Colony" 
#> Id: 9 
#> Location: 0 0 
#> Queen: NA 
#> Number of fathers: 0 
#> Number of workers: 60 
#> Number of drones: 20 
#> Number of virgin queens: 1 
#> Has split: FALSE 
#> Has swarmed: TRUE 
#> Has superseded: FALSE 
#> Has collapsed: FALSE 
#> Is productive: FALSE

We see that the remnant colony does not have a queen but has one virgin queen that will have to be mated. It also has 60 workers since we set p argument to 0.4, meaning that 40% of workers left with the swarm. All the drones remained in the remnant. Note that the swarm status is turned to TRUE.

The swarm contains the old queen, no virgin queens, and 40 workers, since we set the proportion p to 0.4. Same as in the remnant, the swarm status is turned to TRUE in the swarm.

Swarming also turns the production slot to FALSE for both, the swarm and the remnant colony, since we would not be able to collect honey from such colonies (or other products).

The swarm stays genetically identical to the “old” colony, although downsized. Assuming that we have caught the swarm, we assign it back to the original colony object. The remnant has a new queen and is hence genetically different from the original colony. Thus, we assigned it to a new colony object.

colony <- tmp$swarm
colony1 <- tmp$remnant

After swarming, the colony would usually build-up back to the full size and the virgin queens would mate. Building-up a colony turns the production status back to TRUE.

colony <- buildUp(colony)
colony
#> An object of class "Colony" 
#> Id: 8 
#> Location: 0 0 
#> Queen: 11 
#> Number of fathers: 10 
#> Number of workers: 100 
#> Number of drones: 100 
#> Number of virgin queens: 0 
#> Has split: FALSE 
#> Has swarmed: TRUE 
#> Has superseded: FALSE 
#> Has collapsed: FALSE 
#> Is productive: TRUE

Instead of setting the p every time we call the swarm() function, we can save the swarmP argument in the SimParamBee object. The swarm() function will then use this percentage if p is not set.

SP$swarmP
#> [1] 0.5

The default value is 0.5, but we can set any value we want.

SP$swarmP <- 0.35
SP$swarmP
#> [1] 0.35

You can also use a non-fixed p parameter by using the function swarmPUnif that samples the p from a uniform distribution between values 0.4 and 0.6 irrespective of the colony strength. You can read more about this in the Sampling functions vignette.

Swarming a MultiColony

We swarm a MultiColony object in the same was we swarm a single Colony - with the swarm() function. The swarm() function is here applied to each colony in the MultiColony object with the same parameters. The function now returns a list with two MultiColony objects - one containing the swarms and the other containing the remnants.

tmp <- swarm(apiary)
tmp
#> $swarm
#> An object of class "MultiColony" 
#> Number of colonies: 6 
#> Are empty: 0 
#> Are NULL: 0 
#> Have split: 0 
#> Have swarmed: 6 
#> Have superseded: 0 
#> Have collapsed: 0 
#> Are productive: 0 
#> 
#> $remnant
#> An object of class "MultiColony" 
#> Number of colonies: 6 
#> Are empty: 0 
#> Are NULL: 0 
#> Have split: 0 
#> Have swarmed: 6 
#> Have superseded: 0 
#> Have collapsed: 0 
#> Are productive: 0

We see that we get six swarms and six remnants from the apiary with six colonies. We can inspect individuals colonies to ensure they swarmed according to the parameters. Let’s inspect the swarm and remnant of the third colony.

tmp$swarm[[3]]
#> An object of class "Colony" 
#> Id: 14 
#> Location: 0 0 
#> Queen: 14 
#> Number of fathers: 10 
#> Number of workers: 35 
#> Number of drones: 0 
#> Number of virgin queens: 0 
#> Has split: FALSE 
#> Has swarmed: TRUE 
#> Has superseded: FALSE 
#> Has collapsed: FALSE 
#> Is productive: FALSE

tmp$remnant[[3]]
#> An object of class "Colony" 
#> Id: 15 
#> Location: 0 0 
#> Queen: NA 
#> Number of fathers: 0 
#> Number of workers: 65 
#> Number of drones: 20 
#> Number of virgin queens: 1 
#> Has split: FALSE 
#> Has swarmed: TRUE 
#> Has superseded: FALSE 
#> Has collapsed: FALSE 
#> Is productive: FALSE

We see that the the third colony was swarmed with p of 35% as specified in the SimParamBee, hence the swarm left with 35 workers and the old queen, and the remnant stayed behind with a new virgin queen and 65 workers.

Above, all the colonies in a MultiColony are swarmed with the same percentage. However, we can also specify a different p for each colony.

tmp <- swarm(apiary, p = c(0.3, 0.4, 0.5, 0.6, 0.7, 0.8))

If we now inspect the first and the second swarm, we see that each colony has a different percentage of workers that stayed or left.

tmp$swarm[[1]]
#> An object of class "Colony" 
#> Id: 22 
#> Location: 0 0 
#> Queen: 12 
#> Number of fathers: 10 
#> Number of workers: 30 
#> Number of drones: 0 
#> Number of virgin queens: 0 
#> Has split: FALSE 
#> Has swarmed: TRUE 
#> Has superseded: FALSE 
#> Has collapsed: FALSE 
#> Is productive: FALSE

tmp$swarm[[3]]
#> An object of class "Colony" 
#> Id: 26 
#> Location: 0 0 
#> Queen: 14 
#> Number of fathers: 10 
#> Number of workers: 50 
#> Number of drones: 0 
#> Number of virgin queens: 0 
#> Has split: FALSE 
#> Has swarmed: TRUE 
#> Has superseded: FALSE 
#> Has collapsed: FALSE 
#> Is productive: FALSE

If you want to track the genetics, you might want to assign the swarms back to the original apiary and create a new apiary from the remnants. However, if you want to track the position, the remnant actually stay in the original position and would hence be assigned back to the same apiary, while the swarm would be assigned to a new apiary or even be lost. Here, we will track the genetics and assign the swarm back to the original apiary and remnants to a new apiary.

apiary <- tmp$swarm
apiary <- buildUp(apiary)
apiary1 <- tmp$remnant

Split

Colony splitting is a common beekeeping technique to limit swarming. A percentage of workers, brood, and food stores are split away to create a new colony or combine two split. Old queen normally stays in the original (remnant) colony. We created a function split() that works on Colony and Multicolony objects (Figure 2). It accepts the p argument as a proportion of workers that will be split away for a new colony. The output of the function is a list of two Colony or MultiColony objects: remnant that contains the old queen, drones, and (1-p) workers; and split that doesn’t contain a queen, but contains virgin queens and p workers. The split() function follows the same principles as the swarm(), hence we will limit explaining the outputs.

Split function

Splitting a Colony

tmp <- split(colony, p = 0.3)
tmp
#> $split
#> An object of class "Colony" 
#> Id: 34 
#> Location: 0 0 
#> Queen: NA 
#> Number of fathers: 0 
#> Number of workers: 30 
#> Number of drones: 0 
#> Number of virgin queens: 1 
#> Has split: TRUE 
#> Has swarmed: FALSE 
#> Has superseded: FALSE 
#> Has collapsed: FALSE 
#> Is productive: FALSE 
#> 
#> $remnant
#> An object of class "Colony" 
#> Id: 8 
#> Location: 0 0 
#> Queen: 11 
#> Number of fathers: 10 
#> Number of workers: 70 
#> Number of drones: 100 
#> Number of virgin queens: 0 
#> Has split: TRUE 
#> Has swarmed: TRUE 
#> Has superseded: FALSE 
#> Has collapsed: FALSE 
#> Is productive: TRUE

We see that remnant contains the old queen and 70% of workers since we set p argument to 0.3, meaning that 30% of workers are removed in the split. The split status of the remnant colony is turned to TRUE. The production status of the remnant stays TRUE, because in reality we always split a colony in a way that does not threaten the production of the remnant colony.

If we inspect the split, we see that it contains 30% of the workers, the split status is turned to TRUE, and the production status is turned to FALSE, since in reality, these small colonies would not be productive.

We would usually consider the remnant as the original colony, since it tracks its genetics and location.

colony <- tmp$remnant
colony
#> An object of class "Colony" 
#> Id: 8 
#> Location: 0 0 
#> Queen: 11 
#> Number of fathers: 10 
#> Number of workers: 70 
#> Number of drones: 100 
#> Number of virgin queens: 0 
#> Has split: TRUE 
#> Has swarmed: TRUE 
#> Has superseded: FALSE 
#> Has collapsed: FALSE 
#> Is productive: TRUE

After a split, the colony would build-up back to their full-size.

colony <- buildUp(colony)

The p argument for splitting can be also saved in SP object, so we do not specify it each time we call the function - see SimParamBee$splitP.

Splitting a MultiColony

We split a MultiColony object in the same way we split a Colony (as shown in swarm).

tmp <- split(apiary, p = 0.3)
tmp$remnant[[1]]
#> An object of class "Colony" 
#> Id: 22 
#> Location: 0 0 
#> Queen: 12 
#> Number of fathers: 10 
#> Number of workers: 70 
#> Number of drones: 100 
#> Number of virgin queens: 0 
#> Has split: TRUE 
#> Has swarmed: TRUE 
#> Has superseded: FALSE 
#> Has collapsed: FALSE 
#> Is productive: TRUE

We again see that in remnant we have the queen and 70 workers:

tmp$split[[1]]
#> An object of class "Colony" 
#> Id: 35 
#> Location: 0 0 
#> Queen: NA 
#> Number of fathers: 0 
#> Number of workers: 30 
#> Number of drones: 0 
#> Number of virgin queens: 1 
#> Has split: TRUE 
#> Has swarmed: FALSE 
#> Has superseded: FALSE 
#> Has collapsed: FALSE 
#> Is productive: FALSE

and a virgin queen with 30 workers in split. We can use the vector of p, different for each colony same as shown for the swarm() function above.

After the split, we would assign the remnant colonies back to the apiary and build them up.

apiary <- tmp$remnant
apiary <- buildUp(apiary)

Supersedure

Supersedure is a replacement of the queen by one of her daughters without interference of the beekeeper. Supersedure is a natural way of re-queening a colony without swarming. There are many reasons for supersedure: poor physical condition of a queen, old age, diseases, depleted spermatheca, poorly bread queen, reduced pheromone output and many others (Hamdan, 2010).

Function supersede() removes the old queen and triggers the creation of new virgin queens from the brood (Figure 3). The function returns a single Colony or MultiColony object (not a list of two).

Supersede function

Superseding a Colony

colony <- supersede(colony)
colony
#> An object of class "Colony" 
#> Id: 8 
#> Location: 0 0 
#> Queen: NA 
#> Number of fathers: 0 
#> Number of workers: 100 
#> Number of drones: 100 
#> Number of virgin queens: 1 
#> Has split: TRUE 
#> Has swarmed: TRUE 
#> Has superseded: TRUE 
#> Has collapsed: FALSE 
#> Is productive: TRUE

We see that after a supersedure, the old queen is removed and a new virgin queen is ready to mate. Hence, the next step in the simulation would be to cross this virgin queen. We also see that the supersedure status is set to TRUE. The production status stays set to TRUE, since the colony did not loose any individuals (it stayed at it’s full-size).

Superseding a MultiColony

The function supersede() works both on Colony and MultiColony classes. We supersede a MultiColony in a same way as a Colony.

apiary <- supersede(apiary)
apiary
#> An object of class "MultiColony" 
#> Number of colonies: 6 
#> Are empty: 0 
#> Are NULL: 0 
#> Have split: 6 
#> Have swarmed: 6 
#> Have superseded: 6 
#> Have collapsed: 0 
#> Are productive: 6

Collapse

Collapse of the colony is a term that describes the death of a colony - when all individuals within a colony die. There are many reasons for the collapse of a honey bee colony: diseases, starvation, queen problems, contamination with pesticides, etc. Colony losses can be high, possibly up to 60% of colonies per year. High colony losses can significantly influence genetic structure of a population and hence genetic diversity and genetic gain.

Function collapse() simulates the collapse of a colony (Figure 4). This function does not remove individuals from the colony, but sets the collapse status of the colony to TRUE and production status to FALSE. This is to mimic reality, where bees would still be present in the colony, although being dead. This allows us to extract any genetic material from the colony even after collapse, say to study genetic causes related to the collapse. Future operations in terms of reproduction or simulation of events are not allowed with a collapsed colony.

Collapse function

Collapsing a Colony

colony <- collapse(colony)
colony
#> An object of class "Colony" 
#> Id: 8 
#> Location: 0 0 
#> Queen: NA 
#> Number of fathers: 0 
#> Number of workers: 100 
#> Number of drones: 100 
#> Number of virgin queens: 1 
#> Has split: TRUE 
#> Has swarmed: TRUE 
#> Has superseded: TRUE 
#> Has collapsed: TRUE 
#> Is productive: FALSE

Collapsing a MultiColony

collapse() function is used when you want to keep collapsed colonies for subsequent analyses. If you don’t need the collapsed colony, you can also simply select the surviving colonies with the selectColonies() function.

apiary <- collapse(apiary)
apiary[[3]]
#> An object of class "Colony" 
#> Id: 26 
#> Location: 0 0 
#> Queen: NA 
#> Number of fathers: 0 
#> Number of workers: 100 
#> Number of drones: 100 
#> Number of virgin queens: 1 
#> Has split: TRUE 
#> Has swarmed: TRUE 
#> Has superseded: TRUE 
#> Has collapsed: TRUE 
#> Is productive: FALSE
apiary
#> An object of class "MultiColony" 
#> Number of colonies: 6 
#> Are empty: 0 
#> Are NULL: 0 
#> Have split: 6 
#> Have swarmed: 6 
#> Have superseded: 6 
#> Have collapsed: 6 
#> Are productive: 0

References

Clemson Cooperative Extension (2021) Frequently asked questions about honey bee swarms. https://hgic.clemson.edu/factsheet/frequently-asked-questions-about-honey-bee-swarms (accessed on 2022-11-11)

Hamdan K. (2010) Natural Supersedure of Queens in Honey Bee Colonies. Bee World, 87(3):52-54. https://doi.org/10.1080/0005772X.2010.11417360