A key characteristic of `prioriactions`

is that it allows
to calculate an approximation of the **benefit** obtained
by carrying out conservation actions. This approximation is based on the
following assumptions [Cattarino et al.
(2015)](Salgado-Rojas et al.
2020):

Threats can be binary (presence/absence) or continuous (with levels of intensity).

There is only one action per threat.

Actions are fully effective, that is, an action against a threat eliminates it completely.

The

**probability of persistence**of the features is proportional to the number of actions that are prescribed with respect to the total number of actions that would be needed to abate all threats that affect a given species in a given site.

Thus, the expected **benefit** (\(b\)) of a feature in an unit can be
expressed mathematically for a set of planning units \(I\) indexed by \(i\), a set of threats \(K\) indexed by \(k\) and a set of features \(S\) indexed by \(s\) as:

\[
b_{is} = p_{is} r_{is}
\] Where \(p_is\) is the
probability of persistence of the feature (\(s\)) in a planning unit \(i\) and \(r_is\) is the amount of that feature \(s\) in said unit \(i\). `prioriactions`

package
focuses on the net benefit obtained after the application of actions,
therefore, this probability of persistence is calculated with respect to
the base situation, that is, when it does not take any action against
threats.

The remainder of this document is organized as follows. In Section 1
we present how `prioriactions`

calculates the benefits when
the threats are discrete (presence/absence), and in Section 2 we present
how `prioriactions`

calculates the benefits when the threats
have continuous intensities.

In order to calculate the **benefit** obtained for a
features in a planning unit when all threats have binary intensities
(presence / absence), we define the probability of persistence as:

\[ p_{is} = \frac{\sum_{k \in K_i \cap K_s} {x_{ik}}}{|K_i \cap K_s|} \] Where, \(x_{ik}\) is a decision variable that specifies whether an action to abate the threat \(k\) in the planning unit \(i\) has been selected (1) or not (0), \(K_i\) is the set of all threats that exists in \(i\) and \(K_s\) is the set of all threats the feature \(s\) is sensitive to.

Note that \(|K_i \cap K_s|\)
indicates the intersection between these two sets, that is, the threats
that exist on the site \(i\) and that,
in turn, the features \(s\) is
sensitive to. In the case when the intersection is zero, which means
that feature \(s\) does not coexist
with any of its threats in \(i\), its
**probability of persistence** is 1.

Considers that there are two planning objectives
(`recovery`

and `conservation`

), so if a feature
does not coexist with any of its threats (as in the previous case), its
**benefit** contributes to achieving the
**conservation target** (in the case of exist). Otherwise,
the **benefits** contribute to the **recovery
target**. More information about this point can be found in objectives
vignette.

As we have seen, the **probability of persistence** is
calculated initially as a *linear* relationship of the actions
carried out concerning the possible actions to face the threats of a
feature on a site. However, this relationship assumes that all threats
contribute equally to the probability of persistence of the features.
This approach to estimating **probabilities of
persistence** could also overestimate the benefit of addressing
threats (e.g., if two threats are present, one of them more impacting
than the other, but only one of them -the less impacting- was
addressed). For this reason, `prioriactions`

incorporates
different non-linear **curves (**\(v\)**)** as exponents to the
original expression of \(p\):

\[
b_{is} = p_{is}^v r_{is}
\] Thus, with \(v\) as the type
of **curve** or exponent, three options are possible: 1 =
linear, 2 = quadratic, or 3 = cubic. The effect will be greater the
higher the value of the parameter. In turn, the higher it is, the more
complexity is added to the resolution of the resulting model and, for
example, more likely it is to get solutions where all or almost all
threats affecting a given features in a given site have been addressed.
This **curve** parameter is built into
`prioriactions`

within the `problem()`

function.
Let’s see an example.

To show the difference between both models of
**benefit** calculation when working with binary
intensities, we use two different curves (linear and cubic) employing
the example available in the Get
started vignette.

```
# load the prioriactions package
library(prioriactions)
data(sim_boundary_data, sim_dist_features_data, sim_dist_threats_data,
sim_features_data, sim_pu_data, sim_sensitivity_data, sim_threats_data)
# set monitoring costs to 0.1
$monitoring_cost <- 0.1
sim_pu_data
# set recovery_targets to 15% of maximum
$target_recovery <- 0.15 * c(47, 28, 56, 33)
sim_features_data
# evaluate input data
<- inputData(pu = sim_pu_data,
b.binary_base features = sim_features_data,
dist_features = sim_dist_features_data,
threats = sim_threats_data,
dist_threats = sim_dist_threats_data,
sensitivity = sim_sensitivity_data,
boundary = sim_boundary_data)
# create the mathematic model
<- problem(b.binary_base,
c.binary_base model_type = "minimizeCosts")
```

`## Warning: The blm argument was set to 0, so the boundary data has no effect`

`## Warning: Some blm_actions argument were set to 0, so the boundary data has no effect for these cases`

```
# solve the model
<- solve(c.binary_base,
d.binary_base solver = "gurobi",
verbose = TRUE,
output_file = FALSE,
cores = 2)
```

```
## Gurobi Optimizer version 9.1.2 build v9.1.2rc0 (linux64)
## Thread count: 2 physical cores, 4 logical processors, using up to 2 threads
## Optimize a model with 284 rows, 396 columns and 785 nonzeros
## Model fingerprint: 0xda1a7bc4
## Variable types: 176 continuous, 220 integer (220 binary)
## Coefficient statistics:
## Matrix range [5e-01, 2e+00]
## Objective range [1e-01, 1e+01]
## Bounds range [1e+00, 1e+00]
## RHS range [4e+00, 8e+00]
## Found heuristic solution: objective 489.0000000
## Found heuristic solution: objective 146.6000000
## Presolve removed 262 rows and 319 columns
## Presolve time: 0.00s
## Presolved: 22 rows, 77 columns, 169 nonzeros
## Found heuristic solution: objective 50.6000000
## Variable types: 0 continuous, 77 integer (63 binary)
##
## Root relaxation: objective 3.415000e+01, 14 iterations, 0.00 seconds
##
## Nodes | Current Node | Objective Bounds | Work
## Expl Unexpl | Obj Depth IntInf | Incumbent BestBd Gap | It/Node Time
##
## 0 0 34.15000 0 5 50.60000 34.15000 32.5% - 0s
## H 0 0 35.3000000 34.15000 3.26% - 0s
## * 0 0 0 34.4000000 34.40000 0.00% - 0s
##
## Cutting planes:
## Gomory: 1
## Cover: 4
## MIR: 2
##
## Explored 1 nodes (22 simplex iterations) in 0.00 seconds
## Thread count was 2 (of 4 available processors)
##
## Solution count 5: 34.4 35.3 50.6 ... 489
##
## Optimal solution found (tolerance 0.00e+00)
## Best objective 3.440000000000e+01, best bound 3.440000000000e+01, gap 0.0000%
```

By using `getCost()`

we can explore the total cost of the
solution and split into actions. We obtain a total cost of 34.4, divided
into 1.4 for monitoring, 14 in actions to abated the threat 1 and
another 19 in actions to abated the threat 2.

`getCost(d.binary_base)`

```
## solution_name monitoring threat_1 threat_2
## 1 sol 1.4 14 19
```

Now by the `getSolutionBenefit()`

function, we can obtain
how the benefits are distributed for the different features. Notice that
we use the `type = "local"`

argument to obtain the benefits
per unit and feature.

```
# get benefits of solution
<- getSolutionBenefit(d.binary_base, type = "local")
local_benefits
# plot local benefits
<- reshape2::dcast(local_benefits, pu~feature,value.var = "benefit.total", fill = 0)
local_benefits
#loead raster package
library(raster)
<- raster(ncol=10, nrow=10, xmn=0, xmx=10, ymn=0, ymx=10)
r values(r) <- 0
<- raster::stack(r, r, r, r)
group_rasters values(group_rasters[[1]]) <- local_benefits$`1`
values(group_rasters[[2]]) <- local_benefits$`2`
values(group_rasters[[3]]) <- local_benefits$`3`
values(group_rasters[[4]]) <- local_benefits$`4`
names(group_rasters) <- c("feature 1", "feature 2", "feature 3", "feature 4")
plot(group_rasters)
```

The second model use a parameter of `curve = 3`

in its
construction, and therefore, the calculate of probability of persistence
is not proportional.

```
<- problem(b.binary_base,
c.binary_curve model_type = "minimizeCosts",
curve = 3)
```

`## Warning: The blm argument was set to 0, so the boundary data has no effect`

`## Warning: Some blm_actions argument were set to 0, so the boundary data has no effect for these cases`

```
<- solve(c.binary_curve,
d.binary_curve solver = "gurobi",
verbose = TRUE,
output_file = FALSE,
cores = 2)
```

```
## Gurobi Optimizer version 9.1.2 build v9.1.2rc0 (linux64)
## Thread count: 2 physical cores, 4 logical processors, using up to 2 threads
## Optimize a model with 284 rows, 572 columns and 785 nonzeros
## Model fingerprint: 0x6afe5081
## Model has 176 general constraints
## Variable types: 352 continuous, 220 integer (220 binary)
## Coefficient statistics:
## Matrix range [5e-01, 2e+00]
## Objective range [1e-01, 1e+01]
## Bounds range [1e+00, 1e+00]
## RHS range [4e+00, 8e+00]
## Found heuristic solution: objective 489.0000000
## Presolve added 242 rows and 557 columns
## Presolve time: 0.01s
## Presolved: 526 rows, 1129 columns, 2749 nonzeros
## Presolved model has 164 SOS constraint(s)
## Found heuristic solution: objective 488.0000000
## Variable types: 984 continuous, 145 integer (140 binary)
##
## Root relaxation: objective 3.285500e+01, 308 iterations, 0.00 seconds
##
## Nodes | Current Node | Objective Bounds | Work
## Expl Unexpl | Obj Depth IntInf | Incumbent BestBd Gap | It/Node Time
##
## 0 0 32.85500 0 22 488.00000 32.85500 93.3% - 0s
## H 0 0 457.6000000 32.85500 92.8% - 0s
## 0 0 33.07500 0 19 457.60000 33.07500 92.8% - 0s
## H 0 0 51.5000000 33.07500 35.8% - 0s
## 0 0 33.11500 0 20 51.50000 33.11500 35.7% - 0s
## 0 0 33.12490 0 32 51.50000 33.12490 35.7% - 0s
## 0 0 33.13125 0 34 51.50000 33.13125 35.7% - 0s
## H 0 0 41.3000000 33.13125 19.8% - 0s
## 0 0 33.13333 0 27 41.30000 33.13333 19.8% - 0s
## 0 0 33.13333 0 27 41.30000 33.13333 19.8% - 0s
## 0 0 33.23750 0 28 41.30000 33.23750 19.5% - 0s
## 0 0 33.24750 0 18 41.30000 33.24750 19.5% - 0s
## 0 0 33.24750 0 17 41.30000 33.24750 19.5% - 0s
## 0 0 33.24750 0 22 41.30000 33.24750 19.5% - 0s
## 0 0 33.24750 0 22 41.30000 33.24750 19.5% - 0s
## 0 2 33.26000 0 22 41.30000 33.26000 19.5% - 0s
## H 109 80 39.3000000 35.47635 9.73% 3.6 0s
## 37059 1687 38.81870 55 4 39.30000 38.81870 1.22% 2.8 5s
##
## Cutting planes:
## Gomory: 1
## MIR: 2
## Flow cover: 2
##
## Explored 48097 nodes (128726 simplex iterations) in 5.95 seconds
## Thread count was 2 (of 4 available processors)
##
## Solution count 6: 39.3 41.3 51.5 ... 489
##
## Optimal solution found (tolerance 0.00e+00)
## Warning: max constraint violation (1.1895e-02) exceeds tolerance
## Warning: max general constraint violation (1.1895e-02) exceeds tolerance
## (model may be infeasible or unbounded - try turning presolve off)
## Best objective 3.930000000000e+01, best bound 3.930000000000e+01, gap 0.0000%
```

Note that we obtain a total cost of 39.3, i.e. a higher cost than the
when we use a linear curve. By using `getCost()`

, we see that
there are fewer units where actions are carried out, which suggests that
more actions are being carried out in less sites.

`getCost(d.binary_curve)`

```
## solution_name monitoring threat_1 threat_2
## 1 sol 1.3 14 24
```

In the same way as in the previous model, using the
`getSolutionBenefit()`

function, we can obtain how the
benefits are distributed for the different features:

```
# get benefits of solution
<- getSolutionBenefit(d.binary_curve, type = "local")
local_benefits.curve
# plot local benefits
<- reshape2::dcast(local_benefits.curve, pu~feature,value.var = "benefit.total", fill = 0)
local_benefits.curve
values(group_rasters[[1]]) <- local_benefits.curve$`1`
values(group_rasters[[2]]) <- local_benefits.curve$`2`
values(group_rasters[[3]]) <- local_benefits.curve$`3`
values(group_rasters[[4]]) <- local_benefits.curve$`4`
plot(group_rasters)
```

As we can see, for the base case, features 1 and 3 add to the total
benefit sites where their **probability of persistence** is
0.5. Whereas when we use `curve = 3`

, all but one site that
contribute to reaching the target have a probability value of 1. This
effect will be more evident when there are more threats in the planning
exercise.

So far we have worked with two important premises: 1) that threats
exist or not (presence/absence) and 2) that all features are equally
sensitive to threats. To make these assumptions more flexible, we
introduce the possibility of using **threat intensities**
(in the same way that we use \(r_{is}\)
for features) and, the relationship of these intensities with the
**probability of persistence** of the features (through
**response curves**). These response curves can be
*fitted* by a piece-wise function by means of four parameters
within the `sensitivities`

input data, where:

*a*: minimum intensity of the threat at which the features probability of persistence starts to decline.*b*: value of intensity of the threat over which the feature has a probability of persistence of 0.*c*: minimum probability of persistence of a features when a threat reaches its maximum intensity value.*d*: maximum probability of persistence of a features in absence of a given threat.

Where the greater the intensity of the threat, lower
**probability of persistence** of the feature. Thus, with
the definition of these four parameters mentioned above, different
response curves can be *fitted*:

The latter are examples of the curves that could be fitted with these
parameters; that can be customized by users according to their needs by
using the four parameters detailed above. Note that each of the curves
is a relationship between a feature and a particular threat, but what
happens to the **probability of persistence** of a feature
when it coexists with more than one threats?.

We can define the **probability of persistence** of
feature \(s\) in the unit \(i\) as a measure of the individual
**probability of persistence** of feature \(s\) with respect to threat \(k\) in unit \(i\) (\(p_{isk}\)), i.e.:

\[ p_{is} = \sum_{k \in K_i \cap K_s}\gamma_{isk} p_{isk} \]

With \(\sum_{k \in |K_i \cap K_s|}\gamma_{isk} = 1\) and \(\gamma_{isk} = \gamma_{isk'} \forall k, k' \in |K_i \cap K_s|\).

The `prioriactions`

package internally calculates the
values of \(\gamma_{isk}\) reflecting
the relative importance of each threat (considering its potential
danger) when calculating the probability of persistence of each
feature.

Note the **probability of persistence** of a feature
could be different from zero even if no actions are taken on it
(depending on the type of **response curve**). This implies
that doing nothing (no actions) in a unit could lead to, although small,
benefits. These benefits are not considered to raise the targets
regardless of the planning objective.

Finally, the **probability of persistence** resulting
can be calculated by:

\[ p_{is} = \frac{{\sum_{k \in K_i \cap K_s: a_{sk} <= h_{ik} <= b_{sk}} \frac{x_{ik} (h_{ik} - a_{sk})(d_{sk} - c_{sk})}{b_{sk} - a_{sk}} (1 - \frac{c_{sk}(h_{ik} - a_{sk}) - d_{sk}(h_{ik} - b_{sk})}{b_{sk} - a_{sk}}+ \sum_{k \in K_i \cap K_s: h_{ik} > b_{sk}} x_{ik}(1- c_{sk})(d_{sk} - c_{sk})}}{ {\sum_{k \in K_i \cap K_s: h_{ik} < a_{sk}} 1 - d_{sk}} + \sum_{k \in K_i \cap K_s: a_{sk} <= h_{ik} <= b_{sk}} 1 - \frac{c_{sk}(h_{ik} - a_{sk}) - d_{sk}(h_{ik} - b_{sk})}{b_{sk} - a_{sk}}+ \sum_{k in K_i \cap K_s: h_{ik} > b_{sk}} 1 - c_{sk}} \] Where \(h_{ik}\) is the intensity of the threat \(k\) in the unit \(i\).

In order to demonstrate the use of the package when we have
continuous values of intensities, we use the same example considered for
the models with binary threat intensities. Note that both examples will
not be compared due to differences in potential benefits and therefore
in the targets used. Also, we assume that we only have information about
the sensitivity of feature 1 to both threats, whose **response
curves** have been fitted as follow:

Note the feature is sensitive to any intensity of threat-1, while
this is less sensitive to threat 2, as its **probability of
persistence** remains invariant until the threat reaches high
intensity values.

First, we add the parameters \(a\),
\(b\) to the input of sensitivities,
leaving the measures that we do not know as `NA`

.
`pioriractions`

is responsible for assuming them by their
**default** values; for example, for parameter \(a\), it is considered that the values not
provided as 0, for \(b\), the value
will be the maximum intensity of said threat in the case of study, \(c\) will be 0 and \(d\) 1. In addition, we simulate the
intensity of threats continuously using the `runif()`

function; values between 0 and 150 for threat 1 and values between 0 and
1 for threat 2.

```
# set a,b,c and d parameters
$a = c(0, NA, NA, NA, 0.8, NA, NA, NA)
sim_sensitivity_data$b = c(150, NA, NA, NA, 1, NA, NA, NA)
sim_sensitivity_data$c = 0.0
sim_sensitivity_data$d = c(1, NA, NA, NA, 0.6, NA, NA, NA)
sim_sensitivity_data
# set continuous intensities
set.seed(1)
$amount[sim_dist_threats_data$threat == 1] <- round(runif(n = 57, 0, 123), 2)
sim_dist_threats_data$amount[sim_dist_threats_data$threat == 2] <- round(runif(n = 63, 0, 1), 2)
sim_dist_threats_data
# evaluate input data
<- inputData(pu = sim_pu_data,
b.continuous features = sim_features_data,
dist_features = sim_dist_features_data,
threats = sim_threats_data,
dist_threats = sim_dist_threats_data,
sensitivity = sim_sensitivity_data,
boundary = sim_boundary_data)
# set the target of recovery to 15%
<- getPotentialBenefit(b.continuous)
max $target_recovery <- 0.15 * max$maximum.recovery.benefit
sim_features_data
# evaluate input data
<- inputData(pu = sim_pu_data,
b.continuous features = sim_features_data,
dist_features = sim_dist_features_data,
threats = sim_threats_data,
dist_threats = sim_dist_threats_data,
sensitivity = sim_sensitivity_data,
boundary = sim_boundary_data)
# create the mathematic model
<- problem(b.continuous,
c.continuous model_type = "minimizeCosts")
```

`## Warning: The blm argument was set to 0, so the boundary data has no effect`

`## Warning: Some blm_actions argument were set to 0, so the boundary data has no effect for these cases`

```
# solve the model
<- solve(c.continuous,
d.continuous solver = "gurobi",
verbose = TRUE,
output_file = FALSE,
cores = 2)
```

```
## Gurobi Optimizer version 9.1.2 build v9.1.2rc0 (linux64)
## Thread count: 2 physical cores, 4 logical processors, using up to 2 threads
## Optimize a model with 284 rows, 396 columns and 766 nonzeros
## Model fingerprint: 0xfea67198
## Variable types: 176 continuous, 220 integer (220 binary)
## Coefficient statistics:
## Matrix range [2e-04, 2e+00]
## Objective range [1e-01, 1e+01]
## Bounds range [1e+00, 1e+00]
## RHS range [2e+00, 5e+00]
## Found heuristic solution: objective 153.7000000
## Presolve removed 250 rows and 248 columns
## Presolve time: 0.00s
## Presolved: 34 rows, 148 columns, 278 nonzeros
## Found heuristic solution: objective 42.4000000
## Variable types: 0 continuous, 148 integer (146 binary)
##
## Root relaxation: objective 2.011896e+01, 17 iterations, 0.00 seconds
##
## Nodes | Current Node | Objective Bounds | Work
## Expl Unexpl | Obj Depth IntInf | Incumbent BestBd Gap | It/Node Time
##
## 0 0 20.11896 0 9 42.40000 20.11896 52.5% - 0s
## H 0 0 29.1000000 20.11896 30.9% - 0s
## H 0 0 21.9000000 20.11896 8.13% - 0s
## H 0 0 21.8000000 20.11896 7.71% - 0s
## 0 0 20.82302 0 3 21.80000 20.82302 4.48% - 0s
## 0 0 20.91403 0 3 21.80000 20.91403 4.06% - 0s
## 0 0 21.21879 0 4 21.80000 21.21879 2.67% - 0s
## 0 0 21.47599 0 5 21.80000 21.47599 1.49% - 0s
## 0 0 21.53170 0 5 21.80000 21.53170 1.23% - 0s
## 0 0 21.54367 0 6 21.80000 21.54367 1.18% - 0s
## 0 0 21.58911 0 6 21.80000 21.58911 0.97% - 0s
## 0 0 21.59162 0 7 21.80000 21.59162 0.96% - 0s
## 0 0 21.59578 0 8 21.80000 21.59578 0.94% - 0s
## 0 0 21.61294 0 8 21.80000 21.61294 0.86% - 0s
## 0 0 cutoff 0 21.80000 21.80000 0.00% - 0s
##
## Cutting planes:
## Gomory: 2
## Cover: 3
## MIR: 1
## StrongCG: 2
## RLT: 1
##
## Explored 1 nodes (56 simplex iterations) in 0.01 seconds
## Thread count was 2 (of 4 available processors)
##
## Solution count 5: 21.8 21.9 29.1 ... 153.7
##
## Optimal solution found (tolerance 0.00e+00)
## Best objective 2.180000000000e+01, best bound 2.180000000000e+01, gap 0.0000%
```

Note that the maximum benefits to be achieved have changed due to the
presence of intensities in the threats and the sensitivity curves (with
respect to the base model). We can use
`getPotentialBenefit()`

to explore the difference between
these benefits:

```
# get potential benefits
getPotentialBenefit(b.continuous)
```

```
## feature dist dist_threatened maximum.conservation.benefit maximum.recovery.benefit maximum.benefit
## 1 1 47 47 0 13.7781 13.7781
## 2 2 30 28 2 14.6788 16.6788
## 3 3 66 56 10 32.9739 42.9739
## 4 4 33 33 0 15.9912 15.9912
```

Now by the `getSolutionBenefit()`

function, we can obtain
how the benefits are distributed for the different features. Notice that
we use the `type = "local"`

argument to obtain the benefits
per unit and feature.

```
# get benefits of solution
<- getSolutionBenefit(d.continuous, type = "local")
local_benefits.continuous
# plot local benefits
<- reshape2::dcast(local_benefits.continuous, pu~feature,value.var = "benefit.total", fill = 0)
local_benefits.continuous
values(group_rasters[[1]]) <- local_benefits.continuous$`1`
values(group_rasters[[2]]) <- local_benefits.continuous$`2`
values(group_rasters[[3]]) <- local_benefits.continuous$`3`
values(group_rasters[[4]]) <- local_benefits.continuous$`4`
plot(group_rasters)
```

Note that the selected sites differ to a greater extent from those chosen in the base model with binary threat intensities. From the above, the effect that can bring with the use of sensitivities and intensities of continuous threats on the management of conservation actions is extracted.

Cattarino, Lorenzo, Virgilio Hermoso, Josie Carwardine, Mark J. Kennard,
and Simon Linke. 2015. “Multi-Action Planning for Threat
Management: A Novel Approach for the Spatial Prioritization of
Conservation Actions.” Edited by Duccio Rocchini. *PLOS
ONE* 10 (5): e0128027. https://doi.org/10.1371/journal.pone.0128027.

Salgado-Rojas, José, Eduardo Álvarez-Miranda, Virgilio Hermoso, Jordi
Garcia-Gonzalo, and Andrés Weintraub. 2020. “A Mixed Integer
Programming Approach for Multi-Action Planning for Threat
Management.” *Ecological Modelling* 418: 108901.