3.3) One-way efficiency estimations

Hugo Flávio



  1. Preparing your data
    1. Structuring the study area
    2. Creating a distances matrix
    3. The preload() function
  2. explore()
    1. Processes behind explore()
    2. Inspecting the explore() results
  3. migration()
    1. Processes behind migration()
    2. Inspecting the migration() results
    3. One-way efficiency estimations
  4. residency()
    1. Processes behind residency()
    2. Inspecting the residency() results
    3. Multi-way efficiency estimations
  5. Manual mode
  6. Beyond the three main analyses

Forward efficiency

During the migration analysis, actel calculates forward efficiency only, to improve the accuracy of the efficiency measurement. This means that, for each tag, only the first forward movement is considered. Let’s have a look at these examples:

drawing drawing

In example A, the tag moved out to the sea, and was detected at the array River1 and Fjord2, but not at Fjord1. This is considered a missed event for Fjord1. Even if the tag then moved backwards and ended up being detected at Fjord1 at a later time (example B), since the first expected detection was missed, this tag will still be considered as missed by Fjord1, as far as efficiency calculations are concerned.

These efficiency calculations are dependant on the way you organise your receivers, so it is important that you organise your study area in an actel-friendly way.

CJS and multiple branches

Actel calculates array efficiency through CJS modelling, based in the equations provided by Perry et al. (2012). In short, this implies comparing the individual tags detected at an array with those detected at the arrays that come after that said array.

One of the caveats of the CJS calculations is that if, say, we have arrays A and B, and B is after A, then a tag that is detected at B must have passed through A as well. However, this may not be the case if there are multiple water channels that the animal can go through.

To compensate for this, actel finds valid efficiency peers for each array. That is, arrays that are directly or indirectly after a given array, and to which it is not possible to get to without passing through said array (assuming the tag does not move backwards). Then, actel combines the unique tags detected at all of the efficiency peers of a given array, and uses these combined detections as a single array subsequent to the one being analysed. The individual CJS models are then combined to create the overall.CJS object.

Dealing with parallel arrays

Parallel arrays are particularly tricky to deal with, because they do not come before, nor after their neighbours. It is here that the argument disregard.parallels comes in. Let’s have a look at this study area, which has up to three branches.


With this spatial.txt:

A -- B -- C -- G
A -- D -- E -- G
D -- F -- G
D -- B -- D
C -- E -- C
C -- F -- C
E -- F -- E

It is particularly relevant to note that :

Now let’s try to determine the valid efficiency peers of array D, first with disregard.parallels = TRUE and then with disregard.parallels = FALSE.

if disregard.parallels = TRUE


Array D has three arrays directly or indirectly after it: E, F and G. When disregard.parallels = TRUE, actel will ask the following question, for each of the arrays coming after D:

Can an animal get to array [x] without having to pass through array D?

This assumes that the animal is expected to move only in one direction (i.e. from release to a success array). If the answer to this question is no, then array [x] is a valid efficiency peer of array D. Both arrays E and F fulfil this requirement, as the only array coming before them is D itself. However, array G fails this requirement, because the animals can get to array G coming from array C, which is not connected to array D.

So, if disregard.parallels = TRUE, arrays E and F are valid efficiency peers of array D.

if disregard.parallels = FALSE


In this case, since disregard.parallels = FALSE, actel asks an additional question:

1) Can an animal get to array [x] without having to pass through array D?
2) Does array [x] have any parallel arrays which can be reached without passing through array D?

Again, if the answer to both of these questions is no, then array [x] is a valid efficiency peer for array D. As we saw above, arrays E and F fulfil the first requirement. However, both of these arrays have an extra parallel array (array C), and it is possible to reach that array without passing through array D.

As such, if disregard.parallels = FALSE, then array D no longer has any valid peers.

So, should you go with TRUE or FALSE?

It depends on your study area, and on your animals. If you expect that the tagged animals are likely to move between parallel arrays (e.g. because these arrays are very close to each other), then it may be a good idea to not disregard the presence of parallels (i.e. run the analysis with disregard.parallels = FALSE). A practical example would be if you have multiple channels leading to a lake, and you have arrays at each lake entrance. As the animals may have to explore other lake entrances before finding the lake exit, disregarding parallel arrays could potentially lead to underestimations of array efficiency.

Keep in mind that you can always run the analysis twice, and find out which case fits best your data!

Arrays with no efficiency peers

Regardless of the mechanics explained above, arrays C, E, F and G would never have any valid efficiency peers. As such, inter-array efficiency cannot be calculated for them using a CJS model. However, you have the chance to calculate intra-array efficiency, if an array is composed by two lines of receivers. You can find the efficiency peers of each array in the arrays object.

Intra-array efficiency

Intra array efficiency calculations are also performed following the equations provided by Perry et al. (2012). Specifically, actel splits the array’s receivers in “original” and “replicates” (depending on what you specified in the replicates argument), and compares the tags detected at both of these elements. The results of the intra-array calculations for each array are then stored in the intra.array.CJS list.

Return to previous page

Back to top.