# A GRASP for Next Generation Sapphire Image Acquisition Scheduling

Authors: Yang Wang; Snezana Mitrovic Minic; Robert Leitch; Abraham P. Punnen
Journal: International Journal of Aerospace Engineering
 (2016)

---

## Abstract

This paper investigates an image acquisition scheduling problem for a Canadian surveillance-of-space satellite named Sapphire that takes images of deep space Earth-orbiting objects. For a set of resident space objects (RSOs) that needs to be imaged within the time horizon of one day, the Sapphire image acquisition scheduling (SIAS) problem is to find a schedule that maximizes the “Figure of Merit” of all the scheduled RSO images. To address the problem, we propose an effective GRASP heuristic that alternates between a randomized greedy constructive procedure and a local search procedure. Experimental comparisons with the currently used greedy algorithm are presented to demonstrate the merit of the proposed algorithm in handling the SIAS problem.


---

## Body

## 1. Introduction

Sapphire is an outward looking satellite used to take images of Earth-orbiting objects in outer space, so-called resident space objects (RSOs). An RSO can be a man-made object or a natural space object. An acquisition request is defined by an RSO that has to be imaged. Within the day, there may be multiple acquisition requests for imaging one RSO. Given a time horizon of one day, theSapphire image acquisition scheduling problem (SAIS) is to find a schedule of a set of acquisition requests that maximizes the sum of the “Figure of Merit” (FoM) of all the scheduled RSO images, where imaging each RSO has time window constraints. The minimal time difference between the two consecutive images of the same RSO is not considered.The “Figure of Merit” is an integrated measure of five items, including image priority, off-pointing angle, imaging time, manoeuver angle, and manoeuver time. The five items are combined as a product in the measure to generally favor images with high priority and small imaging time. The manoeuver angle is defined as the angle between the pointing vector of the imaging end time for the current RSO and the pointing vector of the imaging start time for the next RSO. The Sapphire manoeuver time between two acquisition requestsi and j calculates the time needed for Sapphire to change its pointing angle from pointing towards R
S
O
i at the end of its scheduled imaging time to pointing towards the R
S
O
j at the start of its scheduled imaging time. The off-pointing angle measures how much Sapphire is oriented off the most desired position for its solar panels towards the Sun.The Sapphire image acquisition scheduling problem is a hard discrete optimization problem, which can be modeled as a prize collecting selective asymmetric traveling salesman problem with multiple time windows for each customer, with service times, and with time-dependent distances between the customers. Each imaging request can be represented by a node of a directed graph G. A directed arc is added between any two imaging requests that can be taken one after another. The weight of an arc represents the duration of the Sapphire maneuver needed for imaging the two corresponding RSOs. Each node has a priority (prize) and the service time that corresponds to the imaging time.The daily photograph scheduling of the SPOT5 satellite for specified areas on the Earth’s surface has been widely studied in the literature. Bensana et al. (1996) [1] formulated the daily management of an Earth observation satellite as a variable valued constraint satisfaction problem, which is handled by exact and approximate methods. Vasquez and Hao (2001) [2] formulated the daily photograph scheduling of an Earth observation satellite as a knapsack model and proposed a tabu search algorithm to determine the scheduling. Wolfe and Sorensen (2000) [3] defined the scheduling problem as a time window constrained packing problem and devised a fast and simple priority dispatch method, a look ahead algorithm, and a genetic algorithm. Mansour and Dessouky (2010) [4] presented a genetic algorithm to maximize a multicriteria objective including the profit and the number of acquired photographs. Ribeiro et al. (2010) [5] employed a commercial solver combined with a strengthened formulation based on valid inequalities arising from the node packing and 3-regular independence system polyhedra.The photograph acquisition scheduling problems for an agile Earth observation satellite or for a set of agile Earth observation satellites have been solved by varying approaches. Lemaître et al. (2002) [6] developed four different methods to solve the track selection and scheduling problem for agile Earth observation satellites, including a fast greedy algorithm, a dynamic programming algorithm, a constraint programming algorithm, and a local search algorithm. Bianchessi et al. (2007) [7] considered the problem of selecting and scheduling requests for a constellation of agile satellites and devised a tabu search algorithm with solution quality evaluated by a column generation method. Habet et al. (2010) [8] addressed an agile Earth observing satellite scheduling problem with stereoscopic and time window visibility constraints by hybridizing a tabu search and a systemic search that uses partial enumerations. Upper bounds are given by a dynamic programming algorithm on a relaxed problem. Jang et al. (2013) [9] studied an image collection planning problem for a Korean satellite KOMPSAT-2 and developed a binary integer programming model and a heuristic solution procedure using the Lagrangian relaxation and subgradient methods. Tangpattanakul et al. (2015) [10] modeled the selection and scheduling of observations taken by an agile satellite as a two-objective optimization problem and solved it with an indicator-based multiobjective local search. Xu et al. (2016) [11] investigated an Earth observation scheduling problem for agile satellites under a time window constraint and resource constraints, which are solved by several constructive procedures including an ant colony optimization approach and two heuristics.Currently used Sapphire image acquisition scheduling algorithm is a greedy heuristic (GH). In this paper, we explore a GRASP heuristic (greedy randomized adaptive search procedure) that integrates a randomized greedy constructive procedure and a simple insertion improvement procedure to enhance the scheduling performance. Our experimental study has demonstrated that the developed algorithm is not only able to improve the objective “Figure of Merit,” but also improves the number of scheduled requests as a bonus.The paper is organized as follows. In Section2, we present the problem model of the Sapphire image acquisition scheduling problem. Section 3 presents the proposed GRASP algorithm. Section 4 provides the results of the computational experiments. Finally, concluding remarks are presented in Section 5.


## 2. Problem Model

The Sapphire image acquisition scheduling (SIAS) problem is to find a schedule that maximizes the sum of the “Figure of Merit” of all the scheduling requests. A solutionS to the SIAS problem, a schedule, is a set S
∈
R of the scheduled requests, where R represents all the acquisition requests. The model of the SIAS problem is formulated as(1)
Maximize
f
S
=
∑
i
∈
S
F
o
M
i
Subject  to
S
∈
Λ
,where the set Λ contains all schedules S satisfying the following constraints:(1)
Within the time horizon of one day, each RSO can be observed in multiple different time windows
(2)
Each time the current requesti to image R
S
O
i is finished, Sapphire needs manoeuver time to take the next request j to image R
S
O
j, and the minimum manoeuver time is 80 seconds and increases as a function of the manoeuver angle magnitude
(3)
The imaging time for each RSO is known
(4)
The next request cannot start earlier than the end time of the current request and must be finished by its time window
(5)
No imaging activity happens outside the planning time horizonWe assume the following:(1)
Memory on-board is not a constraint
(2)
The energy for moving or maneuvering of the satellite is not an issue (the payload is rigidly attached to the satellite)
(3)
Collecting the solar energy is not a task that needs to be scheduled; however, the satellite solar panel orientation relative to the Sun is part of the “Figure of Merit” for the RSO selection
(4)
Sapphire telescope is focused at infinity and this is a constant


## 3. GRASP: Greedy Randomized Adaptive Search Procedures

GRASP, which stands for Greedy Randomized Adaptive Search Procedure, is an effective approach to solving many optimization problems [12, 13]. It mainly consists of a randomized greedy component to produce an initial solution and a solution improvement component to refine the initial solution. The randomized greedy component integrates greedy and random features to sample solutions in the solution space so as to produce initial solutions with good solution quality and diversity. The solution improvement component can be any local search based heuristics, for example, tabu search [14, 15] and variable neighborhood search [16, 17].Our proposed GRASP for the SIAS problem is shown in Algorithm1. Since the purpose of this work is to improve performance of the previous greedy heuristic, our algorithm begins by generating an initial schedule using this greedy heuristic. If a “start” of this multistart algorithm finds a schedule with a better objective value f than the previously best found value f
∗, the algorithm updates the best schedule S
∗ and the objective value f
∗. After δ multistarts, that is, after the “start” variable reaches δ (δ is a parameter), the GRASP is terminated. The following sections present details of the GRASP adaptation to the SIAS problem.Algorithm 1:Pseudocode of GRASP for the SIAS problem.
(1)s
t
a
r
t
=
0, f
∗
=
0
(2)while  s
t
a
r
t
<
δ  do
(3)if  s
t
a
r
t
=
0  then
(4)   Apply a greedy heuristic to produce an initial schedulingS
0
(5)else
(6)   Apply a randomized greedy heuristic to produce an initial schedulingS
0
(7)end if
(8)  Apply a simple insertion improvement heuristic to get an improved schedulingS
(9)f
=
∑
i
∣
i
∈
S
F
o
M
i
(10)if  f
>
f
∗  then
(11)f
∗
=
f, S
∗
=
S
(12)end if
(13)
s
t
a
r
t
=
s
t
a
r
t
+
1
(14)
end while
(15)Return the best scheduling S
∗ and f
∗


### 3.1. The Randomized Greedy Heuristic

The randomized greedy heuristic (RGH) generates a schedule by appending the imaging requests one by one at the end of the previous schedule. Each iteration in RGH considers such a setS
T of imaging requests for the RSOs that are visible for the next 600 seconds from the imaging end time of the last scheduled request. Then, it calculates the F
o
M value for each request in the set S
T. Finally, it creates a restricted candidate set of c
l
s imaging requests with maximum F
o
M values that can be feasibly added at the end of the schedule, from which an imaging request is randomly chosen to insert in the schedule. The RGH repeats the above-mentioned iterations until there is not enough time for scheduling one more imaging request within the given planning horizon or all the imaging requests are scheduled. Note that the complexity of each RGH iteration is bounded by O
(
q
), where q denotes the total number of RSO imaging requests. Algorithm 2 gives the pseudocode of the proposed randomized greedy heuristic.Algorithm 2:Pseudocode of the randomized greedy heuristic.
(1) LetQ denote the set of the RSO imaging requests, T the duration of the planning horizon with the
default setting of 24 hours,m
- the minimal manoeuver time with the default setting of 80 seconds
andd the time step for each constructive iteration
(2)t
=
0
(3)while  t
+
m
-
<
T  or  Q
≠
ϕ  do
(4)  Find all RSOs inQ that are visible in time interval [
t
+
m
-
,
t
+
m
-
+
d
] and put them in set S
(5)if  S
=
ϕ  then
(6)t
=
t
+
d
(7)else
(8)Calculate the F
o
M value for each RSO in S
(9)   Identifyc
l
s RSOs from S with largest F
o
M values and randomly select one from them as R
S
O
b
(10)   Label the start of the imaging time byt
s and the end of the imaging time by t
e for R
S
O
b
(11)Put R
S
O
b at the end of the schedule and remove it from Q
(12)   Lett
=
t
e
(13)end if
(14)end while


### 3.2. The Simple Insertion Improvement Heuristic

#### 3.2.1. Move Operators

We propose a Simple Insertion Improvement Heuristic (SIIH) for the local search procedure in GRASP, which combines the swap move, the backward move, and the insertion move, to collectively conduct neighborhood exploration. The three move operators are defined as follows.(i)
Swap Move. Given a feasible schedule, the swap move replaces a scheduled request i with such an unscheduled request j that satisfies the following: (
1
)
R
S
O
j is visible between the time intervals [
t
e
(
i
-
1
)
+
80
,
t
s
(
i
+
1
)
]; (
2
)
R
S
O
j is permitted to be imaged not later than the time t
s
(
i
+
1
)
-
I
m
g
T
i
m
e
(
j
). R
S
O
j is permitted to be imaged if the total time for the manoeuver time m
t
(
i
-
1
,
j
) from the precedent R
S
O
i
-
1 to R
S
O
j, the manoeuver time m
t
(
j
,
i
+
1
) from R
S
O
j to the next R
S
O
i
+
1, and the imaging time I
m
g
T
i
m
e
(
j
) for the R
S
O
j are no more than t
s
(
i
+
1
)
-
t
e
(
i
-
1
); that is, t
s
i
+
1
-
t
e
i
-
1
≥
m
t
(
i
-
1
,
j
)
+
I
m
g
T
i
m
e
(
j
)
+
m
t
(
j
,
i
+
1
).
(ii)
Backward Move. The backward move enables a sequence of requests that follows the newly inserted request to be imaged at an earlier time, which thus results in an available time span. For a request k, its imaging time can be shifted to be an earlier time if it satisfies the following: (
1
)  R
S
O
k is visible between the time intervals [
t
e
(
k
-
1
)
+
80
,
t
s
(
k
)
]; (
2
) the manoeuver time from the precedent R
S
O
k
-
1 to the request R
S
O
k is no more than t
s
(
k
)
-
t
e
(
k
-
1
); that is, m
t
(
k
-
1
,
k
)
<
t
s
(
k
)
-
t
e
(
k
-
1
); (
3
) the next R
S
O
k
+
1 can be imaged not later than the time t
s
(
k
+
1
).
(iii)
Insertion Move. The insertion move inserts an unscheduled request into the current schedule when a sufficient time span occurs after a sequence of backward moves. An unscheduled request i is qualified to be inserted behind the request j that performs the last backward move if the following conditions are satisfied: (
1
)
R
S
O
i is visible between the time intervals [
t
e
(
j
)
+
80
,
t
s
(
j
+
1
)
]; (
2
)
R
S
O
i can be imaged not later than the time t
s
(
j
+
1
)
-
I
m
g
T
i
m
e
(
i
); that is, t
s
j
+
1
-
t
e
j
≥
m
t
(
j
,
i
)
+
I
m
g
T
i
m
e
(
i
)
+
m
t
(
i
,
j
+
1
).The complexity to determine the visibility of aR
S
O during a given time interval, the manoeuver time between two consecutive R
S
O imaging requests, and the qualification of imaging an R
S
O request during a given time interval are all O
(
1
). Hence, both the complexity of performing a swap move and an insertion move are O
(
1
) while the complexity of performing a backward move is bounded by O
(
q
).


#### 3.2.2. Simple Insertion Improvement Heuristic

For a feasible schedule obtained from the randomized greedy procedure, the SIIH iteratively searches for a better schedule based on the swap move, the backward move, and the insertion move. The swap moves are composed of making swaps between scheduled requests and unscheduled requests. Due to a large number of the swap moves and an expensive time consumption for calculating the objective value for each swap move, the SIIH employs a first-improvement strategy rather than a best-improvement strategy. Precisely, each iteration in the SIIH performs a swap move as long as the resulting schedule after the performance of this move gets a better objective value. Considering that the order to examine the swap moves could affect the search efficiency under the first-improvement strategy, the SIIH examines the scheduled requests sequentially and the unscheduled requests in the order of their priority. This is derived from the observation that a high-priority request has a higher chance to get a largeF
o
M value, which results in a better schedule.Each iteration in the SIIH conducts the following operations. For each scheduled requesti, all unscheduled requests are first evaluated for the qualification to be involved in a swap move. If such a swap move (
i
,
j
) is found and a better objective value of the resulting schedule after performing this swap move is obtained, the following operations are conducted: (
1
) this unscheduled request j is inserted into the schedule by replacing the scheduled request i; (
2
) the backward move operates to get a continuous and long time span by making the requests behind the just inserted request j start at an earlier time if possible; (
3
) as long as the starting time of some requests gets earlier, an insertion move is attempted if an unscheduled request is qualified to be inserted into the newly available time span. If no better objective value is found by performing this swap move, then the swap move is not performed and the next unscheduled request is examined. Each time a swap move is performed, the search sequentially goes to the next scheduled request and repeats the above-mentioned operations. Algorithm 3 shows the pseudocode of the simple insertion improvement heuristic, which terminates when no swap move is able to produce a schedule with a better objective value. The complexity of each SIIH iteration is bounded by O
(
q
2
).Algorithm 3:Pseudocode of the Simple Insertion Improvement Heuristic.
(1)Input: a given schedule S and its objective value f
(2)Output: the refined schedule S
∗ and its objective value f
∗
(3)b
e
s
t
_
f
g
=
0
(4)repeat
(5)i
t
e
r
_
f
g
=
0
(6)for each scheduled request i  do
(7)   Sort the unscheduled requests according to the priority in a non-increasing order
(8)   Identify the first such unscheduled requestj that being swapped with the scheduled request i leads to a feasible schedule
and gets a better objective valuef
(9)if such a request j exists then
(10)    Swap the requestj with the request i and compute the corresponding objective gain f
g
(11)     Conduct feasible backward moves for each request followingi, and update the corresponding objective gain f
g
(12)      Conduct a request insertion operation between the end time of the request performing the last backward move and
the start time of its next request, and update the corresponding objective gainf
g
(13)i
t
e
r
_
f
g
=
i
t
e
r
_
f
g
+
f
g
(14)end if
(15)if  i
t
e
r
_
f
g
>
b
s
t
_
f
g  then
(16)b
s
t
_
f
g
=
i
t
e
r
_
f
g, f
∗
=
f
+
b
s
t
_
f
g
(17)    Record the current schedule as the best scheduleS
∗
(18)end if
(19)end for
(20)f
=
f
+
i
t
e
r
_
f
g
(21)until  i
t
e
r
_
f
g
>
0


## 3.1. The Randomized Greedy Heuristic

The randomized greedy heuristic (RGH) generates a schedule by appending the imaging requests one by one at the end of the previous schedule. Each iteration in RGH considers such a setS
T of imaging requests for the RSOs that are visible for the next 600 seconds from the imaging end time of the last scheduled request. Then, it calculates the F
o
M value for each request in the set S
T. Finally, it creates a restricted candidate set of c
l
s imaging requests with maximum F
o
M values that can be feasibly added at the end of the schedule, from which an imaging request is randomly chosen to insert in the schedule. The RGH repeats the above-mentioned iterations until there is not enough time for scheduling one more imaging request within the given planning horizon or all the imaging requests are scheduled. Note that the complexity of each RGH iteration is bounded by O
(
q
), where q denotes the total number of RSO imaging requests. Algorithm 2 gives the pseudocode of the proposed randomized greedy heuristic.Algorithm 2:Pseudocode of the randomized greedy heuristic.
(1) LetQ denote the set of the RSO imaging requests, T the duration of the planning horizon with the
default setting of 24 hours,m
- the minimal manoeuver time with the default setting of 80 seconds
andd the time step for each constructive iteration
(2)t
=
0
(3)while  t
+
m
-
<
T  or  Q
≠
ϕ  do
(4)  Find all RSOs inQ that are visible in time interval [
t
+
m
-
,
t
+
m
-
+
d
] and put them in set S
(5)if  S
=
ϕ  then
(6)t
=
t
+
d
(7)else
(8)Calculate the F
o
M value for each RSO in S
(9)   Identifyc
l
s RSOs from S with largest F
o
M values and randomly select one from them as R
S
O
b
(10)   Label the start of the imaging time byt
s and the end of the imaging time by t
e for R
S
O
b
(11)Put R
S
O
b at the end of the schedule and remove it from Q
(12)   Lett
=
t
e
(13)end if
(14)end while


## 3.2. The Simple Insertion Improvement Heuristic

### 3.2.1. Move Operators

We propose a Simple Insertion Improvement Heuristic (SIIH) for the local search procedure in GRASP, which combines the swap move, the backward move, and the insertion move, to collectively conduct neighborhood exploration. The three move operators are defined as follows.(i)
Swap Move. Given a feasible schedule, the swap move replaces a scheduled request i with such an unscheduled request j that satisfies the following: (
1
)
R
S
O
j is visible between the time intervals [
t
e
(
i
-
1
)
+
80
,
t
s
(
i
+
1
)
]; (
2
)
R
S
O
j is permitted to be imaged not later than the time t
s
(
i
+
1
)
-
I
m
g
T
i
m
e
(
j
). R
S
O
j is permitted to be imaged if the total time for the manoeuver time m
t
(
i
-
1
,
j
) from the precedent R
S
O
i
-
1 to R
S
O
j, the manoeuver time m
t
(
j
,
i
+
1
) from R
S
O
j to the next R
S
O
i
+
1, and the imaging time I
m
g
T
i
m
e
(
j
) for the R
S
O
j are no more than t
s
(
i
+
1
)
-
t
e
(
i
-
1
); that is, t
s
i
+
1
-
t
e
i
-
1
≥
m
t
(
i
-
1
,
j
)
+
I
m
g
T
i
m
e
(
j
)
+
m
t
(
j
,
i
+
1
).
(ii)
Backward Move. The backward move enables a sequence of requests that follows the newly inserted request to be imaged at an earlier time, which thus results in an available time span. For a request k, its imaging time can be shifted to be an earlier time if it satisfies the following: (
1
)  R
S
O
k is visible between the time intervals [
t
e
(
k
-
1
)
+
80
,
t
s
(
k
)
]; (
2
) the manoeuver time from the precedent R
S
O
k
-
1 to the request R
S
O
k is no more than t
s
(
k
)
-
t
e
(
k
-
1
); that is, m
t
(
k
-
1
,
k
)
<
t
s
(
k
)
-
t
e
(
k
-
1
); (
3
) the next R
S
O
k
+
1 can be imaged not later than the time t
s
(
k
+
1
).
(iii)
Insertion Move. The insertion move inserts an unscheduled request into the current schedule when a sufficient time span occurs after a sequence of backward moves. An unscheduled request i is qualified to be inserted behind the request j that performs the last backward move if the following conditions are satisfied: (
1
)
R
S
O
i is visible between the time intervals [
t
e
(
j
)
+
80
,
t
s
(
j
+
1
)
]; (
2
)
R
S
O
i can be imaged not later than the time t
s
(
j
+
1
)
-
I
m
g
T
i
m
e
(
i
); that is, t
s
j
+
1
-
t
e
j
≥
m
t
(
j
,
i
)
+
I
m
g
T
i
m
e
(
i
)
+
m
t
(
i
,
j
+
1
).The complexity to determine the visibility of aR
S
O during a given time interval, the manoeuver time between two consecutive R
S
O imaging requests, and the qualification of imaging an R
S
O request during a given time interval are all O
(
1
). Hence, both the complexity of performing a swap move and an insertion move are O
(
1
) while the complexity of performing a backward move is bounded by O
(
q
).


### 3.2.2. Simple Insertion Improvement Heuristic

For a feasible schedule obtained from the randomized greedy procedure, the SIIH iteratively searches for a better schedule based on the swap move, the backward move, and the insertion move. The swap moves are composed of making swaps between scheduled requests and unscheduled requests. Due to a large number of the swap moves and an expensive time consumption for calculating the objective value for each swap move, the SIIH employs a first-improvement strategy rather than a best-improvement strategy. Precisely, each iteration in the SIIH performs a swap move as long as the resulting schedule after the performance of this move gets a better objective value. Considering that the order to examine the swap moves could affect the search efficiency under the first-improvement strategy, the SIIH examines the scheduled requests sequentially and the unscheduled requests in the order of their priority. This is derived from the observation that a high-priority request has a higher chance to get a largeF
o
M value, which results in a better schedule.Each iteration in the SIIH conducts the following operations. For each scheduled requesti, all unscheduled requests are first evaluated for the qualification to be involved in a swap move. If such a swap move (
i
,
j
) is found and a better objective value of the resulting schedule after performing this swap move is obtained, the following operations are conducted: (
1
) this unscheduled request j is inserted into the schedule by replacing the scheduled request i; (
2
) the backward move operates to get a continuous and long time span by making the requests behind the just inserted request j start at an earlier time if possible; (
3
) as long as the starting time of some requests gets earlier, an insertion move is attempted if an unscheduled request is qualified to be inserted into the newly available time span. If no better objective value is found by performing this swap move, then the swap move is not performed and the next unscheduled request is examined. Each time a swap move is performed, the search sequentially goes to the next scheduled request and repeats the above-mentioned operations. Algorithm 3 shows the pseudocode of the simple insertion improvement heuristic, which terminates when no swap move is able to produce a schedule with a better objective value. The complexity of each SIIH iteration is bounded by O
(
q
2
).Algorithm 3:Pseudocode of the Simple Insertion Improvement Heuristic.
(1)Input: a given schedule S and its objective value f
(2)Output: the refined schedule S
∗ and its objective value f
∗
(3)b
e
s
t
_
f
g
=
0
(4)repeat
(5)i
t
e
r
_
f
g
=
0
(6)for each scheduled request i  do
(7)   Sort the unscheduled requests according to the priority in a non-increasing order
(8)   Identify the first such unscheduled requestj that being swapped with the scheduled request i leads to a feasible schedule
and gets a better objective valuef
(9)if such a request j exists then
(10)    Swap the requestj with the request i and compute the corresponding objective gain f
g
(11)     Conduct feasible backward moves for each request followingi, and update the corresponding objective gain f
g
(12)      Conduct a request insertion operation between the end time of the request performing the last backward move and
the start time of its next request, and update the corresponding objective gainf
g
(13)i
t
e
r
_
f
g
=
i
t
e
r
_
f
g
+
f
g
(14)end if
(15)if  i
t
e
r
_
f
g
>
b
s
t
_
f
g  then
(16)b
s
t
_
f
g
=
i
t
e
r
_
f
g, f
∗
=
f
+
b
s
t
_
f
g
(17)    Record the current schedule as the best scheduleS
∗
(18)end if
(19)end for
(20)f
=
f
+
i
t
e
r
_
f
g
(21)until  i
t
e
r
_
f
g
>
0


## 3.2.1. Move Operators

We propose a Simple Insertion Improvement Heuristic (SIIH) for the local search procedure in GRASP, which combines the swap move, the backward move, and the insertion move, to collectively conduct neighborhood exploration. The three move operators are defined as follows.(i)
Swap Move. Given a feasible schedule, the swap move replaces a scheduled request i with such an unscheduled request j that satisfies the following: (
1
)
R
S
O
j is visible between the time intervals [
t
e
(
i
-
1
)
+
80
,
t
s
(
i
+
1
)
]; (
2
)
R
S
O
j is permitted to be imaged not later than the time t
s
(
i
+
1
)
-
I
m
g
T
i
m
e
(
j
). R
S
O
j is permitted to be imaged if the total time for the manoeuver time m
t
(
i
-
1
,
j
) from the precedent R
S
O
i
-
1 to R
S
O
j, the manoeuver time m
t
(
j
,
i
+
1
) from R
S
O
j to the next R
S
O
i
+
1, and the imaging time I
m
g
T
i
m
e
(
j
) for the R
S
O
j are no more than t
s
(
i
+
1
)
-
t
e
(
i
-
1
); that is, t
s
i
+
1
-
t
e
i
-
1
≥
m
t
(
i
-
1
,
j
)
+
I
m
g
T
i
m
e
(
j
)
+
m
t
(
j
,
i
+
1
).
(ii)
Backward Move. The backward move enables a sequence of requests that follows the newly inserted request to be imaged at an earlier time, which thus results in an available time span. For a request k, its imaging time can be shifted to be an earlier time if it satisfies the following: (
1
)  R
S
O
k is visible between the time intervals [
t
e
(
k
-
1
)
+
80
,
t
s
(
k
)
]; (
2
) the manoeuver time from the precedent R
S
O
k
-
1 to the request R
S
O
k is no more than t
s
(
k
)
-
t
e
(
k
-
1
); that is, m
t
(
k
-
1
,
k
)
<
t
s
(
k
)
-
t
e
(
k
-
1
); (
3
) the next R
S
O
k
+
1 can be imaged not later than the time t
s
(
k
+
1
).
(iii)
Insertion Move. The insertion move inserts an unscheduled request into the current schedule when a sufficient time span occurs after a sequence of backward moves. An unscheduled request i is qualified to be inserted behind the request j that performs the last backward move if the following conditions are satisfied: (
1
)
R
S
O
i is visible between the time intervals [
t
e
(
j
)
+
80
,
t
s
(
j
+
1
)
]; (
2
)
R
S
O
i can be imaged not later than the time t
s
(
j
+
1
)
-
I
m
g
T
i
m
e
(
i
); that is, t
s
j
+
1
-
t
e
j
≥
m
t
(
j
,
i
)
+
I
m
g
T
i
m
e
(
i
)
+
m
t
(
i
,
j
+
1
).The complexity to determine the visibility of aR
S
O during a given time interval, the manoeuver time between two consecutive R
S
O imaging requests, and the qualification of imaging an R
S
O request during a given time interval are all O
(
1
). Hence, both the complexity of performing a swap move and an insertion move are O
(
1
) while the complexity of performing a backward move is bounded by O
(
q
).


## 3.2.2. Simple Insertion Improvement Heuristic

For a feasible schedule obtained from the randomized greedy procedure, the SIIH iteratively searches for a better schedule based on the swap move, the backward move, and the insertion move. The swap moves are composed of making swaps between scheduled requests and unscheduled requests. Due to a large number of the swap moves and an expensive time consumption for calculating the objective value for each swap move, the SIIH employs a first-improvement strategy rather than a best-improvement strategy. Precisely, each iteration in the SIIH performs a swap move as long as the resulting schedule after the performance of this move gets a better objective value. Considering that the order to examine the swap moves could affect the search efficiency under the first-improvement strategy, the SIIH examines the scheduled requests sequentially and the unscheduled requests in the order of their priority. This is derived from the observation that a high-priority request has a higher chance to get a largeF
o
M value, which results in a better schedule.Each iteration in the SIIH conducts the following operations. For each scheduled requesti, all unscheduled requests are first evaluated for the qualification to be involved in a swap move. If such a swap move (
i
,
j
) is found and a better objective value of the resulting schedule after performing this swap move is obtained, the following operations are conducted: (
1
) this unscheduled request j is inserted into the schedule by replacing the scheduled request i; (
2
) the backward move operates to get a continuous and long time span by making the requests behind the just inserted request j start at an earlier time if possible; (
3
) as long as the starting time of some requests gets earlier, an insertion move is attempted if an unscheduled request is qualified to be inserted into the newly available time span. If no better objective value is found by performing this swap move, then the swap move is not performed and the next unscheduled request is examined. Each time a swap move is performed, the search sequentially goes to the next scheduled request and repeats the above-mentioned operations. Algorithm 3 shows the pseudocode of the simple insertion improvement heuristic, which terminates when no swap move is able to produce a schedule with a better objective value. The complexity of each SIIH iteration is bounded by O
(
q
2
).Algorithm 3:Pseudocode of the Simple Insertion Improvement Heuristic.
(1)Input: a given schedule S and its objective value f
(2)Output: the refined schedule S
∗ and its objective value f
∗
(3)b
e
s
t
_
f
g
=
0
(4)repeat
(5)i
t
e
r
_
f
g
=
0
(6)for each scheduled request i  do
(7)   Sort the unscheduled requests according to the priority in a non-increasing order
(8)   Identify the first such unscheduled requestj that being swapped with the scheduled request i leads to a feasible schedule
and gets a better objective valuef
(9)if such a request j exists then
(10)    Swap the requestj with the request i and compute the corresponding objective gain f
g
(11)     Conduct feasible backward moves for each request followingi, and update the corresponding objective gain f
g
(12)      Conduct a request insertion operation between the end time of the request performing the last backward move and
the start time of its next request, and update the corresponding objective gainf
g
(13)i
t
e
r
_
f
g
=
i
t
e
r
_
f
g
+
f
g
(14)end if
(15)if  i
t
e
r
_
f
g
>
b
s
t
_
f
g  then
(16)b
s
t
_
f
g
=
i
t
e
r
_
f
g, f
∗
=
f
+
b
s
t
_
f
g
(17)    Record the current schedule as the best scheduleS
∗
(18)end if
(19)end for
(20)f
=
f
+
i
t
e
r
_
f
g
(21)until  i
t
e
r
_
f
g
>
0


## 4. Computational Results

In this section, we compare the proposed GRASP algorithm with the greedy heuristic (GH) currently used in the Sapphire image acquisition scheduling project. The GH works similarly as the randomized greedy heuristic shown in Algorithm2, but it requires that each constructive iteration selects an imaging request with the best F
o
M value. The experiments are evaluated on 10 problem instances, each of which is generated from a model in Satellite Toolkit (STK) using an actual Sapphire Task List containing RSO orbit Two Line Elements (TLEs). The content of the Sapphire Task List used is a close representative of the real-world Sapphire Task List. Each problem instance includes 630 RSO acquisition requests and records a time series of pointing vectors covering a 24-hour period.The algorithms are programmed in C++ and tested on a PC with i7-2600 3.4 GHz CPU and 16 GB memory. Given the stochastic nature of the GRASP algorithm, each instance is run 10 times with different random seeds. The parameters in the experiments are set as follows: the candidate list sizec
l
s
=
3 and the maximum starts δ
=
100.Table1 presents the best results of GH and GRASP in terms of the number of imaged requests I
m
g
R
e
q
#, the objective value F
o
M, the improvement percentage of GRASP over GH (Imp%), and the running (computational) time in seconds (Time). The last row summarizes the average improvement of GRASP over GH. From Table 1, we observe that GRASP is able to improve the objective values F
o
M obtained by GH for 34.46% on average. Furthermore, in 9 out of 10 instances GRASP was able to schedule more imaging requests than GH, regardless to the fact that the number of imaged requests I
m
g
R
e
q
# was not the part of the objective function that the algorithm was optimizing. However, this remarkable performance of GRASP consumes more computational time, which is mainly attributed to the time-consuming Simple Insertion Improvement Heuristic.Table 1
Best results of the GH versus GRASP.
Instances
GH
GRASP
I
m
g
R
e
q
#
F
o
M
T
i
m
e  (
s
)
I
m
g
R
e
q
#
(
I
m
p
%
)
F
o
M
I
m
p
%
T
i
m
e  (
s
)
Day 1
488.0
0.032758
5
514 (5.33%)
0.051292
56.58%
1400
Day 2
551.0
0.028856
9
562 (2.00%)
0.031378
8.74%
1440
Day 3
572.0
0.027112
9
572 (0.00%)
0.036878
36.02%
1360
Day 4
559.0
0.025122
9
581 (3.94%)
0.030325
20.71%
1340
Day 5
579.0
0.025286
9
584 (0.86%)
0.034333
35.78%
1360
Day 6
567.0
0.026977
9
581 (2.47%)
0.027701
2.68%
1220
Day 7
568.0
0.025356
9
588 (3.52%)
0.033747
33.09%
1340
Day 8
580.0
0.023662
9
589 (1.55%)
0.032998
39.46%
1290
Day 9
576.0
0.021414
9
583 (1.22%)
0.028848
34.72%
1270
Day 10
570.0
0.019205
9
590 (3.51%)
0.033970
76.88%
1280
Avg.
34.46%Table2 presents the average results of GH and GRASP with the similar statistics given as in Table 1. As shown in Table 2, GRASP is able to achieve improved results in terms of FoM for all the instances with an average improvement of 23.97%. In terms of I
m
g
R
e
q
#, GRASP performs better than GH for all the instances except the 3 instances (Day 3, Day 5, and Day 9). When further comparing with the best results shown in Table 1, we find that for each instance the average I
m
g
R
e
q
# and F
o
M obtained by GRASP are inferior to their best counterparts, but the average computational time is much shorter. This observation indicates that the proposed GRASP algorithm could be further improved by increasing its robustness.Table 2
Average results of the GH versus GRASP.
Instances
GH
GRASP
I
m
g
R
e
q
#
F
o
M
T
i
m
e
(
s
)
I
m
g
R
e
q
#
F
o
M
I
m
p
%
T
i
m
e
(
s
)
Day 1
488.0
0.032758
5
493.4
0.048963
49.47%
140
Day 2
551.0
0.028856
9
553.0
0.029121
0.92%
144
Day 3
572.0
0.027112
9
563.9
0.028773
6.13%
136
Day 4
559.0
0.025122
9
571.9
0.028059
11.69%
134
Day 5
579.0
0.025286
9
572.8
0.032134
27.08%
136
Day 6
567.0
0.026977
9
569.3
0.027049
0.27%
122
Day 7
568.0
0.025356
9
574.9
0.031408
23.87%
134
Day 8
580.0
0.023662
9
580.7
0.030054
27.01%
129
Day 9
576.0
0.021414
9
573.9
0.027035
26.25%
127
Day 10
570.0
0.019205
9
579.2
0.032074
67.01%
128
Avg.
23.97%It is noteworthy that the “Figure of Merit” is always increasing but the number of images captured not necessarily increases. On the one hand, the objective function of the SIAS problem is the summation of the “Figure of Merit” of all the scheduled images. Thus, a better schedule is closely related to the number of the scheduled images. On the other hand, the “Figure of Merit” also considers the image priority. Although capturing high-priority images contributes to larger “Figure of Merit,” they are likely to take more imaging time and result in a reduced number of total scheduled images during the given time horizon.In summary, the experiments demonstrate the effectiveness of the proposed GRASP algorithm for solving the Sapphire image acquisition scheduling problem.


## 5. Conclusion

We developed a GRASP algorithm for solving the Sapphire image acquisition scheduling problem with time window constraints. The proposed algorithm integrates a randomized greedy procedure and a local search procedure to improve the scheduling performance. The local search procedure employs a collection of swap, backward, and insertion moves to cooperatively conduct the neighborhood exploration. Experimental comparisons with the currently used greedy algorithm disclose that the proposed algorithm is able to obtain improvements in terms of the optimized objective and the number of imaged requests. Potential future work can be considered for robustness improvement of the proposed GRASP algorithm.



---

*Source: 3518537-2016-11-14.xml*