Multi-UAV Routing for Persistent Intelligence Surveillance & Reconnaissance Missions

TL;DR

This paper addresses a complex UAV routing problem for persistent surveillance, aiming to optimize data delivery times while respecting task revisit constraints, using mixed integer programming and heuristics for efficient solutions.

Contribution

It formulates a novel PISR routing problem with revisit constraints and develops both exact and heuristic algorithms for effective path planning.

Findings

Heuristic algorithms significantly reduce computation time.

Optimal solutions outperform heuristics in cost but take longer to compute.

The approach effectively balances data freshness and routing efficiency.

Abstract

We consider a Persistent Intelligence, Surveillance and Reconnaissance (PISR) routing problem, which includes collecting data from a set of specified task locations and delivering that data to a control station. Each task is assigned a refresh rate based on its priority, where higher priority tasks require higher refresh rates. The UAV team's objective is to minimize the maximum of the delivery times of all the tasks' data to the control station, while simultaneously, satisfying each task's revisit period constraint. The centralized path planning problem for this PISR routing problem is formulated using mixed integer linear programming and solved using a branch-and-cut algorithm. Heuristics are presented to find sub-optimal feasible solutions that require much less computation time. The algorithms are tested on several instances and their performance is compared with respect to the optimal cost and computation time.

Tables

Table 1. TABLE I: Computational Results using the MILP formulations and the Tree Search Heuristic

Instance #	$\left|T\right|$	${ℱ}_1$		${ℱ}_3$		Tree Search Heuristic
		Cost	CPU time	Cost	CPU time	BFS Cost	BFS CPU time	Final Cost	Final CPU time
1	10	2786	0.07	2786	0.31	3773	0.001	2801	5.185
2	10	4598	0.06	4598	0.22	5651	0.001	4598	5.255
3	10	4756	0.11	4756	0.99	5687	0.001	4756	5.444
4	10	5315	0.15	5315	1.01	7705	0.001	5315	5.379
5	10	3751	0.09	3751	0.89	4786	0.001	3751	5.295
6	10	3921	0.08	3921	0.29	4380	0.004	3921	5.200
7	10	3364	0.07	3364	0.16	5219	0.001	3364	5.263
8	10	3972	0.06	3972	0.53	7891	0.002	4515	5.275
9	10	3383	0.08	3383	0.18	5536	0.001	3383	5.475
10	10	3700	0.09	3700	0.59	4825	0.002	3700	5.275
11	20	6860∗	3600∗	6500	29	8043	0.005	7240	8.356
12	20	5260∗	3600∗	5260	153	5857	0.004	5592	8.089
13	20	6700∗	3600∗	6510	180	8993	0.004	8993	8.685
14	20	6740∗	3600∗	6680	14	9823	0.006	9252	8.585
15	20	6540∗	3600∗	6540	56	11704	0.005	8171	8.514
16	20	5960∗	3600∗	5960	18	9518	0.004	7866	8.685
17	20	6040∗	3600∗	5930	20	9220	0.005	8007	8.860
18	20	5800∗	3600∗	5800	238	9832	0.004	7148	8.390
19	20	6080∗	3600∗	6080	270	7992	0.005	7409	8.178
20	20	4100∗	3600∗	4100	219	7056	0.005	7056	9.031
21	30	∗∗	∗∗	7280	8623	26277	0.010	23418	10.328
22	30	∗∗	∗∗	7290	4967	12920	0.010	10682	10.585
23	30	∗∗	∗∗	6900∗	10000∗	22461	0.012	16536	10.356
24	30	∗∗	∗∗	7160	8070	21070	0.010	17186	10.266
25	30	∗∗	∗∗	6430∗	10000∗	9394	0.011	8911	10.545
26	30	∗∗	∗∗	7420∗	10000∗	16488	0.010	15315	10.383
27	30	∗∗	∗∗	7190∗	10000∗	11785	0.010	9663	10.681
28	30	∗∗	∗∗	7490∗	10000∗	11613	0.011	11613	10.530
29	30	∗∗	∗∗	7160	4886∗	10159	0.010	10159	10.542
30	30	∗∗	∗∗	6560∗	10000∗	10413	0.011	10031	10.954
∗Instances are not converged to the optimal solution with in the specified time limit; the best found solution is reported.
∗∗Instances could not find a solution within the set time limit.

Equations

$$\sum _{j\in V}{x}_{ij}=1\text{mbox}and\sum _{j\in V}{x}_{ji}=1,\forall i\in T,$$

$$\sum _{j\in T}{x}_{dj}\le n_v\text{mbox}and\sum _{j\in T}{x}_{jd}\le n_v,$$

$$x_{ij}\in \{0,1\}\forall (i,j)\in E.$$

$$u_i-u_j+c_{ij}\le M(1-x_{ij}),\forall i\in V,j\in T$$

$$c_{di}\le u_i\le R_i-c_{id},\forall i\in T,$$

$$v_j-v_i+c_{ij}\le M(1-x_{ij}),\forall i\in T,j\in V$$

$$c_{id}\le v_i\le R_i-c_{di},\forall i\in T.$$

$$u_i+v_j\le R_i,\forall i\in T.$$

$$\text{mbox}Minimizez$$

$$v_i\le z,\forall i\in T.$$

$$({\mathcal{F}}_1)\text{mbox}Minimizez$$

$$({\mathcal{F}}_2)\text{mbox}Minimizez$$

$$\sum _{j\in V}{x}_{ij}=1\text{mbox}and\sum _{j\in V}{x}_{ji}=1,\forall i\in T,$$

$$\sum _{j\in T}{x}_{dj}\le n_v\text{mbox}and\sum _{j\in T}{x}_{jd}\le n_v,$$

$$\sum _{j\in V}{y}_{ij}-\sum _{j\in V}{y}_{ji}=\sum _{j\in V}{c}_{ij}{x}_{ij},\forall i\in T,$$

$$y_{di}=c_{di}{x}_{di},\forall i\in T,$$

$$0\le y_{ij}\le R_j{x}_{ij},\forall i\in V,j\in T,$$

$$\sum _{j\in V}{w}_{ji}-\sum _{j\in V}{w}_{ij}=\sum _{j\in V}{c}_{ji}{x}_{ji},\forall i\in T,$$

$$w_{id}=c_{id}{x}_{id},\forall i\in T,$$

$$0\le w_{ij}\le D_i{x}_{ij},\forall i\in T,j\in V$$

$$\sum _{j\in V}{y}_{ji}+\sum _{j\in V}{w}_{ij}\le R_i,\forall i\in T,$$

$$w_{ij}\le z,\forall i\in T,j\in V,$$

$$x_{ij}\in \{0,1\}\forall (i,j)\in E.$$

$$y_{ij}\le (R_j-c_{jd})x_{ij},\forall i,j\in V,$$

$$y_{id}\le R_i{x}_{id},\forall i\in V,$$

$$y_{ij}\ge (c_{di}+c_{ij})x_{ij},\forall i,j\in V,,$$

$$w_{ij}\le (R_i-c_{di})x_{ij},\forall i,j\in V,,$$

$$w_{di}\le R_i{x}_{di},\forall i\in V,$$

$$w_{ij}\ge (c_{ij}+c_{jd})x_{ij},\forall i,j\in V.$$

$$w_{di}-c_{di}\le z,\forall i\in T.$$

$$({\mathcal{F}}_3)\text{mbox}Minimizez$$

$$(\text{ref}cons:deg1)-(\text{ref}cons:secy2),(\text{ref}cons:secw1),(\text{ref}cons:secw2),(\text{ref}cons:revprd),\text{mbox}and(\text{ref}cons:xbin)-\text{ref}cons:strenmaxdt).$$

Full text

I Introduction

Unmanned Aerial Vehicles (UAVs) are a natural choice for deployment in many military Intelligence, Surveillance and Reconnaissance (ISR) missions[1]. A typical ISR scenario involves monitoring a set of task locations for an indefinitely long period of time. These task locations can be buildings, road networks bordering a military base etc. Since these task locations are spatially dispersed, UAVs can be deployed to visit them regularly and ferry the information such as images, videos, sensor data etc. to a control station. This data needs to be delivered to the control station at regular intervals. The importance level of each of the task locations may vary from minimal to highly critical. While scheduling these monitoring missions, it is imperative to schedule the UAV to visit important task more frequently than the ones with lesser significance.

We consider a persistent monitoring scenario, where a set of task locations needs to be visited persistently by multiple UAVs. We assume all the available UAVs are homogeneous. Therefore, there is no difference between visits by different UAVs to the same task. We are interested in two metrics viz. data latency or delivery time (to the control station) and revisit rate or revisit period. We define the data delivery time (or latency time) as the time elapsed from collection of data from a task to the time the data is delivered to the control station. The data needs to be delivered at control stations as early as possible. The revisit period is the time between two successive visits to a task location; a task with higher priority needs to have a smaller revisit period compared to a low priority.

Prior work: Several variants of persistent routing problem were addressed in [2, 3, 4, 5, 6, 7, 8, 9, 10]. Strategies to perform patrolling tasks by multiple agents on a network defined as a graph are presented in [2]. In [3, 4], persistent surveillance of an area decomposed into cells is considered; [3] attempts to minimize the maximum time since last visit of all the cells, whereas [4] balances the frequency of visit to each cell. Persistent surveillance problems with tasks spatially distributed is posed as a vehicle routing problem with time windows in [5]. Patrolling strategies to minimize the refresh time of the viewpoints is presented in [6]. Approximation algorithms are presented in [8], that minimize the maximum weighted latency (time between successive visits) in discrete environments. In [9], the authors attempts to minimize time between two consecutive visits to partitioned regions while satisfying temporal logic constraints of each agent. A persistent routing scenario where some regions need more visitation than others is addressed in [10], and a policy to achieve that is proposed.

In this article, we consider a persistent routing of tasks that are spatially distributed. Also the data collected at the task locations needs to be delivered at a control station (also referred to as depot). In the existing literature concerning persistent routing, the concept of a control station is not considered and delivery time is not addressed.

We model this persistent routing problem as a multiple traveling salesman problem with revisit period constraints, and formulated as a mixed integer linear programming (MILP) problem. The contributions of this article are the following: ($i$) We present a novel formulation addressing two important metrics, delivery time and revisit period for the tasks in ISR missions and model it as a multiple vehicle path planning problem with cycle length constraints. ($ii$) We present two different MILP models to find optimal solutions to the corresponding path planning problem. The two MILP models constitute novel constraints to address the cycle length limits, which could be applied to any general routing problem involving constraints on cycle length. ($iii$) A heuristic via assignment-tree search is presented that produces good sub-optimal solutions, and it could be easily generalized to address different cost functions and/or constraints. ($iv$) We test the algorithms on several random instances and computational results are presented.

The PISR routing problem is closely related to the distance constrained and fuel constrained vehicle routing problems [11, 12]. This problem differs from these as follows: rather than the constraints being dictated by the UAV, the constraints on a tour are dictated by the tasks a UAV visits, which is a harder constraint to deal with. Also the cost function chosen here to capture the latency requirements is different from the cost of distance constrained VRPs.

II Preliminaries and Assumptions

Here, we aim to optimize the total cost of the persistent ISR mission by centralized planning. We are looking at solving the problem before the mission begins and assigning the tasks for each UAV/agent to perform in a pre-specified sequence. Ideally, in a persistent routing scenario, the objective is to optimize the chosen metrics over an infinite time horizon. To plan the mission and schedule tasks to be serviced by each UAV, we need to generate an infinite sequence of visits for each UAV, which is infeasible. To overcome this, one may periodically solve a receding horizon problem, generate the task sequences and schedule the UAVs as proposed in [5]. However, reliable UAV-to-UAV communication links would be required, as well as the precise location of all the UAVs each time the planner is executed.

A critical assumption we make for a-priori mission planning is the following: we restrict each task to be serviced by the same UAV throughout the mission. Each UAV performs the tasks assigned and returns to the control station, and repeats exactly the same sequence throughout the mission. For example consider a mission with two UAVs and five tasks $\{t_{1},t_{2},t_{3},t_{4},t_{5}\}$, and let $t_{d}$ represent the control station (or depot). A sample assignment for two vehicles $V_{1}$ and $V_{2}$ is as follows: $V_{1}:t_{d}\rightarrow t_{1}\rightarrow t_{2}$ and $V_{2}:t_{d}\rightarrow t_{3}\rightarrow t_{4}\rightarrow t_{5}$. Here, if the time of travel for the sequence $t_{d}\rightarrow t_{1}\rightarrow t_{2}\rightarrow t_{d}$ is $R_{1}$ seconds, then tasks $t_{1}$ and $t_{2}$ are serviced once every $R_{1}$ seconds.

Some of the advantages of this class of solutions are the following: we do not need to have communication between UAVs to update the scheduled tasks at each planning time interval. Whenever a UAV breaks down or needs refueling, the operator precisely knows which tasks are not being serviced, such that a contingency plan could be scheduled. The revisit period for each task is exactly known based on the tasks and the sequence assigned to the UAVs. Also under this restriction, the data that is collected from a task is delivered to the control station before its next visit. This is not guaranteed in the unrestricted case, where a task could be serviced by two different UAVs at successive visits. Along with the above advantages, there is a shortcoming; the cost one would optimize with this restriction could be different from the cost of the unrestricted case. However, due to its advantages in planning the mission and implementing, we pursue the restricted case where each tasks is assigned to one of the UAVs, and it is serviced by the same UAV throughout the mission.

There are two important metrics that needs to be addressed in PISR missions. The first one is the data delivery time or data latency ($D_{i}$) for each task $t_{i}$; $D_{i}$ is the elapsed time from when a task is completed until the vehicle returns to the depot. This is not the direct travel time between the task and the depot, as the vehicle may service other tasks before returning to depot. This is illustrated in Fig. 1, the delivery time for the tasks $t_{3}$, $t_{4}$ and $t_{5}$ are shown as $D_{3}$, $D_{4}$ and $D_{5}$ respectively.

The other metric that we consider is the revisit period of each task. It is the time between two successive visits of a task by an UAV. Since each UAV visits the same set of tasks and repeats, the revisit period is the same for every successive visit. The revisit periods $R_{1}$ and $R_{2}$ are illustrated in Fig. 1 for the tasks $t_{1}$ and $t_{2}$. Based on the importance or risk levels, some of the tasks require higher revisit rates than others. We aim to solve the PISR routing problem where a maximum limit on revisit period, $R_{i}$, is specified for each task $t_{i}$. We want the data delivered at the control station to be as fresh as possible, which requires the delivery times to be as small as possible. To accomplish this, we minimize the maximum delivery time of all the tasks: $\min\max_{i\in T}D_{i}$. This cost is different from minimizing total cost of the paths, and it is a measure of the delivery time of the first task that is serviced.

III Problem Formulation

In this section, we define the path planning problem for the PISR missions in more detail. Also we present a mixed integer linear programming (MILP) formulation to find the optimal solution to the path planning problem. We model the MILP using node based and arc based formulations; these models are akin to the models in [13] and [11] used to solve the traveling salesman problem with time windows and the distance constrained vehicle routing problem. Similar formulations were also used to solve fuel constrained multiple vehicle routing problem in [12]. In these articles, the constraints on the length of a tour starting from a depot are constrained. In the formulation presented here, the length of a tour starting from a depot to each task and the length starting from the task returning to the depot together are constrained. The novelty of this formulation lies in modeling and constraining these two lengths together. Also this could be applied to other routing problem which requires to handle cycle lengths such as min-max traveling salesman problem.

Let $T=\{t_{1},t_{2},\ldots t_{n}\}$ represent a set of tasks, and as in the previous example $d$ be the index referring to the depot. We define the problem on a graph $G(V,E)$. $V$ is the set of nodes $V=T\cup\{d\}$, and $E$ is the set of edges between every pair of nodes in $V$. Let $n_{v}$ represent the number of UAVs available for the mission. The problem can be stated as the following: find at most $n_{v}$ cycles that minimizes the maximum delivery time such that, $(i)$ each task $T$ is covered by one cycle, and $(ii)$ if a task $t_{i}$ assigned to one of the UAVs, $v$, with cycle length $L_{v}$, then $L_{v}\leq R_{i},\,\forall i\in T$.

III-A MILP Formulation

In the MILP formulation, we use a set of binary variables $x_{ij}$’s and two sets of real variables $u_{i}$’s and $v_{i}$’s. Each variable $x_{ij}$ corresponds to an edge $(i,j)$, and $x_{ij}=1$ if edge $(i,j)$ is in any of the UAV cycles. Otherwise, $x_{ij}=0$. For a particular cycle (assignment), the variables $u_{i}$’s denote the travel time from the depot to the task $t_{i}$, and $v_{i}$’s represent the return travel time along the cycle from task $t_{i}$ to the depot; this is illustrated in Fig. 2. Let $c_{ij}$ represent the time elapsed from task $t_{i}$ to task $t_{j}$. Here, $c_{ij}$ includes the time of travel between the tasks and the time to perform task $t_{j}$. Now we present the MILP formulation using degree constraints, sub-tour elimination constraints (SEC) and revisit period constraints.

Degree constraints:

[TABLE]

Constraints in Equation (1) state that for every node representing a task, there should be one incoming edge and one outgoing edge. The constraints (2) state that there should be a maximum of $n_{v}$ number of incoming and outgoing edges for the depot node; and the binary constraints on the $x_{ij}$ variables are in (3).

Sub-tour elimination constraints:

[TABLE]

With just the degree constraints, the MILP may produce solutions containing sub-tours; a sub-tour is an assignment where a subset of tasks are connected as a cycle, but are isolated from the depot. One may refer to [14] for further reading on sub-tours. One can remove these infeasible solutions using the sub-tour elimination constraints. To this end, we use the inequalities (4, 5) similar to the MTZ-constraints used to solve traveling salesman problem[15, 14]. If an edge $(i,j)$ is present in the tour, then the value of the variable $u_{j}$ should be at least the sum of travel time from depot to task $t_{i}$ and the travel time from task $t_{i}$ to $t_{j}$. If $x_{ij}=1$, then $u_{j}\geq u_{i}+c_{ij}$. This is enforced by the constraints in (4), where $M$ (referred to as big-$M$ in literature) is a constant of arbitrarily high value. When $x_{ij}$ is zero, the constraint (4) is trivially satisfied. For every $t_{i}$, the minimum value of $u_{i}$ is the direct travel time from the depot to the task, and the maximum is $R_{i}-c_{id}$. These lower and upper limits on $u_{i}$’s are imposed by (5). Inequalities (6), (7) are equivalent to (4), (5), using the variables $v_{i}$’s instead. Inequality (6) states that, when $x_{ij}=1$, then $v_{j}$ should be less then $v_{i}-c_{ij}$. Either the set of constraints (6), (7) or (4), (5) are sufficient to eliminate the sub-tours, but we need both of these to formulate the revisit period constraint, which need both sets of variables, $u_{i}$’s and $v_{i}$’s.

Revisit period constraints:

[TABLE]

For each task, $u_{i}$ is the time of travel from the depot to the task $t_{i}$, and $v_{i}$ is the return time of travel from the task to the depot. Hence, the sum of these two variables gives the time of travel of the full cycle which covers the task $t_{i}$. Therefore, inequalities (8) enforce the revisit period constraints for all of the tasks in $T$.

Objective:

[TABLE]

The variables $v_{i}$’s also are equal to the delivery time of the data collected from each task. To minimize the maximum of all the delivery time, we introduce an auxiliary variable $z$, which is needed to formulate the $\min$-$\max$ objective. The objectives $\min z$ and the inequality (9) together minimize the maximum of all of the delivery times ($v_{i}$’s).

The MILP formulation for the PISR routing problem is the following:

[TABLE]

In the above formulation, the big-$M$ in the constraints (4), (6) is known to cause computational problems [13, 16], and hence make the MILP model computationally less efficient. We propose a second formulation without big-$M$ constraints and compare the computational performance of these two formulations.

III-B Formulation based on arcs ($\mathcal{F}_{2}$)

Here, we use the binary variables $x_{ij}$’s similar to the previous formulation, and the real variables $y_{ij}$’s and $w_{ij}$’s $\forall i,j\in V$ are used instead of $u_{i}$’s and $v_{i}$’s. Variables $y_{ij}$ represent the travel time from depot to the task $t_{j}$ if the edge $(i,j)$ is selected in the assignment, i.e., $x_{ij}=1$. Also, when $x_{ij}=1$ the variable $w_{ij}$ is equal to the return travel time from $t_{i}$ to the depot. For each task $t_{i}$, only one of the variables in the set $y_{ij},\,j\in T$ and one of the variables in the set $w_{ij},\,j\in T$’s are non-zero. The arc based MILP formulation to solve the PISR routing problem is the following:

[TABLE]

Here, constraints in the Equation (10) are the degree constraints, which enforce that only one incoming and one outgoing edge exists for any task. Equation (11) imposes the maximum number of edges going out of and coming into depot to be $n_{v}$. The time elapsed from leaving the depot to the end of the task $t_{i}$ is given by the summation $\sum_{j\in V}y_{ji}$, and the time from leaving the depot to the end of the task that is serviced after $t_{i}$ is given by the summation $\sum_{j\in V}y_{ij}$; these two summation are illustrated in Fig. 3. Constraints (12) and (13) ensure that the difference between these two should be equal to the time between $t_{i}$ and task serviced after $t_{i}$. These constraints are needed to eliminate the sub-tours. Equations (14) ensures the variables $y_{ij}$’s are non-negative always, and nonzero only when $x_{ij}=1$. Constraints in (15) are the counterpart of (12), where the summations $\sum_{j\in V}w_{ij}$ and $\sum_{j\in V}w_{ji}$ are the return travel times to the depot from the task $t_{i}$ and the task serviced before $t_{i}$ respectively. The difference between these two should be equal to the time between these two tasks, and this is imposed by constraints in (15) and (16). The non-negative and non-zero constraints on variables $w_{ij}$’s are enforced by (17). The set of constraints (12) - (14) or (15) - (17) are sufficient to eliminates the sub-tours, however we need both of these to implement the revisit rate constraints.

The summation $\sum_{j\in V}y_{ji}$ is the time of travel for a UAV from the depot to the task $t_{i}$, and the summation $\sum_{j\in V}w_{ij}$ is the return travel time from the task $t_{i}$ to the depot. If UAVv is visiting task $t_{i}$, then these two summations adds up to the total time elapsed to service all the tasks assigned to UAVv. Constraints (18) enforces the maximum limit on the revisit period for each of the tasks. The variables $w_{ij}$’s are the delivery time of the tasks, hence the objective function $\min z$ and the inequalities (19) together minimizes the maximum delivery time.

Proposition III.1**.**

Inequalities (13) - (14) and (16) - (17) in formulation $\mathcal{F}_{2}$ can be strengthened using the following inequalities:

[TABLE]

Proof.

When $j$ is not the depot index, sum of the time from leaving the depot to the end of task $t_{j}$ and $c_{jd}$, direct travel time from the end of task $t_{j}$ to the depot should be less than the revisit period limit for the task $t_{j}$. This inequality is expressed in (21), and since $c_{jd}$ is non-negative, (21) is tighter than (14). Inequality (22) is same as (14) where $j$ is the depot index. Inequality (23) indicates that when $i$ and $j$ are not depot indices and $x_{ij}=1$, then the time to travel from depot to $t_{j}$ should be at least the sum of time to travel from depot to $t_{i}$ and time of travel from $t_{i}$ to $t_{j}$.

Inequalities (24) - (26) are counterpart of the inequalities (21) - (23) for the $w_{ij}$ variables. Inequality (24) states that, when $x_{ij}=1$, sum of the direct time of travel from depot to $t_{i}$ and time from $t_{i}$ to depot along the cycle should be less than the revisit period limit of $t_{i}$. When $x_{ij}=1$, $w_{ij}$ is the time from end of task $t_{i}$ to returning to the depot, which should be at least the sum of time to travel from $t_{i}$ to $t_{j}$ and time to travel from $t_{j}$ to the depot; this is enforced by (26). ∎

Proposition III.2**.**

To minimize the maximum delivery time, inequalities (19) can be replaced with the following inequalities:

[TABLE]

Proof.

Clearly, the first task serviced has the highest delivery time. If $t_{i}$ is the first task, then $w_{di}-c_{di}$ is the delivery time for $t_{i}$. Therefore, the objective $\min z$ along with inequalities (27) minimizes the maximum delivery time. Note that, if $t_{i}$ is not the first task visited, then $w_{di}=0,$ and (27) is trivially satisfied. ∎

We present the strengthened arc based formulation as follows:

[TABLE]

IV Assignment Tree Search Heuristic

In this section, we present a heuristic to solve the PISR routing problem. The heuristic is a greedy assignment tree search, based on the prior work in [17, 18], for planning missions involving multiple UAVs. Here, we present a synopsis of the tree search algorithm, however one can refer to [17, 18] for further details. This tree search follows a best first search pattern until it finds a feasible assignment. At the root node, the algorithm creates branches and a child node at each branch. Each child corresponds to an assignment of one of the tasks to one of the available UAVs. The number of child nodes are all possible ways to select one unassigned task and assign it to a UAV. Among all the child nodes, the algorithm selects the node with the least cost, and repeats the branching process similar to the branching at root node. This process repeats until all the tasks are assigned. At this point in the search the algorithm arrives at a ”leaf” node, which corresponds to a feasible solution to the planning problem. Once, a feasible assignment is found the algorithm stores the solution as an incumbent solution. It proceeds to search the tree by evaluating the unexplored child nodes, and tries to find solutions of lower cost than the incumbent solution. Also, the tree search prunes the branches before reaching a leaf node, if the current cost at the branch is more than the incumbent solution. The search is terminated either when it finds a feasible solution, or if it reaches a pre-specified maximum number of nodes to be explored.

We use this tree search heuristic to find feasible paths for the PISR routing problem. The algorithm is adapted to find feasible paths, such that the cycle lengths of each UAV adheres to the revisit period constraints of the tasks the UAV is assigned, and minimizes the maximum delivery time of all the tasks.

Tree search heuristic:

Initialize the problem at a root node with the following: the locations of the tasks, time of travel between the tasks, the maximum limit on the revisit period for each task, and the number of UAVs available. 2. 2.

Create child nodes ($n_{i}$), each corresponds to an assignment of a task to an available UAV. Each node corresponds to a list of assignments for each UAV.

1. (i)

Compute the current cost of each child node $C(n_{i})$, which is the maximum of the delivery times of all the tasks. For example, a UAV is assigned tasks in the order $t_{s_{1}},t_{s_{2}},t_{s_{3}}$, the maximum of the delivery times is the sum $c_{{s_{1}}{s_{2}}}+c_{{s_{2}}{s_{3}}}+c_{{s_{3}}{d}}$. ( Here, $c_{ij}$ is the sum of the time of travel between $t_{i}$ and $t_{j}$ and the time to performs task $t_{j}$.) 2. (ii)

Check if the assignments violates the revisit period constraints of all the tasks assigned so far. For example if the tasks, $t_{s_{1}},t_{s_{2}},t_{s_{3}}$ are assigned to an UAV, compute the travel time of the cycle $c_{d{s_{1}}}+c_{{s_{1}}{s_{2}}}+c_{{s_{2}}{s_{3}}}+c_{{s_{3}}{d}}$ is less than $R_{s_{1}}$, $R_{s_{2}}$ and $R_{s_{3}}$. If any UAV violates the revisit period constraints, assign an infinite cost to the child node. 3. 3.

To select a child node for further branching, we scale the cost based on two factors based on the current task and current UAV that are assigned at each node. The first scale $C_{s_{1}}$ is to force a task with the lowest revisit period limit to be assigned earliest to an UAV. $C_{s_{1}}=\frac{R_{i}}{R_{max}}i$, where $R_{j}$ is the maximum revisit period limit of the task $t_{j}$ that is assigned at the current node, and $R_{max}$ is the maximum revisit period limits of all the tasks. The second scale $S_{c_{2}}$ is to prioritize a UAV which is assigned a task with revisit limits in earlier assignments (at parent or above nodes); $S_{c_{2}}=10^{-n_{t}}$, where $n_{t}$ is the number of revisit period constrained tasks assigned to the current UAV. 4. 4.

Select the child node with the lowest scaled cost $S_{c_{1}}S_{c_{2}}C(n_{i})$, and repeat the branching, steps 2 - 3, until a leaf node is found. Update the incumbent solution, and proceed to explore the unevaluated child nodes at the parent nodes and further until another leaf node is found. 5. 5.

Exit the tree search when there are no child nodes to be evaluated, or the number of nodes evaluated reaches the specified limit, and output the solution with the lowest cost.

V Computational Results

The MILP formulations $\mathcal{F}_{1}$ and $\mathcal{F}_{3}$ are solved using branch and cut algorithm. The algorithms are implemented using CPLEX (version 12.6) with C++ API. CPLEX solves the MILP using branch and cut algorithm, which generates the feasible solutions (upper bounds) and lower bounds based on a solution to the dual problem iteratively, and outputs the optimal solution when the gap between the lower bound and upper bound converges to zero. All the simulations were run on a Macbook with Intel i5, $2.7$ GHz processor and 8 GB memory. We generated random instances by choosing task locations ($xy$-coordinates) from an uniform distribution in a square grid of size $4000\times 4000$ meters. We have tested the algorithms on $30$ random instances, $10$ each with $10$, $20$ and $30$ tasks and $4$ UAVs. We impose the revisit period constraints on $3$, $4$ and $5$ of the tasks for the instances with $10$, $20$ and $30$ tasks respectively. For all the instances, we have chosen the task farthest from the depot, and the revisit period limit is set to $1.1$ times the sum of the time from the depot to the farthest task and the task to the depot. We have selected the nearest $2$, $3$ and $4$ tasks for the instances with $10$, $20$ and $30$ tasks respectively to set the revisit period limits. We set the revisit period limit to be $1.1$ times the optimal cost of the traveling salesman problem solved on these tasks including the depot, with travel times as the cost of travel between tasks. We assume the UAVs travel at unit speed (one meter per second), and the Euclidean distance between the task locations is chosen to be the travel times between them. The tree search heuristic is implemented in C++, and the maximum number of nodes to be evaluated is set to one million.

The computational results for the $30$ instances are shown in the Table I. The first and second column refers to the instance number and the number of tasks in the instance respectively. The third and fourth column refers to the cost of the solution and the computation time required by the formulation $\mathcal{F}_{1}$. The fifth and sixth column refers to the solution cost and the computation time required for solving using formulation $\mathcal{F}_{3}$. A time limit of one hour and $2.5$ hours are set for solving the instances with $20$ and $30$ tasks. For the instances where the algorithm could not find optimal solutions in the set time limit, the cost of the best found solution are listed. All the computation times reported are in seconds. The seventh and eighth columns refer to the cost of the first feasible solution found (referred to as best first search solution) and the corresponding computation time by the tree search heuristic. The ninth and tenth columns refer to the final cost of the heuristic solution and the computation time required after exploring one million nodes of the tree.

With the formulation $\mathcal{F}_{1}$, the branch-and-cut algorithm could not converge with in the time limit for instances with $20$ and $30$ tasks. We could find optimal solutions for all the instances with $10$ and $20$ tasks using the formulation $\mathcal{F}_{3}$, and for $4$ out of $10$ instances with the $30$ tasks. Though tight feasible solutions are found, the lower bounds given by the LP relaxations of these formulations are not tight enough, and therefore the algorithm needs more computation time to converge. Finding better valid inequalities may solve this problem, which can be a future direction of this research. From the computational results, clearly the formulation $\mathcal{F}_{3}$ outperformed $\mathcal{F}_{1}$. The tree search heuristic generated a best first search solution within $11$ milliseconds and final solutions with in $11$ seconds for all the instances. Also the cost of these solutions are within $50\%$ of the optimal for most of the instances. This heuristic is well suitable for quick planning and onboard re-planning of the missions. Plots of the solutions found by solving the MILP formulation $\mathcal{F}_{3}$ and the heuristic for an instance with $20$ tasks are shown in Fig. 4. One can see that the tasks $t_{6},\,t_{8}$ and $t_{14}$ with tight revisit period limits lie on a UAV tour with the smallest tour length. The task $t_{10}$ also has revisit period limits, however the corresponding UAV also visits other tasks without violating the revisit period constraints of $t_{10}$.

VI Conclusion

We considered a path planning problem for PISR missions that involves multiple UAVs collecting data from spatially dispersed tasks, and delivering at a depot. We have modeled this as an optimization problem to minimize the maximum delivery time for all the tasks while satisfying the revisit period constraints for the high priority tasks. To find optimal solutions, we presented two MILP formulations $\mathcal{F}_{1}$ and $\mathcal{F}_{3}$, which include novel constraints to satisfy revisit period limits. These formulations are solved using branch and cut algorithm, and it could find optimal solutions for instances up to thirty tasks. Also, we presented a heuristic based on assignment tree search; it produces sub-optimal solutions which require only a few seconds of computation time. The heuristic could find feasible solutions for all the instances with in $10$ milliseconds. For the missions where onboard re-planning is necessary due to change in the tasks or locations, this heuristic is well suitable for quick onboard re-planning. The future directions of this research include finding better valid inequalities for the formulations to strengthen the lower bounds for computational efficiency. Also one can develop similar MILP models to find paths that minimizes the weighted sum of the revisit periods of all the tasks.