Research on the Integrated Scheduling of Imaging and Data Transmission for Earth Observation Satellites

Abstract

This study focuses on the integrated scheduling issues of imaging and data transmission for Earth observation satellites, where each target needs to be imaged and transmitted within a feasible time window. The scheduling process also takes into account the constraints of satellite energy and storage capacity. In this paper, a mixed-integer linear programming (MILP) model for the integrated scheduling of imaging data transmission has been proposed. The MILP model was validated through numerical experiments based on simulation data from SuperView-1 series satellites. Additionally, some neighborhood mechanisms are designed based on the characteristics of the problem. Based on the neighborhood mechanisms, the rule-based large neighborhood search algorithm (RLNS) was designed, which constructs initial solutions through various scheduling rules and iteratively optimizes the solutions using multiple destroying and repairing operators. To address the shortcomings of the overly regular mechanism of the destruction and repair operator for large neighborhood search, we design a genetic algorithms (GA) for tuning the heuristic scheduling rules. The calculation results demonstrate the effectiveness of RLNS and GA, highlighting their advantages over CPLEX in solving large-scale problems.

1. Introduction

With the rapid development of satellite technology and space sensor technology, the number of Earth observation satellites has increased quickly, and the observation performance has continuously improved. The application of satellite remote sensing technology is becoming increasingly widespread, with demand growing rapidly.

In the observation activities, the satellite executes payload control commands to observe targets and transmits this information back to the ground station for analysis and assessment [1]. The payloads installed on these satellites are classified as passive remote sensors, which utilize the energy reflected from sunlight by ground targets or the electromagnetic wave energy radiated by the targets themselves to detect and identify them [2]. For Earth observation satellites, a complete imaging mission can be divided into two phases: the imaging phase and the data transmission phase. In the two phases of satellite imaging missions, there are some limitations such as energy, storage capacity, and so on. In general, satellite resources are relatively scarce, and not all user demands can be met; the goal of scheduling is to satisfy as many user demands as possible. For the task planning of Earth observation satellites, designing a reasonable scheduling scheme is crucial for making full use of satellite resources.

There has been a lot of research on the scheduling problems of Earth observation satellites. Cordeau et al. [3] transformed the satellite observation problem into a Selective Traveling Salesman Problem (STSP), converted the time window constraints of the satellite into the time window constraints of the vehicle task, and used the Unified Tabu Search Algorithm (UTSA) to solve the Earth-observation satellite task scheduling problem. Parish [4] conducted an in-depth study of the Satellite Range Scheduling Problem (SRSP) under the Air Force Satellite Control Network (AFSCN) and proposed a genetic algorithm based scheduling algorithm called “Genitor” to solve the AFSCN problem, which achieved a high degree of optimization. Sharkheyli et al. [5] investigated the agile Earth observation satellite scheduling problem by using dual decision variables to represent the mission time window of an Earth observation satellite and the start moment of the mission within the time window. Gabrel et al. [6] represented the satellite mission planning problem as a weighted directed acyclic graph, and the solution goal of the problem was to find a longest path of the graph. The advantage of this method is that the model is intuitive, easy to understand, and can be solved with the help of mature graph theoretic solving algorithms, but its shortcomings are that the expressive ability of the graph theoretic model is limited, and it is not possible to realize complex mission constraints such as area target imaging, imaging digital transmission, solid-state erasure, and so on, in the model, which is still to be improved for real problem portrayal. Integrated scheduling, solid-storage erasure, and other complex task constraints in the model, and the portrayal of practical problems, is still to be improved.

Pemberton et al. [7] conducted a constrained modeling of the imaging data transmission integration scheduling problem, but only provided a formal description of the issue based on analysis, without presenting algorithms or computational results. Bianchessi et al. [8,9] studied the scheduling problem of the COSMO-SkyMed radar constellation, analyzing in detail the occupancy and release of onboard storage. However, their mathematical models primarily considered the bottleneck constraints in the problem, namely the cumulative imaging count and cumulative imaging time constraints related to imaging. For data transmission processing, they adopted a simplified mode where data is transmitted back when there is a data transmission window and storage capacity available, and for the contention of multiple satellites returning data to a single ground station, they employed a simple first-come, first-served conflict resolution strategy. Li Jufang et al. [10] abstracted the satellite integration scheduling problem as a variant form of a transceiver problem, establishing a constrained planning model for the multi-satellite multi-station task planning problem, and employed a tabu search algorithm to solve the issue. Wang Jun [11] studied a comprehensive task scheduling model that only considered satellite task allocation without accounting for the scheduling of task start times, while considering both imaging and data transmission tasks, and proposed two modes for solving the problem based on global optimization and phase optimization. In the phase optimization mode, a task scheduling algorithm for emergency conditions based on the concept of imaging path delay dominance and the idea of label updating is proposed. Jin Peng et al. [12] designed a task scheduling strategy for multi-satellite emergency mission planning that combines fixed-period decision planning with local adjustment planning, and proposed a two-phase algorithm to address the dynamic programming problem of emergency tasks with uncertain arrival times. However, this paper, when studying the scheduling problem, only considers the selection of task time windows, without scheduling the specific start and end times of the tasks.

Wang Pei [13] modeled the task planning problem into a heterogeneous multi-vehicle delivery problem with multiple time windows and complementary resource constraints, and introduced the branch-and-price algorithm into the solution process of this problem. However, this study strictly limited the order of satellite data downlinking to follow the imaging sequence. Additionally, during the modeling process, to facilitate the solution of the branch-and-price method, the start time of tasks was restricted to integer values, and the satellite could only perform one action at the same time, meaning imaging and data transmission could not be executed simultaneously. Xing et al. [14] analyzed the integrated scheduling problem of satellite observation and data transmission in the context of satellite storage environments with partially erasable memory (PEM) and wholly erasable memory (HEM), proposed an integrated scheduling model suitable for both types of storage environments, and employed constructive heuristics and metaheuristics, using Tabu Simulated Annealing (TSA) and Tabu Late Acceptance (TLA) algorithms to solve the model. In this paper, the imaging and non-real-time data transmission actions of the satellite cannot be executed simultaneously. Sun et al. [15] studied the emergency task scheduling problem of agile satellites while simultaneously considering imaging and data transmission tasks.They accurately took into account the attitude adjustment of agile satellites and proposed a new time window partitioning method that transforms variable-spacing visible time windows into multiple fixed-spacing visible time windows and presented a scheduling algorithm based on merging insertion, direct insertion, shifting insertion, deletion insertion, and reinsertion strategies. In this study, the satellite can perform imaging and data transmission tasks simultaneously, and the storage is only required to not exceed the maximum storage capacity limit.

Hu et al. [16] assumes that data transmission occurs when the satellite passes over the ground station, with the data transmission time being the visible window time of the ground station and that the amount of data transmitted is variable, which is independent of the transmission time. The scheduling cycles of the satellite’s tasks were segmented according to the downlink time windows to establish a mixed-integer programming model for integrated imaging and data transmission scheduling problem with a branch-and-price algorithm to solve it. Zhu et al. [17] investigated the integrated scheduling problem of observation data transmission for Earth observation satellites with the involvement of relay satellites, assuming that ground station resources were sufficient to simultaneously meet the data transmission needs of multiple satellites. They used a directed acyclic graph to established a mixed-integer linear programming model, and proposed a two-stage genetic annealing algorithm to solve the model. Chen et al. [18] studied the integrated scheduling problem of Earth observation satellites, proposing an integer linear programming model and an local search algorithm. The algorithm utilizes an efficient constraint handling mechanism to guarantee algorithm efficiency. However, the model proposed in this study does not allocate and schedule tasks for satellites and ground stations, without considering the limitation on ground station antenna resources.

Kim et al. [19] studied the integrated scheduling problem of multiple satellites for imaging and data transmission under memory constraints, tracking the capacity changes during the task scheduling process through the sequence of task variables, but only used the Gurobi solver for solving, which is not applicable to large-scale cases and did not consider task allocation for stations, adopting a “first-come, first-served” approach for data transmission. Lee et al. [20] abstracted the integrated scheduling problem of imaging and data transmission as a vehicle routing problem with pick up and delivery, establishing a mixed-integer programming model for the integrated scheduling of command uplinks, imaging, and data transmission for multiple satellites, and verified the model’s effectiveness through a solver. Zhang et al. [21] studied the imaging and data transmission integration scheduling problem for two types of data transmission modes: real-time data transmission and storage distribution. They established a mixed-integer programming model and designed a genetic algorithm based on the earliest start rule for observation tasks and the earliest suitable time rule for data transmission tasks. He et al. [22] studied the multi-satellite observation-relay transmission–downloading coupling scheduling problem, and improved the conventional tabu search algorithm for multi-satellite earth observation by integrating the data transmission path planning algorithm to solve and carry out the entire coupling process for earth observation. And, a satellite cluster profit-state evaluation function was provided to enhance the local search process, while a rule-based Dijkstra data transmission path planning method was proposed in the data transmission planning algorithm.

Table 1. Previous research on satellite imaging and data transmission scheduling.

Literature	Agile Satellite	Imaging and Transmission Are Performed in Parallel	Limitated Ground Station Resources	Time Window Discretized
[3,5]	✓	×	×	×
[1,2,6,11,12]	×	×	×	✓
[7,8,9,10]	✓	×	✓	✓
[13,14,15]	✓	×	✓	×
[16,17,18]	✓	✓	×	×
[19,20]	✓	✓	×	×
[21,22]	✓	✓	✓	×

summarizes the related work. Due to the explosive characteristics of imaging and data transmission scheduling, traditional research mostly separates the scheduling of imaging tasks from that of data transmission tasks, and there is little research that considers both the imaging and data transmission processes simultaneously. Current research on integrated scheduling is mostly based on various simplified conditions such as: discretization of time windows, unlimited ground station antenna resources, and “first-come, first-served” execution of data transmission tasks and so on. Therefore, in order to improve the effectiveness of satellite scheduling, it is necessary to conduct more in-depth research on the integrated scheduling problem.

This study addresses the integrated scheduling problem of parallel imaging and data transmission for agile Earth observation satellites, considering sliding time windows and ground station resource constraints, establishes a mixed-integer linear programming model and designs various neighborhood operators and heuristic rules within a large neighborhood search algorithm framework.

The remainder of this paper is organized as follows: Section 2 presents the problem description and model formulation. In Section 3, the CPLEX CP Solver Solution is shown. Section 4 provides the details of the Rule-based Large Neighborhood Search algorithm (RLNS) algorithm. Section 5 describes the simulation experiments, including the experimental settings and results. Finally, Section 6 presents conclusions and directions for future research.

2. Mathematical Programming Model

2.1. Problem Definition

The satellite’s imaging actions, data transmission actions, and attitude maneuvers all consume energy. However, during its operation, the satellite cannot always replenish energy by receiving external radiation. Therefore, during scheduling, the satellite has a limited total energy, and the energy consumed in executing tasks must comply with energy constraints. Due to the limitations of the onboard storage capacity of satellites, the imaging and data transmission plans of the satellites need to ensure that the observed data stored in the satellite meets the constraints of the storage capacity.

For agile satellites, their attitude maneuverability is stronger, and the selectable time window for ground targets is longer. When observing a target, it is necessary to determine the start and end time of the observation task within the feasible time window. Due to user demands for the quality of the target image, it is necessary to limit the side viewing angle of the satellite during target imaging to avoid issues where the image resolution does not meet user requirements.

This problem can be described as maximizing scheduling benefits by appropriately arranging which satellites will execute the targets observation tasks, the execution times of these observation tasks, which ground stations will receive the satellites’ data downlink tasks, and the execution times of the downlink tasks, all while satisfying the constraints of satellite energy and storage capacity.

2.2. Assumptions

• Once the satellite’s observation and data transmission activities begin, they must not be interrupted.
• Each satellite is equipped with only one solid-state storage and battery resource. Without considering the uncertainty of resource consumption such as solid-state storage and batteries on board, the storage capacity and energy of the satellite are limited.
• The satellite operates in a playback mode, which means it first captures images and then transmits the imaging data to the ground station.
• Satellites can simultaneously perform imaging and data downlink operations.
• The attitude transition time of the satellite between two targets is a fixed value. A fixed attitude transition time needs to be satisfied between two data transmission missions from a satellite to different ground stations, and similarly, a fixed transition time needs to be satisfied between two data transmission missions from ground stations to different satellites.
• Since the energy consumption of satellite attitude maneuvers is relatively small compared to imaging and data transmission missions, the energy consumed by satellite attitude maneuvers is not considered in this study.
• Each satellite carries only one sensor.
• Ignoring the factors that affect observation tasks, such as cloud cover, solar angle, and other meteorological conditions.
• It is necessary to select a satellite with an appropriate side view angle for imaging in order to meet the user’s requirements for the quality of the target image.

Figure 1 shows a diagram of the example scenario.

2.3. MILP Model Formulation

This section establishes a mixed-integer linear programming (MILP) model for the integrated scheduling problem of Earth observation satellite imaging and data transmission. The notations used for parameters in the proposed MILP model are presented in

Table 2. Notation of parameters for the proposed MILP model.

Parameters	Definition
S	Satellite Collection
G	Ground station set
T	Task Set
M	Number of Tasks
$O_k$	The orbit Set of satellite k
$tim{e}_i$	Execution time of imaging task i
$sl{t}_{i,j,k}$	The time required for satellite k to complete the transition to task j after finishing task i
$c_i$	The benefit value of task i
$g_{i,k}$	The side view angle of satellite k performing task i
$max{g}_i$	The maximum side view angle of target i
$Energ{y}_k$	The energy limit for a single activation of satellite k
$Memor{y}_k$	The maximum storage capacity of satellite k
$m\_uni{t}_{k,0/1}$	The data generated or freed by satellite k per unit time
$e\_uni{t}_{k,0/1}$	Energy consumed per second for satellite imaging or data transmission
$time{d}_i$	The time at which task j is transmitted from the satellite to the ground station
$w{s}_{j,m,k}$	The start time of the time window for task j executed by satellite k at orbit m
$w{e}_{j,m,k}$	The end time of the time window for task j executed by satellite k at orbit m
$ws{d}_{j,m,k}$	Start of the time window for ground stations in satellite k-orbit m
$we{d}_{j,m,k}$	End of the time window for ground stations in satellite k-orbit m
$slewt{s}_i$	Transition time between two adjacent communication tasks at Earth station i
$slewt{g}_i$	Transition time between two adjacent communication tasks at Earth satellite i

, and the decision variables of the MILP model are shown in

Table 3. Notation of decision variables for the proposed MILP model.

Decision Variables	Definition
$g_{j,n,k}$	Whether the ground station j communicates with the satellite k in the nth orbit
$x_{i,m,k}$	Whether target i is observed in the mth orbit of satellite k
$y_{i,j,n,k}$	Whether target i transmitted at ground station j through the nth orbit of satellite k
$x\_tim{e}_{i,k}$	Observation time of target i on satellite k
$x\_star{t}_{i,k}$	Observation start time of target I on Satel-lite K
$x\_en{d}_{i,k}$	Observation end time of target I on Satel-lite K
$g\_tim{e}_{j,n,k}$	Communication time of ground station j with the satellite k in the nth orbit
$g\_en{d}_{j,n,k}$	Communication end time of ground sta-tion j with the satellite k in the nth orbit
$g\_star{t}_{j,n,k}$	Communication start time of ground sta-tion j with the satellite k in the nth orbit
$z{1}_{i1,i2,k}$	The sequence of targets i1 and i2 observed on satellite k
$z1a_{i,j,n,k}$	The end time of data transmission task i executed by satellite k and ground station m
$z1b_{i,j,n,k}$	The end time of data transmission task i executed by satellite k and ground station m
$z1c_{j1,n1,j2,n2,k}$	The sequence of ground j1 at n1th and ground j2 at n2th orbit on satellite k
$z{2}_{n1,k1,n2,k2,j}$	The sequence of satellite k1 at n1th and satellite k2 at n2th orbit on station j
$p_{i1,i2,k}$	Capacity consumed when observing target i1 before target i2 on satellite k
$p{a}_{i,j,n,k}$	Capacity consumed when observing target i before station j with orbit n on satellite k
$p{b}_{i,j,n,k}$	Capacity released when observing target i after station j with orbit n on satellite k
$p{c}_{j1,n1,j2,n2,k}$	Capacity released when observing station j1 with orbit n1 before station j2 with orbit n2 on satellite k
$px\_storag{e}_{i,k}$	Satellite storage when observing target i
$pg\_storag{e}_{j,n,k}$	Satellite storage when communicating with station j at orbit n

.

$$max\sum _{i,m,k}{x}_{i,m,k}{c}_i$$

(1)

$$\begin{array}{c}{\sum }_{k\in S}^{m\in O_k}{x}_{i,m,k}\le 1\end{array}$$

(2)

$$\begin{array}{c}{\sum }_{j\in G}^{n\in O_k}{y}_{i,j,n,k}=\sum _{m\in O_k}{x}_{i,m,k}\end{array}$$

(3)

$$\begin{array}{c}{\sum }_{i\in T}{y}_{i,j,n,k}⩽g_{j,n,k}\ast M\end{array}$$

(4)

$$\begin{array}{c}x\_tim{e}_{i,k}={\sum }_{m\in O_k}{x}_{i,m,k}\ast tim{e}_i\end{array}$$

(5)

$$\begin{array}{c}g\_tim{e}_{j,n,k}={\sum }_{i\in T}{y}_{i,j,n,k}\ast time{d}_i\end{array}$$

(6)

$$\begin{array}{c}x\_en{d}_{i,k}⩽{\sum }_{m\in O_k}{x}_{i,m,k}\ast we{t}_{i,m,k}\end{array}$$

(7)

$$\begin{array}{c}x\_star{t}_{i,k}⩾{\sum }_{m\in O_k}{x}_{i,m,k}\ast ws{t}_{i,m,k}\end{array}$$

(8)

$$\begin{array}{c}x\_en{d}_{i,k}=x\_star{t}_{i,k}+x\_tim{e}_{i,k}\end{array}$$

(9)

$$\begin{array}{c}g\_en{d}_{j,n,k}⩽g_{j,n,k}\ast we{g}_{j,n,k}\end{array}$$

(10)

$$\begin{array}{c}g\_star{t}_{j,n,k}⩾g_{j,n,k}\ast ws{g}_{j,n,k}\end{array}$$

(11)

$$\begin{array}{c}g\_en{d}_{j,n,k}=g\_star{t}_{j,n,k}+g\_tim{e}_{j,n,k}\end{array}$$

(12)

$$\begin{array}{c}z{1}_{i1,i2,k}⩽{\sum }_{m\in O_k}{x}_{i1,m,k}\end{array}$$

(13)

$$\begin{array}{c}z{1}_{i1,i2,k}⩽{\sum }_{m\in O_k}{x}_{i2,m,k}\end{array}$$

(14)

$$\begin{array}{c}z1a_{i,j,n,k}⩽{\sum }_{m\in O_k}{x}_{i,m,k}\end{array}$$

(15)

$$\begin{array}{c}z1a_{i,j,n,k}⩽g_{j,n,k}\end{array}$$

(16)

$$\begin{array}{c}z1b_{i,j,n,k}⩽{\sum }_{m\in O_k}{x}_{i,m,k}\end{array}$$

(17)

$$\begin{array}{c}z1b_{i,j,n,k}⩽g_{j,n,k}\end{array}$$

(18)

$$\begin{array}{c}z1c_{j1,n1,j2,n2,k}⩽g_{j1,n1,k}\end{array}$$

(19)

$$\begin{array}{c}z1c_{j1,n1,j2,n2,k}⩽g_{j2,n2,k}\end{array}$$

(20)

$$\begin{array}{c}z1a_{i,j,n,k}⩾y_{i,j,n,k}\end{array}$$

(21)

$$\begin{array}{c}{y}_{i,j,n,k}=1\Rightarrow x\_en{d}_{i,k}-g\_star{t}_{j,n,k}⩽0\end{array}$$

(22)

$$\begin{array}{c}{\sum }_{m\in O_k}{x}_{i1,m,k}=1\Rightarrow (z{1}_{i1,i2,k}-1)\ast M+x\_en{d}_{i1,k}-g\_star{t}_{i2,k}<0\end{array}$$

(23)

$$\begin{array}{c}{\sum }_{m\in O_k}{x}_{i1,m,k}=1\Rightarrow (z{1}_{i1,i2,k}-1)\ast M+x\_en{d}_{i1,k}-g\_star{t}_{i2,k}⩾-M\end{array}$$

(24)

$$\begin{array}{c}{\sum }_{m\in O_k}{x}_{i1,m,k}=1\Rightarrow (z1a_{i,j,n,k}-1)\ast M+x\_en{d}_{i,k}-g\_star{t}_{j,n,k}<0\end{array}$$

(25)

$$\begin{array}{c}{\sum }_{m\in O_k}{x}_{i1,m,k}=1\Rightarrow (z1a_{i,j,n,k}-1)\ast M+x\_en{d}_{i,k}-g\_star{t}_{j,n,k}⩾-M\end{array}$$

(26)

$$\begin{array}{c}{g}_{j,n2,k}=1\Rightarrow (z1b_{i,j,n,k}-1)\ast M+g\_en{d}_{j,n,k}-x\_star{t}_{i,k}<0\end{array}$$

(27)

$$\begin{array}{c}{g}_{j,n2,k}=1\Rightarrow (z1b_{i,j,n,k}-1)\ast M+g\_en{d}_{j,n,k}-x\_star{t}_{i,k}⩾-M\end{array}$$

(28)

$$\begin{array}{c}{g}_{j1,n1,k}=1\Rightarrow (z1c_{j1,n1,j2,n2,k}-1)\ast M+x\_en{d}_{j1,n1,k}-g\_star{t}_{j1,n1,k}<0\end{array}$$

(29)

$$\begin{array}{c}{g}_{j1,n1,k}=1\Rightarrow (z1c_{j1,n1,j2,n2,k}-1)\ast M+x\_en{d}_{j1,n1,k}-g\_star{t}_{j1,n1,k}⩾-M\end{array}$$

(30)

$$\begin{array}{c}{\sum }_{m\in O_k}{x}_{i1,m,k}+{\sum }_{m\in O_k}{x}_{i2,m,k}-z{1}_{i1,i2,k}-z{1}_{i2,i1,k}<=1\end{array}$$

(31)

$$\begin{array}{c}{g}_{j1,n1,k}+g_{j1,n1,k}-z1c_{j1,n1,j2,n2,k}-z1c_{j2,n2,j1,n1,k}<=1\end{array}$$

(32)

$$\begin{array}{c}z{1}_{i1,i2,k}=1\Rightarrow p_{i1,i2,k}=(x\_tim{e}_{i1,k})\ast m\_uni{t}_{k,0}\end{array}$$

(33)

$$\begin{array}{c}z{1}_{i1,i2,k}=0\Rightarrow p_{i1,i2,k}=0\end{array}$$

(34)

$$\begin{array}{c}z1a_{i,j,n,k}=1\Rightarrow p{a}_{i,j,n,k}=(x\_tim{e}_{i,k})\ast m\_uni{t}_{k,0}\end{array}$$

(35)

$$\begin{array}{c}z1a_{i,j,n,k}=0\Rightarrow p{a}_{i,j,n,k}=0\end{array}$$

(36)

$$\begin{array}{c}z1b_{i,j,n,k}=1\Rightarrow p{b}_{i,j,n,k}=(g\_tim{e}_{j,n,k})\ast m\_uni{t}_{k,1}\end{array}$$

(37)

$$\begin{array}{c}z1b_{i,j,n,k}=0\Rightarrow p{b}_{i,j,n,k}=0\end{array}$$

(38)

$$\begin{array}{c}z1c_{j1,n1,j2,n2,k}=1\Rightarrow p{c}_{j1,n1,j2,n2,k}=(g\_tim{e}_{j1,n1,k})\ast m\_uni{t}_{k,1}\end{array}$$

(39)

$$\begin{array}{c}z1c_{j1,n1,j2,n2,k}=0\Rightarrow p{c}_{j1,n1,j2,n2,k}=0\end{array}$$

(40)

$$\begin{array}{c}z{2}_{n1,k1,n2,k2,j}⩽g_{j,n1,k1}\end{array}$$

(41)

$$\begin{array}{c}z{2}_{n1,k1,n2,k2,j}⩽g_{j,n2,k2}\end{array}$$

(42)

$$\begin{array}{c}{g}_{j,n1,k1}=1\Rightarrow (z{2}_{n1,k1,n2,k2,j}-1)\ast M+g\_en{d}_{j,n1,k1}-g\_star{t}_{j,n2,k2}<0\end{array}$$

(43)

$$\begin{array}{c}{g}_{j,n1,k1}=1\Rightarrow (z{2}_{m,k1,n,k2,i}-1)\ast M+g\_en{d}_{i,m,k1}-g\_star{t}_{i,n,k2}⩾-M\end{array}$$

(44)

$$\begin{array}{c}{g}_{j,n1,k1}+g_{j,n2,k2}-z{2}_{n1,k1,n2,k2,j}-z{2}_{n2,k2,n1,k1,j}<=1\end{array}$$

(45)

$$\begin{array}{c}(1-z{2}_{n1,k1,n2,k2,j})\ast M+g\_star{t}_{j,n2,k2}-g\_en{d}_{j,n1,k1}⩾slewt{g}_j\end{array}$$

(46)

$$\begin{array}{c}(1-z1c_{j1,n1,j2,n2,k})\ast M+g\_star{t}_{j1,n2,k}-g\_en{d}_{j2,n2,k}⩾slewt{s}_k\end{array}$$

(47)

$$\begin{array}{c}(1-z{1}_{i1,i2,k})\ast M+x\_star{t}_{i2,k}-x\_en{d}_{i1,k}⩾sl{t}_{i1,i2,k}\end{array}$$

(48)

$$\begin{array}{c}px\_storag{e}_{i,k}={\sum }_{i1}{p}_{i1,i,k}+{\sum }_{j\in G,n\in O_k}^{p{b}_{i,j,n,k}}\end{array}$$

(49)

$$\begin{array}{c}pg\_storag{e}_{j,n,k}={\sum }_{i}p{a}_{i,j,n,k}+{\sum }_{j1\in G,n1\in O_k}^{p{c}_{j1,n1,j,n,k}}\end{array}$$

(50)

$$\begin{array}{c}px\_storag{e}_{i,k}+(x\_en{d}_{i,k}-x\_star{t}_{i,k})\ast m\_uni{t}_{k,0}⩾0\end{array}$$

(51)

$$\begin{array}{c}pg\_storag{e}_{j,n,k}+(g\_en{d}_{j,n,k}-g\_star{t}_{j,n,k})\ast m\_uni{t}_{k,1}⩾0\end{array}$$

(52)

$$\begin{array}{c}px\_storag{e}_{i,k}+(x\_en{d}_{i,k}-x\_star{t}_{i,k})\ast m\_uni{t}_{k,0}⩽Memor{y}_k\end{array}$$

(53)

$$\begin{array}{c}pg\_storag{e}_{j,n,k}+(g\_en{d}_{j,n,k}-g\_star{t}_{j,n,k})\ast m\_uni{t}_{k,1}⩽Memor{y}_k\end{array}$$

(54)

$$\begin{array}{c}{\sum }_{i\in T}x\_tim{e}_{i,k}\ast e\_uni{t}_{k,0}+{\sum }_{i\in G,m\in O_k}g\_tim{e}_{i,m,k}\ast e\_uni{t}_{k,1}⩽Energ{y}_k\end{array}$$

(55)

$$\begin{array}{c}{x}_{i,m,k}\in \{0,1\}\end{array}$$

(56)

$$\begin{array}{c}{y}_{i,j,n,k}\in \{0,1\}\end{array}$$

(57)

$$\begin{array}{c}{g}_{j,n,k}\in \{0,1\}\end{array}$$

(58)

Equation (1) is the Objective function, aiming to maximize task benefits. Equation (2) describes the task execution count constraints. Equations (3) and (4) describe the tasking relationship constraints. Equation (5) represents the observation mission time constraints. Equation (6) indicates the data transmission time constraint. Equations (7)–(9) indicate the observation mission time window constraints.

Equations (10)–(12) indicate the time Window Constraints for data transmission Tasks. Equations (13) and (14) represent the constraints on the order of observational tasks. Equations (15)–(18) represent the Observation and data transmission task sequencing constraints. Equations (19) and (20) represent the sequential relationship constraints for on-planet data transmission tasks. Equation (21) indicates the logical relationship between target digitizing assignments and imaging digitizing sequential relationships. Equation (22) indicates the logical relationship between the distribution of target passes and the start and end times of missions.

Equations (23) and (24) indicate the relationship between imaging tasks’ order and start and finish times. Equations (25)–(28) indicate the relationship between imaging and data transmission tasks sequencing and tasks’ start and finish times. Equations (29) and (30) indicate the relationship between the sequence of digital transmission missions on satellites and the start and end times of missions. Equations (31) and (32) indicate that similar missions on satellites may not be carried out simultaneously. Equations (33)–(40) indicate the relationship between the capacity utilization of on-planet tasks and task sequencing.

Equations (41) and (42) indicate the sequencing of tasks at Earth stations. Equations (43)–(45) indicate the relationship between the sequence of data transmission tasks on ground stations and the start and end times of the tasks. Equation (46) indicates the attitude transition time constraints between ground station data transmission missions. Equation (47) indicates the attitude transition time constraints between digital transmission missions on satellites. Equation (48) indicates the attitude transition time constraints between imaging missions on satellites. Equations (49)–(54) indicate the satellite fixed storage capacity constraint. Equation (55) indicates the energy constraint for satellites.

3. CPLEX CP Solver Solution

3.1. CPLEX Solver

CPLEX is a high-performance mathematical optimization solver developed by IBM, widely used in operations research, management science, and engineering fields. It supports modeling and solving various types of problems, including linear programming (LP), integer programming (IP), mixed-integer programming (MIP), and quadratic programming (QP/QCP).

The constraint programming module (Constraint Programming, CP) of CPLEX is one of its important extensions, focusing on solving combinatorial optimization problems with complex logical constraints. Compared to traditional mathematical programming methods, the CP solver is based on constraint propagation and backtracking search mechanisms, allowing for flexible definition and constraint of relationships between variables, and quickly finding optimal or approximate solutions through an automatic solver. This feature makes CPLEX particularly outstanding in fields such as scheduling problems, resource allocation, and logic puzzles.

3.2. MILP Model

In order to test the validity of the model presented in the previous section, this study implements this mixed-integer linear programming model through the opl language of the Cplex solver and implements the CP model form of the model using variables and constraints specific to Cplex’s CP solver.

3.2.1. Using CPLEX Solver

• dvar boolean x[i in tasks][k in satellites][m in orbits];
• dvar boolean g[j in stations][k in satellites][n in orbits];
• dvar int x_time[i in tasks][k in satellites];
• dvar int g_time[i in stations][k in satellites][m in orbits];
• dvar boolean y[i in tasks][j in stations][k in satellites][n in orbits];
• dvar boolean za[i in tasks][j in stations][k in satellites][n in orbits];
• dvar boolean zb[i in tasks][j in stations][k in satellites][n in orbits];
• dvar boolean z1[i1 in tasks][i2 in tasks][k in satellites];
• dvar boolean z1c[k in satellites][j1 in stations][n1 in orbits][j2 in stations][n2 in orbits];
• dvar boolean z2[j in stations][k1 in satellites][m in orbits][k2 in satellites][n in orbits];
• dvar int+ x_start[i in tasks][k in satellites];
• dvar int+ x_end[i in tasks][k in satellites];
• dvar int+ g_start[i in stations][k in satellites][m in orbits];
• dvar int+ g_end[i in stations][k in satellites][m in orbits];
• dvar float+ ux[tasks,satellites];
• dvar float+ ug[stations,satellites,orbits];
• dvar float pg[k in satellites][j1 in stations][n1 in orbits][j2 in stations][n2 in orbits];
• dvar float px[i1 in tasks][i2 in tasks][k in satellites];
• dvar float pxga[i1 in tasks][j2 in stations][k in satellites][n2 in orbits];
• dvar float pxgb[i1 in tasks][j2 in stations][k in satellites][n2 in orbits];
• maximize sum(j in tasks, m in orbits ,k in satellites)(profit[j] *x[j][k][m]);
• subject to {
• forall(i in tasks)
• sum(m in orbits ,k in satellites) x[i][k][m]<=1;
• forall(i in tasks, k in satellites){
• sum(n in orbits, j in stations) y[i][j][k][n]==sum(m in orbits) x[i][k][m];}
• forall(n in orbits, j in stations, k in satellites){
• sum(i in tasks) y[i][j][k][n] <= g[j][k][n]*tasknum;}
• forall(i in tasks,k in satellites){
• x_time[i][k]==sum(m in orbits)x[i][k][m]*duration[i];}
• forall(j in stations, n in orbits,k in satellites){
• g_time[j][k][n]==sum(i in tasks)y[i][j][k][n]*utime[i];}
• forall(i in tasks, k in satellites){
• x_start[i][k]>=sum(m in orbits)x[i][k][m]*wst[i][k][m];
• x_end[i][k]<=sum(m in orbits)x[i][k][m]*wet[i][k][m];
• x_end[i][k]==x_start[i][k]+x_time[i][k];}
• forall(j in stations, n in orbits,k in satellites){
• g_end[j][k][n]==g_start[j][k][n]+g_time[j][k][n];
• g_start[j][k][n]>=g[j][k][n]*wsg[j][k][n];
• g_end[j][k][n]<=g[j][k][n]*weg[j][k][n];}
• forall(i1 in tasks,i2 in tasks, k in satellites: i1 != i2){
• z1[i1][i2][k]<=sum(m in orbits)x[i1][k][m];
• z1[i1][i2][k]<=sum(m in orbits)x[i2][k][m];
• sum(m in orbits)x[i1][k][m]+sum(m in orbits)x[i2][k][m]
• -z1[i1][i2][k]-z1[i2][i1][k]<=1;}
• forall(i in stations,m in orbits,k in satellites)
• forall(j in stations, n in orbits: <i,m> != <j,n>){
• z1c[k][i][m][j][n]<=g[i][k][m];
• z1c[k][i][m][j][n]<=g[j][k][n];
• g[i][k][m]+g[j][k][n]-z1c[k][i][m][j][n]-z1c[k][j][n][i][m]<=1;}
• forall(i1 in tasks, k in satellites)
• forall(j in stations, n in orbits){
• za[i1][j][k][n]<=sum(m in orbits)x[i1][k][m];
• za[i1][j][k][n]<=g[j][k][n];
• zb[i1][j][k][n]<=sum(m in orbits)x[i1][k][m];
• zb[i1][j][k][n]<=g[j][k][n];}
• forall(i1 in tasks, k in satellites)
• forall(j in stations, n in orbits){
• za[i1][j][k][n]>=y[i1][j][k][n];}
• forall(i in tasks, k in satellites)
• forall(j in tasks){
• (x_end[i][k]-x_start[j][k]<=s && sum(m in orbits)x[i][k][m]==1)=>(z1[i][j][k]==1);
• (x_end[i][k]-x_start[j][k]>=0 && sum(m in orbits)x[i][k][m]==1)=>(z1[i][j][k]==0);}
• forall(i in tasks, k in satellites)
• forall(j in stations, n in orbits){
• (x_end[i][k]-g_start[j][k][n]<=s &&
• sum(m in orbits)x[i][k][m]==1)=>(za[i][j][k][n]==1);
• (x_end[i][k]-g_start[j][k][n]>=0 &&
• sum(m in orbits)x[i][k][m]==1)=>(za[i][j][k][n]==0);
• (g_end[j][k][n]-x_start[i][k]<=s && g[j][k][n]==1)=>(zb[i][j][k][n]==1);
• (g_end[j][k][n]-x_start[i][k]>=0 && g[j][k][n]==1)=>(zb[i][j][k][n]==0);}
• forall(i in stations,m in orbits, k in satellites)
• forall(j in stations, n in orbits){
• (g_end[i][k][m]-g_start[j][k][n]<=s && g[i][k][m]==1)=>(z1c[k][i][m][j][n]==1);
• (g_end[i][k][m]-g_start[j][k][n]>=0 && g[i][k][m]==1)=>(z1c[k][i][m][j][n]==0);}
• forall(i in stations, m in orbits,k in satellites)
• forall(j in stations, n in orbits){
• (z1c[k][i][m][j][n]==1)=>(pg[k][i][m][j][n]==g_time[i][k][m]*umemory[k][1]);
• (z1c[k][i][m][j][n]==0)=>(pg[k][i][m][j][n]==0);}
• forall(i in tasks, k in satellites)
• forall(j in tasks){
• (z1[i][j][k]==1)=>(px[i][j][k]==x_time[i][k]*umemory[k][0]);
• (z1[i][j][k]==0)=>(px[i][j][k]==0);}
• forall(i in tasks, k in satellites)
• forall(j in stations, n in orbits){
• (za[i][j][k][n]==1)=>(pxga[i][j][k][n]==x_time[i][k]*umemory[k][0]);
• (za[i][j][k][n]==0)=>(pxga[i][j][k][n]==0);
• (zb[i][j][k][n]==1)=>(pxgb[i][j][k][n]==g_time[j][k][n]*umemory[k][1]);
• (zb[i][j][k][n]==0)=>(pxgb[i][j][k][n]==0);}
• forall(i in tasks,k in satellites){
• ux[i][k]==(sum(j in tasks) px[j][i][k])-
• (sum(j in stations, m in orbits) pxgb[i][j][k][m])+x_time[i][k]*umemory[k][0];
• ux[i][k]<=memory[k];
• ux[i][k]>=0;}
• forall(i in stations, m in orbits,k in satellites){
• ug[i][k][m]==(sum(j in tasks) pxga[j][i][k][m])-
• (sum(j in stations, m1 in orbits)pg[k][j][m1][i][m])-g_time[i][k][m]*umemory[k][1];
• ug[i][k][m]<=memory[k];
• ug[i][k][m]>=0;}
• forall(i in stations,m in orbits,k1 in satellites)
• forall(k2 in satellites, n in orbits:k1!=k2){
• z2[i][k1][m][k2][n]<=g[i][k1][m];
• z2[i][k1][m][k2][n]<=g[i][k2][n];
• g[i][k1][m]+g[i][k2][n]-z2[i][k1][m][k2][n]-z2[i][k2][n][k1][m]<=1;}
• forall(i in stations,m in orbits, k1 in satellites)
• forall(k2 in satellites, n in orbits){
• (g_end[i][k1][m]-g_start[i][k2][n]>=0 && g[i][k1][m]==1)=>(z2[i][k1][m][k2][n]==0);
• (g_end[i][k1][m]-g_start[i][k2][n]<=s && g[i][k1][m]==1)=>(z2[i][k1][m][k2][n]==1);}
• forall(i in stations,m in orbits,k1 in satellites)
• forall(k2 in satellites, n in orbits){
• (z2[i][k1][m][k2][n]==1)=>(g_start[i][k2][n]-g_end[i][k1][m]>=slewt[i]);}
• forall(i in stations,m in orbits,k in satellites)
• forall(j in stations, n in orbits){
• (z1c[k][i][m][j][n]==1)=>(g_start[j][k][n]-g_end[i][k][m]>=slewtime1[k]);}
• forall(i in tasks, k in satellites)
• forall(j in tasks){
• (z1[i][j][k]==1)=>(x_start[j][k]-x_end[i][k]>=slewtime[i][j][k]);}
• forall(k in satellites){
• sum(i in tasks)((x_time[i][k])*uenergy[k][0])+
• sum(i in stations, m in orbits)((g_time[i][k][m])*uenergy[k][1])<=energy[k];}
• }

3.2.2. Using CP Solver

In the CPLEX constraint programming solver, for time window constraints, “interval” and “sequence” data types can be used to describe time windows and sequences of time windows. The “noOverlap” function can be employed to ensure that the execution times of tasks on the same satellite do not overlap, as well as to impose constraints on attitude transition times.

• dvar boolean x[i in tasks][k in satellites][m in orbits];
• dvar boolean y[i in tasks][j in stations][k in satellites][n in orbits];
• dvar interval x_val[j in tasks][k in satellites] optional size duration[j];
• dvar interval g_val[i in stations][k in satellites][m in orbits] optional in wsg[i][k][m]..weg[i][k][m];
• dvar interval y_val[i in tasks][j in stations][k in satellites][m in orbits] optional size utime[i];
• dvar sequence x_seq[k in satellites] in all (j in tasks) x_val[j][k];
• dvar sequence y_seq[k in satellites] in all (i in tasks, j in stations, m in orbits) y_val[i][j][k][m];
• dvar sequence g_seq[j in stations] in all (i in tasks, m in orbits, k in satellites) y_val[i][j][k][m];
• dvar sequence d_seq[j in stations] in all (m in orbits, k in satellites) g_val[j][k][m];
• cumulFunction storageUsage[k in satellites] =
• sum(i in tasks) stepAtStart(x_val[i][k], umemory[k][1] * duration[i])
• - sum(j in stations, i in tasks, m in orbits) stepAtStart(y_val[i][j][k][m],
• umemory[k][2] * utime[i]);
• cumulFunction energyUsage[k in satellites] =
• sum(i in tasks) stepAtStart(x_val[i][k], uenergy[k][1] * duration[i])
• + sum(j in stations, i in tasks, m in orbits) stepAtStart(y_val[i][j][k][m],
• uenergy[k][2] * utime[i]);
• maximize sum(j in tasks, m in orbits ,k in satellites) (profit[j] *x[j][k][m]);
• subject to {
• forall(i in tasks){
• sum(m in orbits ,k in satellites) x[i][k][m] <= 1;}
• forall(i in tasks){
• sum(n in orbits, j in stations, k in satellites) y[i][j][k][n] <= 1;}
• forall(i in tasks, k in satellites){
• sum(n in orbits, j in stations) y[i][j][k][n] >= sum(m in orbits) x[i][k][m];}
• forall(i in tasks, j in stations, m in orbits, k in satellites){
• y[i][j][k][m] == presenceOf(y_val[i][j][k][m]);}
• forall(i in tasks,k in satellites){
• sum(m in orbits)x[i][k][m] == presenceOf(x_val[i][k]);}
• forall(i in tasks, k in satellites){
• startOf(x_val[i][k])>=sum(m in orbits)x[i][k][m]*wst[i][k][m];
• endOf(x_val[i][k])<=sum(m in orbits)x[i][k][m]*wet[i][k][m];}
• forall(i in tasks, j in stations, m in orbits, k in satellites){
• endBeforeStart(x_val[i][k], y_val[i][j][k][m]);
• (y[i][j][k][m] == 1) => ( endOf(x_val[i][k]) <= startOf(g_val[j][k][m]) );}
• forall(j in stations, m in orbits, k in satellites)
• span(g_val[j][k][m], all(i in tasks) y_val[i][j][k][m]);
• forall(k in satellites) storageUsage[k] <= memory[k];
• forall(k in satellites) energyUsage[k] <= energy[k];
• forall(k in satellites) noOverlap(y_seq[k]);
• forall(j in stations) noOverlap(g_seq[j]);
• forall(j in stations) noOverlap(d_seq[j]);
• forall(k in satellites) noOverlap(x_seq[k], Setup[k]);
• forall(k in satellites){
• forall(j1 in stations, m1 in orbits, j2 in stations, m2 in orbits : j1 != j2){
• (presenceOf(g_val[j1][k][m1]) && presenceOf(g_val[j2][k][m2])) =>
•  abs(endOf(g_val[j1][k][m1])-startOf(g_val[j2][k][m2])) >= slewtime1[k];
• (presenceOf(g_val[j1][k][m1]) && presenceOf(g_val[j2][k][m2])) =>
•  abs(endOf(g_val[j2][k][m2])-startOf(g_val[j1][k][m1])) >= slewtime1[k];}}
• forall(j in stations){
• forall(k1 in satellites, m1 in orbits, k2 in satellites, m2 in orbits : k1 != k2){
• (presenceOf(g_val[j][k1][m1]) && presenceOf(g_val[j][k2][m2])) =>
•  abs(endOf(g_val[j][k1][m1])-startOf(g_val[j][k2][m2])) >= slewt[j];
• (presenceOf(g_val[j][k1][m1]) && presenceOf(g_val[j][k2][m2])) =>
•  abs(endOf(g_val[j][k2][m2])-startOf(g_val[j][k1][m1])) >= slewt[j];}}
• }

By utilizing the special variable types and built-in constraint functions of the CP solver, it is possible to model the original mixed-integer linear programming problem conveniently and solve it conveniently using the solver.

4. Rule-Based Large Neighborhood Search Algorithm (RLNS)

The solution space of this problem is vast, and due to the presence of various constraints, the feasible region of the solutions is highly complex. Traditional exact solving methods struggle to address such problems; therefore, it is necessary to design heuristic algorithms, and a Rule-based Large Neighborhood Search algorithm (RLNS) is designed.

4.1. Algorithm Description

Since the problem itself involves multiple levels of task allocation and scheduling of task execution time, when defining the solution to the problem, both task allocation and the scheduling of start times are treated as variables.

Due to the complex logical constraints of the problem, it is necessary to design different neighborhood operators for different levels of the problem. For various neighborhood operators, a roulette wheel-based operator selection method is employed, and the operator scores are updated in each iteration to continuously adjust the selection probabilities of the operators, thereby enhancing the convergence of the algorithm.

4.2. Heuristic Rules and Various Operators

The implementation of this search algorithm relies on various heuristic rules and forms multiple types of operators based on these rules.

4.2.1. Construction of the Initial Solution

Based on the random allocation scheme for satellites and ground stations, the initial solution construction operator is designed according to the start time of the time window and suitable timing, following the precedence rules for scheduling, which is shown in Figure 2.

4.2.2. Task Allocation Random Perturbation Operator

Task allocation random disturbance operator is based on the taboo degree table. For the allocation matrix of targets to satellites and ground stations, a simple approach is to compare the initial allocation matrix with the final allocation matrix after conflict resolution. A taboo value is set for the allocation methods of targets that have been canceled after conflict resolution, in order to avoid such allocations as much as possible. The taboo values used here are not binary (0–1), but numerical. Each time when allocating satellites and ground stations to each target, the allocation scheme with the smallest taboo value is preferentially selected. As shown in Algorithm 1.

Algorithm 1 Task Allocation Disturbance

Require: Task Allocation Matrix: $matrix\_x$, Taboo List: $task\_taboo$ Ensure: new Task Allocation Matrix: $matrix\_x$  1: while $size\_of(task\_indexs)\le m$ do  2:       $task\_index\leftarrow dis\left(\right)$  3:       $task\_indexs.push\_back(task\_index)$  4: end while  5: while $i\le m$ do  6:       $new\_sat\_index\leftarrow select\_posion\_with\_taboo(task\_taboo)$  7:       $matrix\_x[task\_indexs[i\left]\right][new\_sat\_index]\leftarrow 1$  8:       $matrix\_x[task\_indexs[i\left]\right][sat\_index]\leftarrow 0$  9: end while

4.2.3. Random Perturbation Operator for Observation Task Sequences

Observation Task Sequence Random Perturbation Operators: In situations where it is necessary to adjust the execution order of satellite observation tasks, operators for swapping and deleting-inserting have been designed. These operators can swap the execution order of two tasks in the queue or remove a task’s execution order from the queue and then simply insert it at the beginning or end of the queue. Before executing the perturbation operators, it is important to reinsert any tasks that were not successfully executed at the end of the sequence to avoid the perturbation of the sequence from failing to find a better task sequence. As shown in Algorithm 2.

Algorithm 2 Sequence Perturbation

Require: Observation Tasks Sequences: $sequences$ Ensure: new Observation Tasks Sequences: $sequences$       $num\leftarrow dis\left(\right)\%size\_of\left(sequences\right)$  2: while $i\le num$ do       $idx1\leftarrow dis\left(\right),idx2\leftarrow dis\left(\right)$  4:       $swap\left(sequences\right[idx1],sequence[idx2\left]\right)$ end while

4.2.4. Observation Task Scheduling Operator Based on Target Allocation Scheme

The Observation Task Scheduling Operator is based on the target allocation scheme. Once the allocation scheme for observation targets is known, the scheduling of task start and end times is carried out according to the rule of observing targets in the order of their arrival, as shown in Algorithm 3. In this algorithm, there are many customized symbols, and the meanings are as follows: the timenode is a structure that stores the corresponding mission and satellite numbers for each time window, with the window start time being wst and the end time being wet, which means that i.wst means the wst of timewindow i; is_scheduled is a 0–1 array of the size of the number of tasks to record whether each task has been successfully scheduled during the scheduling process.

Algorithm 3 Observation Task Scheduling
Require: Observation Tasks Allocations: $matrix\_x$
Ensure: Observation Tasks Scheduling Scheme: $is\_scheduled$	▹ also contains other
informations such as starttime, endtime et al.        if $matrix\_x==1$ then        $timeNodes.push\_back\left(timenode\right)$  3: end if $sort(timeNodes.begin(),timeNodes.end(\left)\right)$ $is\_scheduled\left[\right]\leftarrow 0$  6: while $i\le size\_of\left(timeNodes\right)$ do      if $timeNodes\left[i\right].endtime>temptime$ && $is\_scheduled\left[timeNodes\right[i].task]\ne 1$ then            $x\_start\left[timeNodes\right[i].task]\leftarrow max\left\{timeNodes\right[i].endtime,temptime+slewtime\}$  9:            $temptime\leftarrow x\_end\left[timeNodes\right[i].task]$            $is\_scheduled\left[timeNodes\right[i].task]\leftarrow 1$      end if 12: end while

4.2.5. Onboard Data First-Come-First-Served Transmission Operator

An on-orbit data transmission tasks scheduling operator is based on the target data transmission allocation scheme and the observation task scheduling results: after determining the allocation scheme for the target ground station, the satellite observation task scheduling results are combined to downlink satellite data according to the first-come, first-served rule, while satisfying the logical constraints of observation and data transmission. When determining the transmission time for each data transmission opportunity, the observation end time of the corresponding targets that have been observed but not yet transmitted is used to sequentially select the targets that need to be transmitted, ensuring that the difference between the end time of the time window and the start time of the transmission does not exceed the specified limit, as shown in Algorithm 4.

Algorithm 4 Observation Task Scheduling
Require: Transmission Tasks Allocations: $matrix\_y$
Ensure: Transmission Tasks Scheduling Scheme: $is\_downloaded$	▹ also contains other
informations such as starttime, endtime et al.     if $matrix\_y==1$ then         $timeNodes.push\_back\left(timenode\right)$     end if  4: $sort(timeNodes.begin(),timeNodes.end(\left)\right)$ $is\_scheduled\left[\right]\leftarrow 0$ while $i\le size\_of\left(timeNodes\right)$ do       if $timeNodes\left[i\right].endtime>sat\_temptime$ && $timeNodes\left[i\right].endtime>sta\_temptime$ then  8:          $g\_start\left[timeNodes\right[i].sta]\hspace{1em} \leftarrow \hspace{1em} max\left\{timeNodes\right[i].endtime,sat\_temptime +$ $sat\_slewtime,sta\_temptime+sta\_slewtime\}$          while $duration\le max\_duration$ && $j\le n$ do                if $x\_end\left[j\right]>temptime$ && $is\_downloaded\left[j\right]\ne 1$ then                   $duration\leftarrow duration+dtime\left[j\right]$ 12:                   $is\_downloaded\left[timeNodes\right[i].task]\leftarrow 1$                end if          end while          $sat\_temptime\leftarrow g\_end\left[timeNodes\right[i].sat]$ 16:          $sta\_temptime\leftarrow g\_end\left[timeNodes\right[i].sta]$       end if end while

4.2.6. Sequence-Based Observation Tasks Scheduling Algorithm

The observation tasks scheduling operator is based on task sequences: after perturbing the task sequence, it is necessary to arrange the start and end times of observation tasks according to the new task sequence. When scheduling the times, the observation tasks are arranged in the order of execution, and for each task, the start time of the observation is scheduled according to the arrival order of the time windows, while ensuring that the observation tasks do not overlap, as shown in Figure 3.

4.2.7. Repair Algorithms Based on Onboard Capacity Constraints and Satellite Energy Constraints

The Repair Operator is based on onboard capacity constraints and satellite energy constraints: after completing the task scheduling scheme for the satellite and ground station, it is also necessary to calculate the fixed capacity limitations of the satellite while performing observation tasks. If there are task schedules that do not meet the capacity constraints, adjustments to the scheduling scheme are required. To reduce the computational complexity of the repair operator, a method of eliminating conflicting tasks is employed to repair the original scheduling scheme. In addition to verifying the satellite’s fixed capacity, it is also necessary to examine the satellite’s energy consumption. If the satellite’s energy consumption exceeds its maximum energy limit, adjustments to the scheduling plan are required. To minimize the impact of these adjustments on the original plan, a simple method of canceling the last executed observation tasks is employed until the satellite’s energy constraints are satisfied, as shown in Figure 4.

4.3. Process of the RLNS

The process of the large neighborhood search algorithm based on constraint information is shown in Figure 5.

In the iterative framework of the algorithm, a reference is made to the Metropolis criterion of the simulated annealing algorithm to enhance the search efficiency of the algorithm.

5. Genetic Algorithms (GA)

Through the analysis we found that due to the high coupling of the scheduling schemes of the imaging and digital transmission tasks in this integrated scheduling problem, the destruction and repair operators of the designed RLNS are relatively simple and the solution effect is relatively limited; therefore, the population-based genetic algorithm is designed on the basis of the multiple rule operators of the RLNS.

5.1. Algorithm Description

In the RLNS, task start scheduling is performed by a simple first-come-first-scheduled rule. This single heuristic rule could potentially lead to optimal solutions that cannot be found by neighborhood search.

As shown in Figure 6, if only the first-come-first-served rule is followed, goal 2 will not be scheduled; however, it may be possible to adjust the execution time of goal 1 backward so that goal 2 can also be executed.

As shown in Figure 7, if only the first-come-first-served rule is followed, Satellite 2 will not be able to perform the observation as planned due to insufficient on-board fixed memory capacity during the observation mission.

5.2. Algorithm Design

In order to realize the perturbation of the first-come-first-schedule rule based on the time window sequence and achieve better search results, the operators of the genetic algorithm are designed as the perturbation of the task sequence on the satellite and the perturbation of the time window timing sequence between the satellite and the ground station.

For mission sequences on satellites, neighborhood perturbation can be achieved by exchanging the sequential order between different segments, and exchanging mission sequence segments on different satellites, as shown in Figure 8.

For the perturbation of the time sequence of the time window between the satellite and the ground station, it is possible to adopt the method of randomly selecting the perturbation position, and exchanging the time sequence between the time window of the perturbation position and the next window immediately adjacent to it.

For other aspects of the design of the genetic algorithm, the new population selects individuals from the parent population for chromosome crossover operations (chromosome crossover operations in this case are exchanging the assignments and sequences of observational targets to satellites or assignments to ground stations on different solutions, as well as the sequence of adjustments to the time window of the satellite and ground stations) and mutation operations by means of a tournament selection method. The optimal individuals from the previous generation of the population are retained each time the offspring population is generated, as shown in Figure 9.

6. Simulation Experiments and Results

This section conducts simulation experiments of varying scales.

6.1. Data Description

The various parameters of the simulation data are as follows: The satellite parameters (from the orbital parameters of the SuperView-1 series satellites) are shown in

Table 4. Parameters of satellites for experiments.

Parameters	Sat01	Sat02	Sat03	Sat04
a	609.1 km	609.1 km	609.1 km	609.1 km
e	1.64 $\times {10}^{-3}$	1.54 $\times {10}^{-3}$	5.11 $\times {10}^{-4}$	1.1 $\times {10}^{-3}$
i	97.50°	97.41°	97.47°	97.47°
$\omega$	82.01°	78.17°	335.09°	320.80°
$\Omega$	349.16°	334.40°	342.09°	342.30°
$\nu$	52.73°	33.30°	162.46°	173.56°

.

The satellite sensor type is rectangular, with a vertical half-angle of the field of view of 30° and a horizontal half-angle of 5°. Other satellite parameters are shown in

Table 5. Information of satellites for experiments.

Sat	${\mathit{m}}_{\mathit{k}}$	${\mathit{energy}}_{\mathit{k}}$	${\mathit{M}}_{\mathit{k}}$	${\mathit{Energy}}_{\mathit{k}}$
Sat01	2	2	500	500
Sat02	2	2	500	500
Sat03	2	2	500	500
Sat04	2	2	500	500

.

The observation targets are a group of targets with an average distribution centered around five points within China, with latitude and longitude differences ranging from −10° to 10°. The coordinates of the five central points are shown in

Table 6. Information of targets for experiments.

	Point1	Point2	Point3	Point4	Point5
Longitude	113	90	100	110	115
Latitude	10	40	35	30	25

.

The five ground stations selected are located within China, with the following latitude and longitude information shown in

Table 7. Information of stations for experiments.

	Beijing	Jiamusi	Kashgar	Nanning	Xiamen
Longitude	116	130.32	75.929	108.37	118.09
Latitude	40	46.8	39.505	22.82	24.48

.

The priority of the targets is a random integer between 1 and 5.

The observation time for each target is 10, and the transmission time is 20.

To simplify the complexity of the simulation, we randomly assign the transition time between observation tasks as an integer within the range of 1 to 10. The attitude maneuver of the satellite or the stations both consume 1 unit of energy per second.

6.2. Problem Scenario Visualization

Based on the above assumptions, the problem scenarios focused on in this study are as shown in Figure 10 and Figure 11.

6.3. Analysis of the Results

The exact solution experiment was implemented using the CPLEX 12.9 Studio, while the heuristic algorithm solution experiment was implemented using C++ language. Both experiments were run on a personal computer with an AMD Ryzen Threadripper PRO 5975WX 32-Cores 3.60 GHz processor, 32.0 GB (31.8 GB available) of memory, and the operating system Windows 10.

The experimental results are shown in Figure 12, Figure 13 and Figure 14.

As shown in Figure 15. The experimental results for solvers and algorithms are shown in

Table 8. Results of experiments.

Target Quantity	LP	LPtime	CP	CPtime	RLNS	RLNStime	GA	GAtime
10	15	0.08	15	0.37	15	3	13	3
20	45	0.56	45	10.77	34	3	38	14
30	65	6.23	65	600.21	34	1	28	28
40	129	41.08	129	41.57	109	1	77	40
50	152	601.16	152	600.35	91	3	85	55
100	198	3604.33	198	3600.74	152	4	150	146
150	0	3600	0	3600	161	6	226	288
200	0	3600	0	3600	174	8	261	473
300	0	3600	0	3600	163	12	327	609

.

The solution of CPLEX is not the optimal solution when the target scale is greater than 50, but a truncated solution according to the set time limit.

7. Discussion

Through the experimental results we found the following:

As the problem size increases, the solution time of the cplex solver increases exponentially with the problem size. And, when the problem exceeds a certain size, the solver has difficulty in finding a feasible solution within an acceptable time frame. For small-scale problems, the solution performance of the cplex solver is not much different from that of the cp solver when resources are more abundant, while for resource-constrained cases, the cplex solver is able to find the optimal solution faster without having to explore all the branches as much as possible, as in the case of the cp solver.

Rule-based algorithms for large neighborhoods converge better, but have limited effectiveness in finding optimal results for large-scale problems. Neighborhood updates by large neighborhood search algorithms to explore to a better solution during neighborhood search occur more often on the task reassignment operator than on the task sequence perturbation operator, which may reflect the significant advantage of the first-come-first-scheduled rule for stochastic task sequences.

Genetic algorithms have a better ability to find the optimal based on the heuristic rules of the large neighborhood algorithms, but for the case of tight resource constraints, the solution effect is not satisfactory enough; when the size of the problem increases, the solution performance of genetic algorithms is better than that of the neighborhood search algorithms. Meanwhile, during the experiments we found that the genetic algorithm is prone to premature maturity, where the algorithm has found a better solution under the heuristic rule in the first generation, while it is unable to find a better neighborhood solution in the subsequent iterations of the optimization search process.

Current rule-based operators fall short in the explorability of neighborhood spaces: first of all, the rules of the repair operator designed in this paper are too simple, and there may be cases where the optimal solution cannot be searched. This is especially so when the satellite is executing imaging and digital transmission tasks at the same time; if the satellite’s fixed memory capacity at this time cannot satisfy the current observation task, then according to the rules in this paper, this task will not be successfully executed in the current task sequence. However, if the current mission can be moved backward for a certain period of time within the range allowed by the time window, after the satellite completes the current digital transmission mission, there will be possible memory space to realize the current observation mission, as shown in Figure 16. Therefore, in order to achieve better search results and avoid the optimal solution being unreachable, the execution start time of tasks in the task scheme can be designed to be locally adjusted based on the execution time of the tasks, instead of the current simple sequence-based neighborhood operator.

8. Conclusions

In this paper, the integrated scheduling problem for parallel imaging and data transmission of agile Earth observation satellites is explored, considering sliding time window and ground station resource constraints, as well as satellite energy and memory capacity constraints. To solve the problem, the RLNS algorithm is first proposed and a genetic algorithm is designed on the basis of its operator design, and the solution performance of these two algorithms is compared with that of the cplex and cp solvers through simulation experiments to verify the effectiveness of the algorithms.

By analyzing the neighborhood space of the algorithm, we found that some parts of the neighborhood space that could potentially lead to better solution results were discarded due to the use of certain heuristic rules. This leads to the limited effectiveness of the heuristics proposed in this paper. Cplex performs well and is fast when dealing with small-scale problems. However, its performance is limited when dealing with larger scale problems, whereas the heuristics are faster in searching and can produce better solution results for larger scale problems. For this problem, possible future algorithmic improvements are to relax the heuristic rules for data transfer scheduling and the neighborhood search for imaging and digitizing task start times, or to use advanced heuristic information such as the degree of temporal slack in the time window in which the task is located, and the degree of satellite on-board fixed memory capacity slack to guide the neighborhood search.