# Robust Satellite Scheduling Approach for Dynamic Emergency Tasks

Authors: Xuejun Zhai; Xiaonan Niu; Hong Tang; Lixin Wu; Yonglin Shen
Journal: Mathematical Problems in Engineering
 (2015)

---

## Abstract

Earth observation satellites play a significant role in rapid responses to emergent events on the Earth’s surface, for example, earthquakes. In this paper, we propose a robust satellite scheduling model to address a sequence of emergency tasks, in which both the profit and robustness of the schedule are simultaneously maximized in each stage. Both the multiobjective genetic algorithm NSGA2 and rule-based heuristic algorithm are employed to obtain solutions of the model. NSGA2 is used to obtain a flexible and highly robust initial schedule. When every set of emergency tasks arrives, a combined algorithm called HA-NSGA2 is used to adjust the initial schedule. The heuristic algorithm (HA) is designed to insert these tasks dynamically to the waiting queue of the initial schedule. Then the multiobjective genetic algorithm NSGA2 is employed to find the optimal solution that has maximum revenue and robustness. Meanwhile, to improve the revenue and resource utilization, we adopt a compact task merging strategy considering the duration of task execution in the heuristic algorithm. Several experiments are used to evaluate the performance of HA-NSGA2. All simulation experiments show that the performance of HA-NSGA2 is significantly improved.


---

## Body

## 1. Introduction

Earth observing satellites (EOSs), orbiting the Earth, are able to collect images of specified areas of the Earth’s surface at the request of customers by using observation sensors [1]. EOSs not only play key roles in application for environment surveillance, reconnaissance, resource investigation, and other fields, but also support many important services, such as remote sensing, navigation, geodesy, and monitoring [2]. As a result, many countries, especially China, tend to increase their investments to develop associated techniques and EOSs. For example, China plans to launch four small optical satellites and four small SAR satellites to form a natural disaster-monitoring constellation [3]. Although the number of EOSs is continuously increasing, they are still unable to satisfy the requirements of various customers [4]. Therefore, it is very important to develop effective methods of satellites observation scheduling to make full use of scarce satellite resources to better satisfy the demands of customers. The satellite observation scheduling problem (SOSP) is to reasonably assign satellite resources and time windows to Earth observation tasks on the precondition of satisfying complex constraints [5]. Additionally, SOSP can be seen as a kind of multidimensional knapsack problem that is NP-hard [6].From the previous survey, the satellite observation tasks scheduling problem can be divided into two classes, that is, static tasks scheduling and dynamic tasks scheduling. Over the past decades, the satellite scheduling imaging problem has been intensively investigated [7–10]. Regarding static single satellite scheduling, Lin et al. employed mathematical programming methods such as Tabu search, Lagrange relaxation, and liner search to solve the scheduling problem and acquired a near-optimal schedule [11–13]. Wolfe and Sorensen proposed three corresponding algorithms including a dispatch algorithm, a look-ahead algorithm, and a genetic algorithm to model the imaging satellite scheduling problem [14]. Gabrel and Murat presented two upper bound procedures based on the graph theory and a column generation technique [15]. Vasquez and Hao formulated the satellite observation scheduling problem into a generalized version of the well-known knapsack model and used the Tabu search method to solve the problem [16]. Furthermore, they proposed a partition-based approach UPPB to obtain tight upper bounds to evaluate the TS search algorithm [17]. Several exact methods, such as depth first branch and bound or Russian dolls search and some approximate methods, such as greedy search and Tabu search, were used by Bensana et al. to solve the scheduling problem of the SPOT5 satellite. They viewed the scheduling problem as a value constraint satisfaction problem or an integer linear programming problem [6].Although the single satellite scheduling problem can be solved perfectly by the above methods, with the development of the EOS system, these methods are unable to satisfy the needs of multisatellite system scheduling. In later studies, many researchers adopted a heuristic algorithm to solve the multisatellite scheduling problem such as Zweben et al. [18], Frank et al. [19], Bianchessi and Righini [20], Wang and Reinelt [21], and Marinelli et al. [22]. Bianchessi and Righini proposed a FIFO heuristic and a look-ahead insert heuristic algorithm to solve the scheduling problem [20]. Frank et al. used a constraint based interval planning framework to model the problem and proposed a heuristic for guiding this search procedure. Wang and Reinelt considered image downloads and proposed a priority-based conflict-avoided heuristic algorithm [21]. With the development of the intelligent optimization algorithm, many researchers proposed using intelligent algorithms to solve the complex scheduling problem. The intelligent algorithms mainly include genetic algorithm and ant colony optimization algorithm. Barbulescu et al. [23], Wang et al. [24], Baek et al. [25], Chen et al. [26], and Mansour and Dessouky [7] used the genetic algorithm (GA) to address the satellite scheduling problem. Barbulescu et al. proposed Genitor, a genetic algorithm, and proved that it performs well for a broad range of problem instances [23]. A multiobjective earth observation satellite scheduling method called SPEA2, based on the strength of the Pareto evolutionary algorithm, was proposed by Wang et al. [24]. Additionally, Mansour and Dessouky solved the satellite scheduling problem by developing a genetic algorithm considering two objectives, that is, the profits and the number of acquired photographs [7]. Ant colony optimization (ACO) was also used to address this problem. Based on ant colony optimization, Zhang et al. [27] and Liu et al. [28] considered multisatellite resources and task merging, respectively. Wu et al. presented a novel two-phase based scheduling method with the consideration of task clustering [29]. Moreover, Qiu et al. proposed the first finish first schedule with discard task moving back (FFFS-DTMB) and accommodate discard task predicting coexistence with task moving back (ADTPC-DTMB) algorithms to solve the problem [30]. Globus et al. developed an evolutionary algorithm to solve this problem and compared it with existing algorithms [31, 32]. From the survey of static tasks scheduling, we find that the heuristic algorithm is shown to perform well for simple problems and the genetic algorithm is proven to be suitable for large scale, more complex problems [23].Static scheduling assumes that all imaging tasks have been submitted before scheduling and once the scheduling scheme is produced, it is immutable until all tasks have been finished. In practice, because emergent events usually occur unexpectedly, with uncertainties of occurrence time and number, traditional static scheduling cannot attend to these emergent tasks in time. It is suggested that dynamic scheduling copes with these unexpected factors.Until now, there are a few research efforts towards the dynamic scheduling on Earth observation satellites. Pemberton and Greenwald described the problem of dynamic scheduling and discussed contingency conditions [33]. Kramer and Smith proposed a repair-based search method for the oversubscribed scheduling problem [34]. Verfaillie and Schiex developed an approach employing local adjustment to solve the dynamic constraint satisfaction problem (DCSP) [35]. Considering the tradeoff between the performance and degree of adjustment, Wang et al. proposed a rule-based heuristic algorithm to solve the dynamic scheduling problem [36]. Also, Wang et al. established a multiobjective mathematic programming model for the dynamic real-time scheduling of EOSs and proposed a dynamic real-time scheduling algorithm called DMTRH to solve the problem [37]. Through analyzing the main constraints, Dishan et al. constructed an integer programming model and proposed a Rolling Horizon (RH) strategy with a mixed triggering mode to schedule the dynamic tasks and common tasks together [2].To the best of our knowledge, EOSs play an important role in the process of disaster relief. For example, when an earthquake occurs, new emergency tasks will be submitted to the satellite observation system to acquire images that contain disaster information. According to the needs of disaster relief, more and more different emergency tasks will arrive. So far, just a few dynamic scheduling methods consider dealing with the emergency tasks. After analyzing the dynamic properties of satellite scheduling, Wang et al. proposed an optimization model and two heuristic algorithms to solve the problem [38]. However, they did not consider the task merging method in the heuristic algorithms. Wu et al. adopted the ant colony optimization plus iteration local search (ACO-ILS) approach to resolve the multisatellite emergency tasks and common tasks scheduling problem [4]. However, they did not account for the uncertainty of emergency tasks. Moreover, Wang et al. presented a dynamic scheduling algorithm called TMBSR-DES, which comprehensively considers task merging, backward shift, and rehabilitation [39]. The task merging strategy in TMBSR-DES only combines new tasks. The robustness of schedule has not been considered in all of the above algorithms.To sum up, the studies on dynamic emergency scheduling mentioned above have the following shortages.(1)
Some dynamic scheduling methods ignored the timeliness of emergency tasks.
(2)
The real-time scheduling method [2, 37, 38] took into account the timeliness of dynamic emergency tasks, but it did not consider the influence of the common tasks on satellites.
(3)
Most of studies overlooked the robustness of dynamic satellite scheduling.In this paper, we propose a robust scheduling approach oriented to both dynamic tasks and common tasks. We establish a robust satellite scheduling model to maximize the profit and robustness of the schedule. To solve the model, we design a combined algorithm HA-NSGA2 that is made up of multiobjective genetic algorithm NSGA2 and rule-based heuristic algorithm. NSGA2 is to acquire a flexible and highly robustness initial schedule in the scheduling of common tasks. Then a heuristic algorithm is designed to insert more emergency tasks dynamically. Meanwhile, to improve the revenue and resource utilization, we adopt a compact task merging strategy considering the duration of task execution in the heuristic algorithm. Based on the heuristic algorithm, NSGA2 is employed to optimize the solution so as to keep high continuous robustness for new emergency tasks.The major contributions of this paper are summarized as follows.(
1
) The robustness is considered in the whole process of common tasks and dynamic emergency tasks scheduling to improve the scheduling ability of resisting disturbances. (
2
) To leave more opportunities for emergency tasks and improve the revenue and resource utilization, a compact task merging strategy is used. (
3
) Through considering the advantages of the heuristic algorithm and NSGA2 comprehensively, we propose an efficient solution to deal with the emergency tasks dynamically.The remainder of this paper is organized as follows. The characteristics of emergency tasks and the solution framework are described in Section2. In Section 3, we present the robust scheduling model. We introduce the corresponding solution to the model including the multiobjective genetic algorithm, rule-based heuristic algorithm, and neighborhood operator in detail, in Section 4. The simulation results and performance analysis, through comparison with other methods, are given in Section 5. Section 6 concludes the paper with some future research directions.


## 2. Problem Description

Earth observing satellites (EOSs), orbiting the Earth, collect images of the Earth’s surface. As shown in Figure1(a), a strip of EOSs can be formed on the ground by the subsatellite point of satellite and the field of view of the sensor, slewing angle of the sensor, and observation duration. Satellite mission scheduling allocates the limited satellite resources to observing tasks efficiently and reasonably. Figure 1(b) shows that each schedule is a sequence of tasks ordered in time for an EOS.Figure 1
Illustration of satellite observing activity.
(a)
Multisatellite observation schematic diagram
(b)
The satellites’ scheduleThe EOSs work in a complex environment in which there exist many dynamic factors, as follows:(i)
The change in task properties: the change in user requirements or the reasonable task attributes will lead to a change in task priority. When the priority of the task changes, we cancel the task before it is performed. Then the task, which is viewed as an emergency task, is added to the emergency task set.
(ii)
The change in the state of satellites: sometimes, certain satellites may be out of use because of malfunction, memory, or energy shortage, and so on. As a result, the initial schedule cannot be executed continuously. These tasks which are affected by the satellites can be seen as emergency tasks to be inserted.
(iii)
The arrival of emergency tasks: according to the actual requirement, users may insert some new tasks when a scheduling scheme is executed. Specifically, there are some new incoming emergency tasks caused by emergent events, for example, earthquakes, fire, and landslides. Take an earthquake as an example. There is an urgent need to reasonably utilize the existing satellites to rapidly image the affected area during a short time period. Once the emergency tasks are submitted and scheduled, EOSs can acquire remote sensing images of disaster area quickly, which can provide rapid and effective information for quick investigation and assessment of earthquake damage.
(iv)
Uncertainty of weather conditions: some imaging tasks may not be completed because of a change in weather conditions. To satisfy user requirements, these tasks must be rearranged.The four cases mentioned above can be seen as emergency tasks to be inserted into a scheduling scheme. Thus, the dynamic scheduling problem can be described as a unified form of inserting new tasks. In this paper, we research dynamic scheduling focus on new incoming emergency tasks. The general method is to produce a temporary schedule and then to adjust the schedule as quickly as possible. When dynamically adjusting the initial schedule, the solution stability is an important problem. In fact, the satellite application is a complex process and the orders can only be uploaded with the special equipment within limited visible time windows, so excessive changes may cause great operational trouble [36]. Hence, we should not only consider arranging more emergency tasks dynamically but also decrease the disturbances to the initial schedule as much as possible. Moreover, the uncertainty of arrival time is an important property of new tasks. Thus, we should consider the timeliness of emergency tasks in dynamic scheduling. Therefore, the goal of our research is to arrange emergency tasks as more as possible in smaller disturbances, considering the timeliness of the emergency tasks. As a result, the optimization objectives in this paper are revenue and robustness.In this paper, we propose a dynamic scheduling approach that can deal with the emergency tasks in real time dynamically. It is actually a two-stage method to produce a temporary schedule and then to adjust the schedule as quickly as possible as is shown in Figure2. The robust scheduling approach proposed in the paper is oriented to both dynamic emergency tasks and common tasks. We describe the flowchart of the solution in Figure 3. Before scheduling, pretreatment is conducted to compute the available opportunities for each task. Then we establish a robust satellite scheduling model with two objectives considering both revenue and robustness. To optimize objectives of the model, the multiobjective genetic algorithm NSGA2 is used to obtain robust solutions. We can acquire an initial schedule with high revenue and stronger ability to accept emergency tasks. With the arrival of emergency tasks, we update the state of the tasks in the current executing schedule. To arrange the emergency tasks dynamically, the rule-based heuristic algorithm with compact task merging strategy is designed. Thus, we can get some temporary adjusted schedule. Lastly, NSGA2 is adopted to further improve the solution by searching the global space. It is worth mentioning that we design a neighborhood operator to initialize the population in NSGA2.Figure 2
The framework of solution to the dynamic scheduling problem.Figure 3
The flowchart of the dynamic scheduling approach.


## 3. Model

The satellite scheduling amounts to a reasonable arrangement of satellites, sensors, time windows, and sensor slewing angle for observation tasks to maximize one or more objectives, for example, the overall observation profit, while being subject to related constraints. As a result, the satellite scheduling problem usually consists of five parts: tasks, satellite resources, opportunities, objectives, and constraints. A detailed introduction of the model is as follows.


### 3.1. Tasks

In this paper, we concentrate on two types of tasks: the common task and emergency task. Common imaging tasks are usually submitted to the planning system in advance. The characteristics of emergency tasks are different from those of common tasks. Emergency events usually occur unexpectedly, with uncertainties of occurrence time and number. Thus, the emergency task number and arrival times are not known a priori. Moreover, dynamic tasks need to be completed in time, because users want to obtain observation results within certain time limits.(i)
Common task: letT
=
t
1
,
t
2
,
…
,
t
N be the common task set, where N is the number of common tasks. We assume that all tasks are independent, aperiodic, and nonpreemptive. Each task is associated with the weight, p
i, and the indispensable duration of task execution d
i.
(ii)
Emergency task: letT
E
=
{
t
N
+
1
,
t
N
+
2
,
…
,
t
N
+
N
E
} be the emergency task set. Each emergency task is presented by t
n
=
p
n
,
d
n
,
a
t
n
,
d
t
n, where p
n is the weight, d
n is the duration, a
t
n is the arrival time, and d
t
n is the deadline.In addition, to make the denotation of common tasks consistent with that of emergency tasks, we assume that each common task has an arrival timea
t
n
=
0 and a deadline d
t
n
=
t
S
f.Considering that many tasks are commonly submitted together, thus we assume in this paper that the new tasks arrive in batch style. LetT
S
=
{
t
S
0
,
t
S
1
,
…
,
t
S
e
,
t
S
f
} be the scheduling time set, where t
S
i (i
≥
1) is the ith dynamic scheduling time, t
S
0 is the initial scheduling time, e is the total batch of emergency tasks, and t
S
f is the end time of scheduling.Imaging tasks can be divided into two types: point target and area target. The type depends on the size of the target area and the attributes of the satellite, such as the field of view and height of satellite. The point target is small so that it can be observed by single observations trip. The area target, which covers a wide geographical area, cannot be photographed in a scene. Usually, the area target can be segmented into several point targets to be imaged. In this paper, we focus on dealing with point targets.


### 3.2. Satellite Resources

As for the resources, we consider a setS
=
s
1
,
s
2
,
…
,
s
M, where M is the satellite number. We assume that the sensors of the satellites considered in our study are able to slew laterally. Each resource s
j
∈
S is denoted by s
j
=
Δ
θ
j
,
Δ
d
j
,
s
l
j
,
s
t
j
,
m
s
g
j
,
o
r
b
j
,
s
u
j
,
s
d
j
,
d
u
t
y
j, where Δ
θ
j, Δ
d
j, s
l
j, m
s
g
j, o
r
b
j, s
u
j, s
d
j, and d
u
t
y
j are the field of view, the longest opening time, slewing rate, attitude stability time, maximum slewing angle, the flight time in each orbit, the start-up time of sensor, the retention time of shutdown, and the longest imaging time in each orbit.


### 3.3. Available Opportunities

For available opportunities, letA
O
=
{
a
o
1
1
,
a
o
1
2
,
…
,
a
o
1
j
,
a
o
2
1
,
…
,
a
o
2
j
,
…
,
a
o
N
M
} be the opportunity set of every task on each satellite resource. For a
o
i
j
∈
A
O, a
o
i
j
=
{
a
o
i
1
j
,
a
o
i
2
j
,
a
o
i
3
j
,
…
,
a
o
i
k
i
j
j
} represents the available opportunities of task t
i on resource s
j, where k
i
j represents the number of available opportunities. Giving an available opportunity a
o
i
k
j
∈
a
o
i
j, it is represented by a
o
i
k
j
=
w
s
i
k
j
,
w
e
i
k
j
,
θ
i
k
j, where w
s
i
k
j and w
e
i
k
j are denoted by the start time and end time of the window W
i
k
j, and θ
i
k
j is the swing angle. The set of time windows of task i on satellite j is W
i
j
=
⋃
k
∈
1
,
…
,
K
i
j
W
i
k
j.


### 3.4. Optimization Objectives

We assume thatt
S
k is the current scheduling time, and then the model can be described as follows.The primary objective is to maximize the revenue of all scheduled tasks:(1)
m
a
x
:
∑
i
=
1
N
+
N
E
∑
j
=
1
M
∑
k
=
1
K
i
j
x
i
,
k
j
p
i
,where x
i
,
k
j is the decision variable whether the task i is scheduled:(2)
x
i
,
k
j
=
1
,
i
f
t
a
s
k
i
i
s
e
x
e
c
u
t
e
d
b
y
s
a
t
e
l
l
i
t
e
j
i
n
t
h
e
k
t
h
t
i
m
e
w
i
n
d
o
w
0
,
o
t
h
e
r
w
i
s
e
.The second objective is called the neighborhood-based robust indicator [40]. The robustness based on neighborhood is proposed from the advances in robust optimization of continuous functions [41, 42]. The idea is that robust optima are located on broad peaks (plateaus) in the fitness landscape, whereas brittle optima are located on narrow peaks, as shown in Figure 4. A tradeoff is made between the broadness and height of the peaks, such that a low and broad peak may be preferable to a narrow and high peak. The problem of satellite scheduling is a discrete problem. There are some schedules which are different sequence of the scheduled tasks ordered in time but have the same revenue. If only considering the revenue, any one of these schedules is a feasible solution. However, dynamic task scheduling not only requires arranging more emergency tasks, but also requires reducing the frequency and difficulty of adjustment as much as possible. Thus, the property of resisting disturbances and self-adjusting is very important for dynamic task scheduling.Figure 4
The idea in the robust optimization technique for continuous problem [47].Hence, we define the neighborhood-based robustness as the total revenue of scheduled tasks that can be reassigned to other timeslots in the scheme directly. It is used to measure the ability of a scheduling scheme to rearrange scheduled tasks. The higher value of the neighborhood-based robust indicator is, the more possible it is to rearrange scheduled tasks. Therefore, we maximize the value of the neighborhood-based robust indicator:(3)
m
a
x
:
∑
i
=
1
N
+
N
E
∑
j
=
1
M
∑
k
=
1
K
i
j
p
i
×
x
i
,
k
j
×
y
i
,where y
i is the parameter that indicates whether the task t
i
∈
S
S can be rearranged in another timeslot:(4)
y
i
=
1
,
i
f
t
a
s
k
t
i
c
a
n
b
e
r
e
a
r
r
a
n
g
e
d
i
n
a
n
o
t
h
e
r
t
i
m
e
s
l
o
t
0
,
o
t
h
e
r
w
i
s
e
.


### 3.5. Constraints

There are some constraints that are used to analyze the complex restricted condition in the model.(1) Each taskt
i must be executed in an available opportunity a
o
i
k
j, a
o
i
k
j
∈
a
o
i
j.Hence, we have the available opportunity constraint:(5)
C
1
:
x
i
,
k
j
t
s
i
j
-
w
s
i
k
j
≥
0
x
i
,
k
j
t
s
i
j
+
d
i
-
w
e
i
k
j
≤
0
a
i
≤
t
S
k
≤
t
s
i
j
≤
d
t
i
,where t
s
i
j denotes the start time of task t
i. Actually, for a given scheduled task t
i on s
j, its starting observation time t
s
i
j and observation angle θ
i
j are determined. All scheduled tasks form the current schedule S
S
=
⋃
j
∈
[
1
,
M
]
T
j, where T
j is a sequence of scheduled tasks on satellite j.(2) Each task only needs to be executed once, and the execution process does not involve preemptive service. So we have the following uniqueness constraint:(6)
C
2
:
∑
j
=
1
M
∑
k
=
1
K
i
j
x
i
,
k
j
≤
1
.(3) There should be an adequate transmission time for sensor in any two adjacent taskst
u
,
t
v assigned to the same satellite s
j to finish the actions such as shutting down, swinging the observation angle, stabilizing gesture, and start-up. So we have the switch time constraint:(7)
C
3
:
t
e
u
j
+
s
d
j
+
s
l
j
×
θ
v
j
-
θ
u
j
+
s
t
j
+
s
u
j
≤
t
s
v
j
.(4) Another constraint is the total imaging time of any satellite, which should be less than the allowable longest imaging time of its sensor during every time period. Let the scheduling period bet
S
k
,
f. Hereby, we have the imaging time constraint:(8)
C
4
:
∑
i
∈
T
t
b
j
d
i
≤
d
u
t
y
j
,where T
t
b
j denotes a sequence of scheduled tasks on satellite j which flies during the time span t
b
,
t
b
+
o
r
b
j, where t
b
∈
t
S
k
,
f
-
o
r
b
j.


## 3.1. Tasks

In this paper, we concentrate on two types of tasks: the common task and emergency task. Common imaging tasks are usually submitted to the planning system in advance. The characteristics of emergency tasks are different from those of common tasks. Emergency events usually occur unexpectedly, with uncertainties of occurrence time and number. Thus, the emergency task number and arrival times are not known a priori. Moreover, dynamic tasks need to be completed in time, because users want to obtain observation results within certain time limits.(i)
Common task: letT
=
t
1
,
t
2
,
…
,
t
N be the common task set, where N is the number of common tasks. We assume that all tasks are independent, aperiodic, and nonpreemptive. Each task is associated with the weight, p
i, and the indispensable duration of task execution d
i.
(ii)
Emergency task: letT
E
=
{
t
N
+
1
,
t
N
+
2
,
…
,
t
N
+
N
E
} be the emergency task set. Each emergency task is presented by t
n
=
p
n
,
d
n
,
a
t
n
,
d
t
n, where p
n is the weight, d
n is the duration, a
t
n is the arrival time, and d
t
n is the deadline.In addition, to make the denotation of common tasks consistent with that of emergency tasks, we assume that each common task has an arrival timea
t
n
=
0 and a deadline d
t
n
=
t
S
f.Considering that many tasks are commonly submitted together, thus we assume in this paper that the new tasks arrive in batch style. LetT
S
=
{
t
S
0
,
t
S
1
,
…
,
t
S
e
,
t
S
f
} be the scheduling time set, where t
S
i (i
≥
1) is the ith dynamic scheduling time, t
S
0 is the initial scheduling time, e is the total batch of emergency tasks, and t
S
f is the end time of scheduling.Imaging tasks can be divided into two types: point target and area target. The type depends on the size of the target area and the attributes of the satellite, such as the field of view and height of satellite. The point target is small so that it can be observed by single observations trip. The area target, which covers a wide geographical area, cannot be photographed in a scene. Usually, the area target can be segmented into several point targets to be imaged. In this paper, we focus on dealing with point targets.


## 3.2. Satellite Resources

As for the resources, we consider a setS
=
s
1
,
s
2
,
…
,
s
M, where M is the satellite number. We assume that the sensors of the satellites considered in our study are able to slew laterally. Each resource s
j
∈
S is denoted by s
j
=
Δ
θ
j
,
Δ
d
j
,
s
l
j
,
s
t
j
,
m
s
g
j
,
o
r
b
j
,
s
u
j
,
s
d
j
,
d
u
t
y
j, where Δ
θ
j, Δ
d
j, s
l
j, m
s
g
j, o
r
b
j, s
u
j, s
d
j, and d
u
t
y
j are the field of view, the longest opening time, slewing rate, attitude stability time, maximum slewing angle, the flight time in each orbit, the start-up time of sensor, the retention time of shutdown, and the longest imaging time in each orbit.


## 3.3. Available Opportunities

For available opportunities, letA
O
=
{
a
o
1
1
,
a
o
1
2
,
…
,
a
o
1
j
,
a
o
2
1
,
…
,
a
o
2
j
,
…
,
a
o
N
M
} be the opportunity set of every task on each satellite resource. For a
o
i
j
∈
A
O, a
o
i
j
=
{
a
o
i
1
j
,
a
o
i
2
j
,
a
o
i
3
j
,
…
,
a
o
i
k
i
j
j
} represents the available opportunities of task t
i on resource s
j, where k
i
j represents the number of available opportunities. Giving an available opportunity a
o
i
k
j
∈
a
o
i
j, it is represented by a
o
i
k
j
=
w
s
i
k
j
,
w
e
i
k
j
,
θ
i
k
j, where w
s
i
k
j and w
e
i
k
j are denoted by the start time and end time of the window W
i
k
j, and θ
i
k
j is the swing angle. The set of time windows of task i on satellite j is W
i
j
=
⋃
k
∈
1
,
…
,
K
i
j
W
i
k
j.


## 3.4. Optimization Objectives

We assume thatt
S
k is the current scheduling time, and then the model can be described as follows.The primary objective is to maximize the revenue of all scheduled tasks:(1)
m
a
x
:
∑
i
=
1
N
+
N
E
∑
j
=
1
M
∑
k
=
1
K
i
j
x
i
,
k
j
p
i
,where x
i
,
k
j is the decision variable whether the task i is scheduled:(2)
x
i
,
k
j
=
1
,
i
f
t
a
s
k
i
i
s
e
x
e
c
u
t
e
d
b
y
s
a
t
e
l
l
i
t
e
j
i
n
t
h
e
k
t
h
t
i
m
e
w
i
n
d
o
w
0
,
o
t
h
e
r
w
i
s
e
.The second objective is called the neighborhood-based robust indicator [40]. The robustness based on neighborhood is proposed from the advances in robust optimization of continuous functions [41, 42]. The idea is that robust optima are located on broad peaks (plateaus) in the fitness landscape, whereas brittle optima are located on narrow peaks, as shown in Figure 4. A tradeoff is made between the broadness and height of the peaks, such that a low and broad peak may be preferable to a narrow and high peak. The problem of satellite scheduling is a discrete problem. There are some schedules which are different sequence of the scheduled tasks ordered in time but have the same revenue. If only considering the revenue, any one of these schedules is a feasible solution. However, dynamic task scheduling not only requires arranging more emergency tasks, but also requires reducing the frequency and difficulty of adjustment as much as possible. Thus, the property of resisting disturbances and self-adjusting is very important for dynamic task scheduling.Figure 4
The idea in the robust optimization technique for continuous problem [47].Hence, we define the neighborhood-based robustness as the total revenue of scheduled tasks that can be reassigned to other timeslots in the scheme directly. It is used to measure the ability of a scheduling scheme to rearrange scheduled tasks. The higher value of the neighborhood-based robust indicator is, the more possible it is to rearrange scheduled tasks. Therefore, we maximize the value of the neighborhood-based robust indicator:(3)
m
a
x
:
∑
i
=
1
N
+
N
E
∑
j
=
1
M
∑
k
=
1
K
i
j
p
i
×
x
i
,
k
j
×
y
i
,where y
i is the parameter that indicates whether the task t
i
∈
S
S can be rearranged in another timeslot:(4)
y
i
=
1
,
i
f
t
a
s
k
t
i
c
a
n
b
e
r
e
a
r
r
a
n
g
e
d
i
n
a
n
o
t
h
e
r
t
i
m
e
s
l
o
t
0
,
o
t
h
e
r
w
i
s
e
.


## 3.5. Constraints

There are some constraints that are used to analyze the complex restricted condition in the model.(1) Each taskt
i must be executed in an available opportunity a
o
i
k
j, a
o
i
k
j
∈
a
o
i
j.Hence, we have the available opportunity constraint:(5)
C
1
:
x
i
,
k
j
t
s
i
j
-
w
s
i
k
j
≥
0
x
i
,
k
j
t
s
i
j
+
d
i
-
w
e
i
k
j
≤
0
a
i
≤
t
S
k
≤
t
s
i
j
≤
d
t
i
,where t
s
i
j denotes the start time of task t
i. Actually, for a given scheduled task t
i on s
j, its starting observation time t
s
i
j and observation angle θ
i
j are determined. All scheduled tasks form the current schedule S
S
=
⋃
j
∈
[
1
,
M
]
T
j, where T
j is a sequence of scheduled tasks on satellite j.(2) Each task only needs to be executed once, and the execution process does not involve preemptive service. So we have the following uniqueness constraint:(6)
C
2
:
∑
j
=
1
M
∑
k
=
1
K
i
j
x
i
,
k
j
≤
1
.(3) There should be an adequate transmission time for sensor in any two adjacent taskst
u
,
t
v assigned to the same satellite s
j to finish the actions such as shutting down, swinging the observation angle, stabilizing gesture, and start-up. So we have the switch time constraint:(7)
C
3
:
t
e
u
j
+
s
d
j
+
s
l
j
×
θ
v
j
-
θ
u
j
+
s
t
j
+
s
u
j
≤
t
s
v
j
.(4) Another constraint is the total imaging time of any satellite, which should be less than the allowable longest imaging time of its sensor during every time period. Let the scheduling period bet
S
k
,
f. Hereby, we have the imaging time constraint:(8)
C
4
:
∑
i
∈
T
t
b
j
d
i
≤
d
u
t
y
j
,where T
t
b
j denotes a sequence of scheduled tasks on satellite j which flies during the time span t
b
,
t
b
+
o
r
b
j, where t
b
∈
t
S
k
,
f
-
o
r
b
j.


## 4. Algorithms

In this section, we introduce the dynamic emergency tasks scheduling algorithm HA-NSGA2 proposed in this paper. The algorithm, which is actually a combined algorithm, aims at improving the efficiency of dynamic emergency tasks scheduling. The flowchart of the algorithm is depicted in Figure5. Firstly, the multiobjective genetic algorithm NSGA2 with two objectives, that is, revenue and robustness, is used for common tasks scheduling to obtain the optimal solution. With the arrival of emergency tasks, the rule-based heuristic algorithm is applied to insert these emergency tasks into the initial schedule as much as possible. To improve the imaging efficiency as much as possible, we propose a compact task merging method that considers task execution duration in the rule-based heuristic algorithm. If two or more targets are geographically adjacent, they may be combined into a compact composite task by the compact task merging method. The details of compact task merging strategy are described in Appendix B. Based on the rule-based heuristic algorithm, the multiobjective genetic algorithm NSGA2 is employed to find the optimal solution. The neighborhood operator, which is embedded in NSGA2, aims at generating the initial population.Figure 5
The flowchart of the algorithm.


### 4.1. Multiobjective Genetic Algorithm

Satellites observation scheduling problem has been proven to be NP-complete. Thus, it is impossible to find polynomial time algorithms for finding optimal solutions. Genetic algorithms are the most successful algorithms for efficiently dealing with the complexity of computationally hard problems from the networking domain [23, 43]. Before introducing the multiobjective genetic algorithm NSGA2, we firstly make clear some terms, such as Pareto Dominance, Pareto optimality, Pareto Optimal Set, Pareto Front, Nondominated Sorting, and crowding distance, which will be referred to in the algorithm. We give the associative definitions in Appendix A.As shown in Figure6, we present the main process of NSGA2. First, we initialize the parameters and generate the initial population P
f
a
t
h
e
r. After computing the fitness function of P
f
a
t
h
e
r, we make use of the binary tournament selection mechanism, single point crossover operator, and single point mutation operator for the current individuals until the number of the next generation population P
c
h
i
l
d reaches the size M. Then, we set the total population as Q
=
P
f
a
t
h
e
r
∪
P
c
h
i
l
d by combining P
f
a
t
h
e
r and P
c
h
i
l
d. Next, the nondominated sorting algorithm is used to divide the population Q into different Pareto Front F
r
a
n
k with the rank of each individual. We choose the individuals from F
r
a
n
k until the number of the next population |
P
n
e
x
t
| satisfies the request, ranking from small to large. If |
P
n
e
x
t
| is greater than M, then we sort the current F
r
a
n
k in order according to the crowding distance and choose the better individuals as P
n
e
x
t. Finally, if the result satisfies the termination conditions, then we output the nondominated solution set. Otherwise, we let P
f
a
t
h
e
r
=
P
n
e
x
t and repeat the process.Figure 6
The main process of NSGA-2.The main parts of the genetic algorithm will be described in detail including initialization, selection operator, crossover operator, mutation operator, nondominated sorting, and the computation of crowding distance.


#### 4.1.1. Initialization

Unlike local search techniques, the genetic algorithm uses a population of individuals giving thus the search a larger scope and chances to find a better solution. In this paper, the satellite scheduling problem is encoded into a set of chromosomes. Each chromosome composed of an imaging task sequence of different satellites represents a solution and is assigned a fitness value to determine how good each chromosome is. The structure of a chromosome is shown in Figure7. In the algorithm, some parameters such as the size of population M, the maximum iterative number T, the probability of crossover p
c
r
o
s
s
o
v
e
r, and mutation probability p
m
u
t
a
t
i
o
n must be set. The initial population is generated by random strategy.Figure 7
The structure of chromosome.


#### 4.1.2. Selection Operator

Several selection strategies have been proposed in the previous literatures such as roulette wheel selection and binary tournament selection. We adopt binary tournament selection in this paper. The main steps are to choose two individuals randomly from a population and to select the individual that dominates the others.


#### 4.1.3. Crossover Operator

Crossover operator plays an important role in the genetic algorithm. The best genetic information of parents can be transmitted to offspring during generations of the evolution process by the crossover operator. After parent chromosomes have been selected from the population, we set the crossover probabilityp
c
r
o
s
s
o
v
e
r to allow the majority of chromosomes to mate and pass to their offspring. Figure 8 shows an example of the crossover. According to the characteristics of the satellite scheduling problem, we cross the parent chromosomes to generate child chromosomes and then delete the same genes in common chromosome. Finally we attempt to arrange the tasks differently for both parent chromosomes in child chromosomes.Figure 8
Crossover operator.


#### 4.1.4. Mutation Operator

Mutation operator intends to keep the variety of the population and improve the individuals by small local perturbations. Additionally, the mutation operator provides a component of randomness in the neighborhood of the individuals of the population. Therefore, genetic algorithm has the ability to avoid falling prematurely into local optima and eventually escapes from them during the search process. For example, if we set the probabilityp
m
u
t
a
t
i
o
n
=
0.2, then the overall procedure of the random mutation operator on the chromosome is shown in Figure 9. We choose a scheduled task that has another window randomly such as t
8. Then the task is rearranged in another available window.Figure 9
Mutation operator.


#### 4.1.5. Nondominated Sorting

The main procedure of nondominated sorting is described in Algorithm1 in detail.Algorithm 1
for eachp
∈
Q // every individual in population p
∈
Q
S
p
=
⌀;    // let the set of individuals dominated by p be null
n
p
=
0;     // the number of individuals dominating p be 0
for eachq
∈
Q
if (p
≺
q) then     // if p dominates q
S
p
=
S
p
∪
q; add q into S
p
else if (p
≻
q) then   // if q dominates p
n
p
=
n
p
+
1;
end for;
end for;
for eachp
∈
Q
if (n
p
=
=
0) then
p
r
a
n
k
=
1;     // the rank of p is 1st
F
1
=
F
1
∪
p;     // add p into the set of the first non-dominated front F
1
end for;
i
=
1;         // initialize the rank of the non-dominated fronts
while(
F
i
≠
⌀
)
for eachp
∈
F
i
for eachq
∈
S
p
n
q
=
n
q
-
1; // the number of individuals dominating p is reduced by one
if (n
q
=
=
0) then  // if there is no individual dominating q
q
r
a
n
k
=
i
+
1;     // the rank of q plus one
F
i
+
1
=
F
i
+
1
∪
q;    // add q into the non-dominated front F
i
+
1
end for;
end for;
i
=
i
+
1;
end while.


#### 4.1.6. Crowding Distance Computation

The main procedure of computing the crowding distance is described in Algorithm2 in detail.Algorithm 2
I
=
F
r
a
n
k;         // number of solutions in F
r
a
n
k
for eachp
∈
F
r
a
n
k
F
r
a
n
k
[
p
]
d
i
s
t
a
n
c
e
=
0;      // initialize the distance
end for;
for each objectivem
F
r
a
n
k
,
m
=
s
o
r
t
(
F
r
a
n
k
,
m
);    // sort using each objective value
for eachi
=
2
→
I
-
1
F
rank
⁡
,
m
[
i
]
d
i
s
t
a
n
c
e
=
(
F
r
a
n
k
,
m
i
+
1
-
F
r
a
n
k
,
m
i
-
1
)
/
(
F
r
a
n
k
,
m
m
a
x
-
F
r
a
n
k
,
m
m
i
n
); //crowding-distance of individual i in m_th objective
end for;
end for;
for eachp
∈
F
r
a
n
k
for each objectivem
F
r
a
n
k
[
p
]
d
i
s
t
a
n
c
e
=
F
r
a
n
k
[
p
]
d
i
s
t
a
n
c
e
+
F
r
a
n
k
,
m
[
p
]
d
i
s
t
a
n
c
e; // crowding-distance of p
end for;
end for.


### 4.2. Rule-Based Heuristic Algorithm

The solution with maximum revenue and robustness, which is produced by NSGA2, is selected as the initial schedule. When the schedule is executed, a number of emergency tasks arrive. In this case, the current executing schedule must be modified to arrange these emergency tasks.When a batch of emergency tasks arrives, based on the current scheduling time, tasks may have different states: finished task, running task, waiting task, and new task. In the example shown in Figure10, t
S
k is the current scheduling time. If task i has been executed before the current time, then task i is a finished task while t
e
i
<
t
S
k. If t
s
i
<
t
S
k
<
t
e
i, then task i is a running task. Task i is a waiting task if t
s
i
>
t
S
k. If task i is an emergent task that has not been planned, then task i is a new task.Figure 10
The states of tasks.According to the analysis on the state of the tasks, the waiting tasks in the current schedule can be adjusted. Focusing on the new emergency tasks, we assign these tasks to the current schedule. In this paper, we employ a rule-based heuristic algorithm considering compact task merging (CTM-DAHA) to insert the new tasks dynamically [44]. The main idea of the heuristic algorithm is to assign the most conflict-free time window to the task most in need. With CTM-DAHA, we obtain the temporary adjusted schedules.To describe the dynamic adjusting rule-based heuristic algorithm considering compact task merging clearly, we first give some definitions.Definition 1.
The need of the task indicates how badly the task needs to be performed [30, 44]:(9)
N
t
i
=
p
i
A
O
i
.Definition 2.
The contention of the task window is measured by counting the number of tasks that need the time window, weighted by the weights of the tasks:(10)
C
w
=
∑
t
i
∈
T
w
p
t
i
,where T
w is the set of tasks that could be executed at any moment within time window w and p
(
t
i
) is the weight of the tasks t
i.The dynamic adjusting rule-based heuristic algorithm CTM-DAHA is presented as shown in Figure11 [44]. To accommodate emergency tasks in the initial scheme, firstly we update the state of tasks in the schedule. Then, all new tasks are inserted into a waiting queue according to the needs of the tasks N
t
i, from high to low. The time windows of each task are ranked from low to high according to the contention C
w. For a task, we first judge whether it can merge with any other existing task in the current schedule. If all time windows of the task fail to be merged, we attempt to insert the task directly if it does not conflict with any other task. If direct insertion fails, we judge whether the task can be inserted by rearranging the conflict tasks. If direct insertion and insertion by rearranging do not succeed, some tasks may be deleted for inserting an emergency task. Then the entire process will repeat until the waiting queue is empty. Take, for example, a current executing schedule as shown in Figure 12(a). With the arrival of emergency tasks, that is, T
E
=
t
8
,
t
9
,
t
10
,
t
11, they should be arranged in time. Task t
8 can be combined with t
2 by compact task merging. Task t
9 can be inserted directly. Task t
10 is inserted into the schedule by rearranging the conflict task t
5. Task t
7 is deleted from the schedule so that task t
11 with higher weight can be inserted. Figure 12(b) shows the planning task list of the adjusted schedule.Figure 11
The process of inserting a new task.Figure 12
(a) The current executing schedule. (b) The adjusted schedule.
(a)
(b)


### 4.3. Neighborhood Operator

The solution obtained by CTM-DAHA still needs to be optimized. Based on the temporary adjusted schedule, we use NSGA2 to find the optimal solution. Different from the multiobjective genetic algorithm described in Section4.1, we design a neighborhood operator to generate the initial population.The main idea of the neighborhood operator is to search all neighborhoods of the current schedule. As shown in Figure13, the current schedule S
S is represented by the red point and the yellow points denote the neighborhoods of S
S. Specifically, we change the locus of a task to move it to another position, as shown in Figure 14.Figure 13
The neighborhods of the current schedule.Figure 14
Illustration of neighborhood operator.The procedure of the neighborhood operator is described as shown in Algorithm3.Algorithm 3
(1) According to the arrival time of a batch of emergency tasks, select the waiting tasks in the current scheduleS
S as T
w
(2) for alli
∈
[
1,2
,
…
,
T
w
], do
(3) for allj
∈
1
,
…
,
M, do
(4) compute all available opportunities for taski on satellite j
(5) end for
(6) compute the number of available opportunitiesW
i for task i
(7) end for
(8) let the neighborhood set of the current scheduleS
S
N be S
S
N
=
S
S
(9)  whileT
w
≠
⌀ do
(10)  take the serial numberi of the first task in T
w
(11)    ifW
i
≤
1 do
(12)   removet
i from T
w and then go to Step (9)
(13)   end if
(14)   else
(15) try to change the locus of task i in the chromosome
(16)if succeed, update the chromosome and add the chromosome to S
S
N
(17)remove t
i from T
w and then go to Step (9)
(18)   end if
(19)else
(20)   removet
i from T
w and then go to Step (9)
(21) end while
(22) output the neighborhood set of the current scheduleS
S
NAfter initializing the population using the neighborhood operator, the next serial of operation is selection, crossover, mutation, and nondominated sorting as expressed in Section4.1. Finally, using the multiobjective genetic algorithm NSGA2, we obtain the optimal solution as the new adjusted schedule.


## 4.1. Multiobjective Genetic Algorithm

Satellites observation scheduling problem has been proven to be NP-complete. Thus, it is impossible to find polynomial time algorithms for finding optimal solutions. Genetic algorithms are the most successful algorithms for efficiently dealing with the complexity of computationally hard problems from the networking domain [23, 43]. Before introducing the multiobjective genetic algorithm NSGA2, we firstly make clear some terms, such as Pareto Dominance, Pareto optimality, Pareto Optimal Set, Pareto Front, Nondominated Sorting, and crowding distance, which will be referred to in the algorithm. We give the associative definitions in Appendix A.As shown in Figure6, we present the main process of NSGA2. First, we initialize the parameters and generate the initial population P
f
a
t
h
e
r. After computing the fitness function of P
f
a
t
h
e
r, we make use of the binary tournament selection mechanism, single point crossover operator, and single point mutation operator for the current individuals until the number of the next generation population P
c
h
i
l
d reaches the size M. Then, we set the total population as Q
=
P
f
a
t
h
e
r
∪
P
c
h
i
l
d by combining P
f
a
t
h
e
r and P
c
h
i
l
d. Next, the nondominated sorting algorithm is used to divide the population Q into different Pareto Front F
r
a
n
k with the rank of each individual. We choose the individuals from F
r
a
n
k until the number of the next population |
P
n
e
x
t
| satisfies the request, ranking from small to large. If |
P
n
e
x
t
| is greater than M, then we sort the current F
r
a
n
k in order according to the crowding distance and choose the better individuals as P
n
e
x
t. Finally, if the result satisfies the termination conditions, then we output the nondominated solution set. Otherwise, we let P
f
a
t
h
e
r
=
P
n
e
x
t and repeat the process.Figure 6
The main process of NSGA-2.The main parts of the genetic algorithm will be described in detail including initialization, selection operator, crossover operator, mutation operator, nondominated sorting, and the computation of crowding distance.


### 4.1.1. Initialization

Unlike local search techniques, the genetic algorithm uses a population of individuals giving thus the search a larger scope and chances to find a better solution. In this paper, the satellite scheduling problem is encoded into a set of chromosomes. Each chromosome composed of an imaging task sequence of different satellites represents a solution and is assigned a fitness value to determine how good each chromosome is. The structure of a chromosome is shown in Figure7. In the algorithm, some parameters such as the size of population M, the maximum iterative number T, the probability of crossover p
c
r
o
s
s
o
v
e
r, and mutation probability p
m
u
t
a
t
i
o
n must be set. The initial population is generated by random strategy.Figure 7
The structure of chromosome.


### 4.1.2. Selection Operator

Several selection strategies have been proposed in the previous literatures such as roulette wheel selection and binary tournament selection. We adopt binary tournament selection in this paper. The main steps are to choose two individuals randomly from a population and to select the individual that dominates the others.


### 4.1.3. Crossover Operator

Crossover operator plays an important role in the genetic algorithm. The best genetic information of parents can be transmitted to offspring during generations of the evolution process by the crossover operator. After parent chromosomes have been selected from the population, we set the crossover probabilityp
c
r
o
s
s
o
v
e
r to allow the majority of chromosomes to mate and pass to their offspring. Figure 8 shows an example of the crossover. According to the characteristics of the satellite scheduling problem, we cross the parent chromosomes to generate child chromosomes and then delete the same genes in common chromosome. Finally we attempt to arrange the tasks differently for both parent chromosomes in child chromosomes.Figure 8
Crossover operator.


### 4.1.4. Mutation Operator

Mutation operator intends to keep the variety of the population and improve the individuals by small local perturbations. Additionally, the mutation operator provides a component of randomness in the neighborhood of the individuals of the population. Therefore, genetic algorithm has the ability to avoid falling prematurely into local optima and eventually escapes from them during the search process. For example, if we set the probabilityp
m
u
t
a
t
i
o
n
=
0.2, then the overall procedure of the random mutation operator on the chromosome is shown in Figure 9. We choose a scheduled task that has another window randomly such as t
8. Then the task is rearranged in another available window.Figure 9
Mutation operator.


### 4.1.5. Nondominated Sorting

The main procedure of nondominated sorting is described in Algorithm1 in detail.Algorithm 1
for eachp
∈
Q // every individual in population p
∈
Q
S
p
=
⌀;    // let the set of individuals dominated by p be null
n
p
=
0;     // the number of individuals dominating p be 0
for eachq
∈
Q
if (p
≺
q) then     // if p dominates q
S
p
=
S
p
∪
q; add q into S
p
else if (p
≻
q) then   // if q dominates p
n
p
=
n
p
+
1;
end for;
end for;
for eachp
∈
Q
if (n
p
=
=
0) then
p
r
a
n
k
=
1;     // the rank of p is 1st
F
1
=
F
1
∪
p;     // add p into the set of the first non-dominated front F
1
end for;
i
=
1;         // initialize the rank of the non-dominated fronts
while(
F
i
≠
⌀
)
for eachp
∈
F
i
for eachq
∈
S
p
n
q
=
n
q
-
1; // the number of individuals dominating p is reduced by one
if (n
q
=
=
0) then  // if there is no individual dominating q
q
r
a
n
k
=
i
+
1;     // the rank of q plus one
F
i
+
1
=
F
i
+
1
∪
q;    // add q into the non-dominated front F
i
+
1
end for;
end for;
i
=
i
+
1;
end while.


### 4.1.6. Crowding Distance Computation

The main procedure of computing the crowding distance is described in Algorithm2 in detail.Algorithm 2
I
=
F
r
a
n
k;         // number of solutions in F
r
a
n
k
for eachp
∈
F
r
a
n
k
F
r
a
n
k
[
p
]
d
i
s
t
a
n
c
e
=
0;      // initialize the distance
end for;
for each objectivem
F
r
a
n
k
,
m
=
s
o
r
t
(
F
r
a
n
k
,
m
);    // sort using each objective value
for eachi
=
2
→
I
-
1
F
rank
⁡
,
m
[
i
]
d
i
s
t
a
n
c
e
=
(
F
r
a
n
k
,
m
i
+
1
-
F
r
a
n
k
,
m
i
-
1
)
/
(
F
r
a
n
k
,
m
m
a
x
-
F
r
a
n
k
,
m
m
i
n
); //crowding-distance of individual i in m_th objective
end for;
end for;
for eachp
∈
F
r
a
n
k
for each objectivem
F
r
a
n
k
[
p
]
d
i
s
t
a
n
c
e
=
F
r
a
n
k
[
p
]
d
i
s
t
a
n
c
e
+
F
r
a
n
k
,
m
[
p
]
d
i
s
t
a
n
c
e; // crowding-distance of p
end for;
end for.


## 4.1.1. Initialization

Unlike local search techniques, the genetic algorithm uses a population of individuals giving thus the search a larger scope and chances to find a better solution. In this paper, the satellite scheduling problem is encoded into a set of chromosomes. Each chromosome composed of an imaging task sequence of different satellites represents a solution and is assigned a fitness value to determine how good each chromosome is. The structure of a chromosome is shown in Figure7. In the algorithm, some parameters such as the size of population M, the maximum iterative number T, the probability of crossover p
c
r
o
s
s
o
v
e
r, and mutation probability p
m
u
t
a
t
i
o
n must be set. The initial population is generated by random strategy.Figure 7
The structure of chromosome.


## 4.1.2. Selection Operator

Several selection strategies have been proposed in the previous literatures such as roulette wheel selection and binary tournament selection. We adopt binary tournament selection in this paper. The main steps are to choose two individuals randomly from a population and to select the individual that dominates the others.


## 4.1.3. Crossover Operator

Crossover operator plays an important role in the genetic algorithm. The best genetic information of parents can be transmitted to offspring during generations of the evolution process by the crossover operator. After parent chromosomes have been selected from the population, we set the crossover probabilityp
c
r
o
s
s
o
v
e
r to allow the majority of chromosomes to mate and pass to their offspring. Figure 8 shows an example of the crossover. According to the characteristics of the satellite scheduling problem, we cross the parent chromosomes to generate child chromosomes and then delete the same genes in common chromosome. Finally we attempt to arrange the tasks differently for both parent chromosomes in child chromosomes.Figure 8
Crossover operator.


## 4.1.4. Mutation Operator

Mutation operator intends to keep the variety of the population and improve the individuals by small local perturbations. Additionally, the mutation operator provides a component of randomness in the neighborhood of the individuals of the population. Therefore, genetic algorithm has the ability to avoid falling prematurely into local optima and eventually escapes from them during the search process. For example, if we set the probabilityp
m
u
t
a
t
i
o
n
=
0.2, then the overall procedure of the random mutation operator on the chromosome is shown in Figure 9. We choose a scheduled task that has another window randomly such as t
8. Then the task is rearranged in another available window.Figure 9
Mutation operator.


## 4.1.5. Nondominated Sorting

The main procedure of nondominated sorting is described in Algorithm1 in detail.Algorithm 1
for eachp
∈
Q // every individual in population p
∈
Q
S
p
=
⌀;    // let the set of individuals dominated by p be null
n
p
=
0;     // the number of individuals dominating p be 0
for eachq
∈
Q
if (p
≺
q) then     // if p dominates q
S
p
=
S
p
∪
q; add q into S
p
else if (p
≻
q) then   // if q dominates p
n
p
=
n
p
+
1;
end for;
end for;
for eachp
∈
Q
if (n
p
=
=
0) then
p
r
a
n
k
=
1;     // the rank of p is 1st
F
1
=
F
1
∪
p;     // add p into the set of the first non-dominated front F
1
end for;
i
=
1;         // initialize the rank of the non-dominated fronts
while(
F
i
≠
⌀
)
for eachp
∈
F
i
for eachq
∈
S
p
n
q
=
n
q
-
1; // the number of individuals dominating p is reduced by one
if (n
q
=
=
0) then  // if there is no individual dominating q
q
r
a
n
k
=
i
+
1;     // the rank of q plus one
F
i
+
1
=
F
i
+
1
∪
q;    // add q into the non-dominated front F
i
+
1
end for;
end for;
i
=
i
+
1;
end while.


## 4.1.6. Crowding Distance Computation

The main procedure of computing the crowding distance is described in Algorithm2 in detail.Algorithm 2
I
=
F
r
a
n
k;         // number of solutions in F
r
a
n
k
for eachp
∈
F
r
a
n
k
F
r
a
n
k
[
p
]
d
i
s
t
a
n
c
e
=
0;      // initialize the distance
end for;
for each objectivem
F
r
a
n
k
,
m
=
s
o
r
t
(
F
r
a
n
k
,
m
);    // sort using each objective value
for eachi
=
2
→
I
-
1
F
rank
⁡
,
m
[
i
]
d
i
s
t
a
n
c
e
=
(
F
r
a
n
k
,
m
i
+
1
-
F
r
a
n
k
,
m
i
-
1
)
/
(
F
r
a
n
k
,
m
m
a
x
-
F
r
a
n
k
,
m
m
i
n
); //crowding-distance of individual i in m_th objective
end for;
end for;
for eachp
∈
F
r
a
n
k
for each objectivem
F
r
a
n
k
[
p
]
d
i
s
t
a
n
c
e
=
F
r
a
n
k
[
p
]
d
i
s
t
a
n
c
e
+
F
r
a
n
k
,
m
[
p
]
d
i
s
t
a
n
c
e; // crowding-distance of p
end for;
end for.


## 4.2. Rule-Based Heuristic Algorithm

The solution with maximum revenue and robustness, which is produced by NSGA2, is selected as the initial schedule. When the schedule is executed, a number of emergency tasks arrive. In this case, the current executing schedule must be modified to arrange these emergency tasks.When a batch of emergency tasks arrives, based on the current scheduling time, tasks may have different states: finished task, running task, waiting task, and new task. In the example shown in Figure10, t
S
k is the current scheduling time. If task i has been executed before the current time, then task i is a finished task while t
e
i
<
t
S
k. If t
s
i
<
t
S
k
<
t
e
i, then task i is a running task. Task i is a waiting task if t
s
i
>
t
S
k. If task i is an emergent task that has not been planned, then task i is a new task.Figure 10
The states of tasks.According to the analysis on the state of the tasks, the waiting tasks in the current schedule can be adjusted. Focusing on the new emergency tasks, we assign these tasks to the current schedule. In this paper, we employ a rule-based heuristic algorithm considering compact task merging (CTM-DAHA) to insert the new tasks dynamically [44]. The main idea of the heuristic algorithm is to assign the most conflict-free time window to the task most in need. With CTM-DAHA, we obtain the temporary adjusted schedules.To describe the dynamic adjusting rule-based heuristic algorithm considering compact task merging clearly, we first give some definitions.Definition 1.
The need of the task indicates how badly the task needs to be performed [30, 44]:(9)
N
t
i
=
p
i
A
O
i
.Definition 2.
The contention of the task window is measured by counting the number of tasks that need the time window, weighted by the weights of the tasks:(10)
C
w
=
∑
t
i
∈
T
w
p
t
i
,where T
w is the set of tasks that could be executed at any moment within time window w and p
(
t
i
) is the weight of the tasks t
i.The dynamic adjusting rule-based heuristic algorithm CTM-DAHA is presented as shown in Figure11 [44]. To accommodate emergency tasks in the initial scheme, firstly we update the state of tasks in the schedule. Then, all new tasks are inserted into a waiting queue according to the needs of the tasks N
t
i, from high to low. The time windows of each task are ranked from low to high according to the contention C
w. For a task, we first judge whether it can merge with any other existing task in the current schedule. If all time windows of the task fail to be merged, we attempt to insert the task directly if it does not conflict with any other task. If direct insertion fails, we judge whether the task can be inserted by rearranging the conflict tasks. If direct insertion and insertion by rearranging do not succeed, some tasks may be deleted for inserting an emergency task. Then the entire process will repeat until the waiting queue is empty. Take, for example, a current executing schedule as shown in Figure 12(a). With the arrival of emergency tasks, that is, T
E
=
t
8
,
t
9
,
t
10
,
t
11, they should be arranged in time. Task t
8 can be combined with t
2 by compact task merging. Task t
9 can be inserted directly. Task t
10 is inserted into the schedule by rearranging the conflict task t
5. Task t
7 is deleted from the schedule so that task t
11 with higher weight can be inserted. Figure 12(b) shows the planning task list of the adjusted schedule.Figure 11
The process of inserting a new task.Figure 12
(a) The current executing schedule. (b) The adjusted schedule.
(a)
(b)


## 4.3. Neighborhood Operator

The solution obtained by CTM-DAHA still needs to be optimized. Based on the temporary adjusted schedule, we use NSGA2 to find the optimal solution. Different from the multiobjective genetic algorithm described in Section4.1, we design a neighborhood operator to generate the initial population.The main idea of the neighborhood operator is to search all neighborhoods of the current schedule. As shown in Figure13, the current schedule S
S is represented by the red point and the yellow points denote the neighborhoods of S
S. Specifically, we change the locus of a task to move it to another position, as shown in Figure 14.Figure 13
The neighborhods of the current schedule.Figure 14
Illustration of neighborhood operator.The procedure of the neighborhood operator is described as shown in Algorithm3.Algorithm 3
(1) According to the arrival time of a batch of emergency tasks, select the waiting tasks in the current scheduleS
S as T
w
(2) for alli
∈
[
1,2
,
…
,
T
w
], do
(3) for allj
∈
1
,
…
,
M, do
(4) compute all available opportunities for taski on satellite j
(5) end for
(6) compute the number of available opportunitiesW
i for task i
(7) end for
(8) let the neighborhood set of the current scheduleS
S
N be S
S
N
=
S
S
(9)  whileT
w
≠
⌀ do
(10)  take the serial numberi of the first task in T
w
(11)    ifW
i
≤
1 do
(12)   removet
i from T
w and then go to Step (9)
(13)   end if
(14)   else
(15) try to change the locus of task i in the chromosome
(16)if succeed, update the chromosome and add the chromosome to S
S
N
(17)remove t
i from T
w and then go to Step (9)
(18)   end if
(19)else
(20)   removet
i from T
w and then go to Step (9)
(21) end while
(22) output the neighborhood set of the current scheduleS
S
NAfter initializing the population using the neighborhood operator, the next serial of operation is selection, crossover, mutation, and nondominated sorting as expressed in Section4.1. Finally, using the multiobjective genetic algorithm NSGA2, we obtain the optimal solution as the new adjusted schedule.


## 5. Experimental Simulation and Discussion

In this section, we evaluate the performance of the proposed algorithm HA-NSGA2. To reveal the advantages of the algorithm, we compare it with RBHA-DTSP [36] and CTM-DAHA [44]. The two methods both use multiobjective genetic algorithm to make the initial schedule for common tasks. To evaluate the advantage of the compact task merging method (CTM), we perform experiments to compare the scheduling results obtained by HA-NSGA2 with the two task merging strategies: traditional task merging strategy (TTM) and compact task merging method (CTM). Specifically, we embed the two task merging methods into HA-NSGA2, respectively, so as to prove the effectiveness of compact task merging strategy.(i)
RBHA-DTSP: the basic idea of RBHA-DTSP is to carry out some amount of iterative repair search inside each emergency task’s available opportunities. With the repair search for a given emergency task, some rules are adopted to decide which tasks should be retracted [36].
(ii)
CTM-DAHA: this is a dynamic adjusting rule-based heuristic algorithm considering compact task merging (CTM-DAHA) which is designed to insert the emergency tasks into the initial schedule.To evaluate the result we use the following performance metrics.Emergency task revenue (ETR) can be described as(11)
E
T
R
=
∑
i
=
1
N
∑
j
=
1
M
∑
k
=
1
K
i
j
x
i
,
k
j
p
i
.Satisfaction ratio (SR) is defined as SR = total number of tasks that can be arranged in the scheme/total number of tasks.Scheduled tasks robustness (STR) can be defined as(12)
S
T
R
=
∑
i
=
1
N
∑
j
=
1
M
∑
k
=
1
K
i
j
p
i
×
x
i
,
k
j
×
y
i
.In fact, the satellite application is a complex process and the orders can only be uploaded with special equipment within limited visible time windows, so it is important to make the least adjustment to keep the stability of the schedule as well as to insert more tasks to keep the efficiency of the schedule. Therefore, the main measurement of perturbation needs to be considered.Perturbation measurement (PM) is a metric used to describe the distance between the adjusted scheme and the initial scheme. PM can be defined with the total number of initial tasks that change in the adjusted scheme compared with the initial scheme.


### 5.1. Simulation Method and Parameters

Without loss of generality, we acquire the imaging targets randomly in the area: latitude −180°~180° and longitude −65°~65°. The scheduling period is 24 h, which can be denoted by[
0
,
86400
]. The number of common tasks is 200. In addition, there are five batches of new coming emergency tasks and each batch is given the same size: 50. The arrival time of a batch t
S
k is a random positive number distributed in t
S
0
,
t
S
f. In the experiment, we simulate 5 batches of emergency tasks and T
S is set as T
S
=
{
t
S
0
,
t
S
1
,
…
,
t
S
e
,
t
S
f
}
=
{
0,59,13300,26100,41800,65000,86400
}. Moreover, the deadline of an emergency task is the end time of scheduling: 86400. Without loss of generality, the weights of all tasks are randomly distributed in 1,10. Two sensors on different satellites are simulated to accomplish the tasks. The parameters of sensors are shown in Table 1. The available opportunities, including time windows and slewing angles associated with tasks, are computed using STK (Satellite Tool Kit). The time window is removed if its span is shorter than the duration of the corresponding task or its finished time is later than the deadline. Moreover, we assume that the maximum time for each satellite to open its sensor once is 60 seconds and that the longest imaging time in any period time of o
r
b
j is 150 seconds.Table 1
Parameters of satellites.
Parameters
Satellites
1
Satellites
2
Average height (km)
780.099
505.984
Orbital inclination (degree)
98.5
97.421
Local descending node time (am)
10:30
10:30
Argument of perigee
90
90
Eccentricity ratio (degree)
0.0011
0
Nodical period (min)
100.38
97.716
Maximum slewing angle (degree)
±32
±32
Field of view (degree)
8.4
6


### 5.2. The Simulation Result

We carry out two groups of experiments in this section. We investigate the performance impact of different algorithms, that is, RBHA-DTSP, CTM-DAHA, and HA-NSGA2, in the first group. The experimental results are depicted in Figure15. The second group of experiments is designed to evaluate the efficiency of the task merging method: CTM and TTM.Figure 15
The performance of different dynamic scheduling algorithms.
(a)
(b)
(c)Figure15(a) shows the result of the revenue of scheduled emergency tasks in each adjusted schedule. Among the algorithms, HA-NSGA2 shows the best scheduling revenue. The explanation is that HA-NSGA2 optimizes the robustness and uses the compact task merging strategy. In contrast, CTM-DAHA does not improve the robustness and RBHA-DTSP does not consider task merging. Based on Figure 15(b), we can see that, with more batches of emergency tasks, the robustness of each adjusted schedule decreases. This can be attributed to the fact that, with the time of scheduling increasing, the scheduling period becomes shorter. This means that the tasks’ available opportunities in a schedule decrease and the number of tasks which can be rearranged decreases. As a result, the robustness becomes smaller. In addition, in each scheduling, HA-NSGA2 can generate a more robust schedule except the last scheduling. In the last scheduling, the schedule obtained by HA-NSGA2 shows the lowest robustness because HA-NSGA2 scheduled more tasks and less spare time is left for other tasks to be rearranged. As a result, the robustness is worse. Figure 15(c) presents the satisfaction ratio of every scheduling result. It is found that the satisfaction ratio of all algorithms decreases as the arrival of more emergency tasks. This can be attributed to the fact that the number of scheduled tasks decreases compared with the increasing emergency tasks. Moreover, HA-NSGA2 shows the highest satisfaction ratio among all of the algorithms. Table 2 describes the number of scheduled emergency tasks and the number of adjusted tasks in the adjusted schedules. It is found that there is little difference of disturbance among the algorithms. On the whole, the ability dealing with emergency tasks of HA-NSGA2 is superior to that of the other algorithms.Table 2
The perturbation measurements of different algorithms.
Batch
RBHA-DTSP
CTM-DAHA
HA-NSGA2
N
PM
N
PM
N
PM
1
47
2
47
2
48
4
2
46
5
46
5
47
5
3
41
3
41
1
42
1
4
43
3
46
4
47
4
5
43
1
42
1
44
1
Note:N: the number of scheduled emergency tasks.Figure16 shows the performance impact of the two task merging methods. Figure 16(a) demonstrates that, with the increase in scheduling time, the compact task merging method (CTM) can get a higher total emergency task revenue. This result indicates that more emergency tasks can be arranged by the compact task merging method and more opportunities can be left for other emergency tasks. From Figure 16(b), it is found that robustness of the schedule of the compact task merging method is lower than that of the traditional task merging strategy. This result can be attributed to two factors. First, the algorithm with the compact task merging strategy can arrange more emergency tasks compared with traditional task merging method. The other is the composite task, which is unable to participate in the robustness computing because there is only one synthetic available window, acquired by compact task merging. Moreover, the number of composite tasks by compact task merging is more than that by traditional task merging. So the compact task merging strategy is better than the traditional merging strategy in the available windows and the satellite resources left. Figure 16(c) depicts that the compact task merging method can arrange more emergencies and obtain a more satisfactory schedule. Table 3 describes the way of adjusting of emergency tasks and the distance of the adjusted scheme from the initial scheme. In the same perturbation measurement, HA-NSGA2 with the compact task merging method can arrange more emergency tasks. Also, CTM can merge more tasks than CTM. The result proves that the compact task merging strategy has an advantage over the existing traditional method. The compact task merging method can improve the chances of inserting emergency tasks.Table 3
The perturbation measurements of different task merging strategies.
Batch
Method
N
TM
NI
NIR
NID
PM
1
CTM
48
4
42
1
1
4
TTM
47
1
44
1
1
4
2
CTM
47
4
38
3
2
5
TTM
46
1
41
2
2
6
3
CTM
42
3
38
1
0
1
TTM
41
2
38
1
0
2
4
CTM
47
7
36
1
3
4
TTM
46
1
39
1
4
6
5
CTM
44
3
40
0
1
1
TTM
42
1
43
0
0
1
Note:N: the number of scheduled emergency tasks, PM: the number of adjusted tasks in the schedules, NITM: the number of emergency tasks inserted by task merging, NI: the number of emergency tasks inserted directly, NIR: the number of emergency tasks inserted by rearranging, and NID: the number of emergency tasks inserted by deleting.Figure 16
The performances of different task merging methods.
(a)
(b)
(c)


### 5.3. Discussion

Based on the extensive experiments, we can evaluate the performance of HA-NSGA2 proposed in the paper. Using the algorithm HA-NSGA2 with two objectives, that is, the revenue and robustness, we can obtain the scheduling scheme that has higher revenue and stronger ability to resist disturbance in emergency tasks scheduling. HA-NSGA2 algorithm can insert more emergency tasks while keeping the high revenue as is shown in Figure15. Moreover, HA-NSGA2 can significantly reduce the scheduling disturbance in the process of scheduling emergency tasks. The experiments prove that the HA-NSGA2 is capable of finding optimal solutions with the ability to resist disturbance and to address emergency tasks efficiently. Moreover, the compact task merging strategy can improve the chances of merging multiple tasks and save the satellite resources. So the method proposed in this paper is more practical and satisfies the requests of the users.


## 5.1. Simulation Method and Parameters

Without loss of generality, we acquire the imaging targets randomly in the area: latitude −180°~180° and longitude −65°~65°. The scheduling period is 24 h, which can be denoted by[
0
,
86400
]. The number of common tasks is 200. In addition, there are five batches of new coming emergency tasks and each batch is given the same size: 50. The arrival time of a batch t
S
k is a random positive number distributed in t
S
0
,
t
S
f. In the experiment, we simulate 5 batches of emergency tasks and T
S is set as T
S
=
{
t
S
0
,
t
S
1
,
…
,
t
S
e
,
t
S
f
}
=
{
0,59,13300,26100,41800,65000,86400
}. Moreover, the deadline of an emergency task is the end time of scheduling: 86400. Without loss of generality, the weights of all tasks are randomly distributed in 1,10. Two sensors on different satellites are simulated to accomplish the tasks. The parameters of sensors are shown in Table 1. The available opportunities, including time windows and slewing angles associated with tasks, are computed using STK (Satellite Tool Kit). The time window is removed if its span is shorter than the duration of the corresponding task or its finished time is later than the deadline. Moreover, we assume that the maximum time for each satellite to open its sensor once is 60 seconds and that the longest imaging time in any period time of o
r
b
j is 150 seconds.Table 1
Parameters of satellites.
Parameters
Satellites
1
Satellites
2
Average height (km)
780.099
505.984
Orbital inclination (degree)
98.5
97.421
Local descending node time (am)
10:30
10:30
Argument of perigee
90
90
Eccentricity ratio (degree)
0.0011
0
Nodical period (min)
100.38
97.716
Maximum slewing angle (degree)
±32
±32
Field of view (degree)
8.4
6


## 5.2. The Simulation Result

We carry out two groups of experiments in this section. We investigate the performance impact of different algorithms, that is, RBHA-DTSP, CTM-DAHA, and HA-NSGA2, in the first group. The experimental results are depicted in Figure15. The second group of experiments is designed to evaluate the efficiency of the task merging method: CTM and TTM.Figure 15
The performance of different dynamic scheduling algorithms.
(a)
(b)
(c)Figure15(a) shows the result of the revenue of scheduled emergency tasks in each adjusted schedule. Among the algorithms, HA-NSGA2 shows the best scheduling revenue. The explanation is that HA-NSGA2 optimizes the robustness and uses the compact task merging strategy. In contrast, CTM-DAHA does not improve the robustness and RBHA-DTSP does not consider task merging. Based on Figure 15(b), we can see that, with more batches of emergency tasks, the robustness of each adjusted schedule decreases. This can be attributed to the fact that, with the time of scheduling increasing, the scheduling period becomes shorter. This means that the tasks’ available opportunities in a schedule decrease and the number of tasks which can be rearranged decreases. As a result, the robustness becomes smaller. In addition, in each scheduling, HA-NSGA2 can generate a more robust schedule except the last scheduling. In the last scheduling, the schedule obtained by HA-NSGA2 shows the lowest robustness because HA-NSGA2 scheduled more tasks and less spare time is left for other tasks to be rearranged. As a result, the robustness is worse. Figure 15(c) presents the satisfaction ratio of every scheduling result. It is found that the satisfaction ratio of all algorithms decreases as the arrival of more emergency tasks. This can be attributed to the fact that the number of scheduled tasks decreases compared with the increasing emergency tasks. Moreover, HA-NSGA2 shows the highest satisfaction ratio among all of the algorithms. Table 2 describes the number of scheduled emergency tasks and the number of adjusted tasks in the adjusted schedules. It is found that there is little difference of disturbance among the algorithms. On the whole, the ability dealing with emergency tasks of HA-NSGA2 is superior to that of the other algorithms.Table 2
The perturbation measurements of different algorithms.
Batch
RBHA-DTSP
CTM-DAHA
HA-NSGA2
N
PM
N
PM
N
PM
1
47
2
47
2
48
4
2
46
5
46
5
47
5
3
41
3
41
1
42
1
4
43
3
46
4
47
4
5
43
1
42
1
44
1
Note:N: the number of scheduled emergency tasks.Figure16 shows the performance impact of the two task merging methods. Figure 16(a) demonstrates that, with the increase in scheduling time, the compact task merging method (CTM) can get a higher total emergency task revenue. This result indicates that more emergency tasks can be arranged by the compact task merging method and more opportunities can be left for other emergency tasks. From Figure 16(b), it is found that robustness of the schedule of the compact task merging method is lower than that of the traditional task merging strategy. This result can be attributed to two factors. First, the algorithm with the compact task merging strategy can arrange more emergency tasks compared with traditional task merging method. The other is the composite task, which is unable to participate in the robustness computing because there is only one synthetic available window, acquired by compact task merging. Moreover, the number of composite tasks by compact task merging is more than that by traditional task merging. So the compact task merging strategy is better than the traditional merging strategy in the available windows and the satellite resources left. Figure 16(c) depicts that the compact task merging method can arrange more emergencies and obtain a more satisfactory schedule. Table 3 describes the way of adjusting of emergency tasks and the distance of the adjusted scheme from the initial scheme. In the same perturbation measurement, HA-NSGA2 with the compact task merging method can arrange more emergency tasks. Also, CTM can merge more tasks than CTM. The result proves that the compact task merging strategy has an advantage over the existing traditional method. The compact task merging method can improve the chances of inserting emergency tasks.Table 3
The perturbation measurements of different task merging strategies.
Batch
Method
N
TM
NI
NIR
NID
PM
1
CTM
48
4
42
1
1
4
TTM
47
1
44
1
1
4
2
CTM
47
4
38
3
2
5
TTM
46
1
41
2
2
6
3
CTM
42
3
38
1
0
1
TTM
41
2
38
1
0
2
4
CTM
47
7
36
1
3
4
TTM
46
1
39
1
4
6
5
CTM
44
3
40
0
1
1
TTM
42
1
43
0
0
1
Note:N: the number of scheduled emergency tasks, PM: the number of adjusted tasks in the schedules, NITM: the number of emergency tasks inserted by task merging, NI: the number of emergency tasks inserted directly, NIR: the number of emergency tasks inserted by rearranging, and NID: the number of emergency tasks inserted by deleting.Figure 16
The performances of different task merging methods.
(a)
(b)
(c)


## 5.3. Discussion

Based on the extensive experiments, we can evaluate the performance of HA-NSGA2 proposed in the paper. Using the algorithm HA-NSGA2 with two objectives, that is, the revenue and robustness, we can obtain the scheduling scheme that has higher revenue and stronger ability to resist disturbance in emergency tasks scheduling. HA-NSGA2 algorithm can insert more emergency tasks while keeping the high revenue as is shown in Figure15. Moreover, HA-NSGA2 can significantly reduce the scheduling disturbance in the process of scheduling emergency tasks. The experiments prove that the HA-NSGA2 is capable of finding optimal solutions with the ability to resist disturbance and to address emergency tasks efficiently. Moreover, the compact task merging strategy can improve the chances of merging multiple tasks and save the satellite resources. So the method proposed in this paper is more practical and satisfies the requests of the users.


## 6. Conclusion and Future Work

To solve dynamic scheduling problem for emergency tasks in a multisatellite observation system, we propose a mixed algorithm named HA-NSGA2 to improve the ability of emergency tasks scheduling from two aspects. In our algorithm two optimization objectives, that is, revenue and robustness, are considered continuously. Firstly, we schedule common tasks by using the multiobjective genetic algorithm NSGA2 to obtain an initial solution with high revenue and robustness. Then, the heuristic algorithm which embeds a compact task merging strategy is used to handle emergency tasks. Finally, to optimize the solution, NAGA2, which embeds a novel neighborhood operator to generate the initial population, is adopted to search the optimal result in the local scope. Extensive experimental simulation proves that the robustness is an important factor in dynamic scheduling. The algorithm HA-NSGA2 proposed in this paper optimizes the robustness and obtains the more robust scheduling results with the highest revenue compared with other algorithms. Moreover, the compact task merging strategy can improve the chances of merging multiple tasks. Therefore, we conclude that the robustness of the schedule has considerable significance in the dynamic scheduling problem.In the future, our studies will address the following issues: first, we will conduct some research on area targets and consider more critical issues, such as resource availability, data dimension, and communication. In addition, we will improve our scheduling model by considering more constraints, such as memory capacity, energy consumption, and speed of upload. Finally, we will extend our experiments in real scene.



---

*Source: 482923-2015-12-06.xml*