Satellite orbit batch calculation method and system based on tensor acceleration

Abstract

The application discloses a kind of satellite orbit batch computation method and system based on tensor acceleration, it is related to aerospace and high-performance computing field, including: the satellite orbit root number parameter of each satellite is converted into intermediate tensor set with batch dimension;According to intermediate tensor set, tensor coefficient and preset time stamp sequence, based on the broadcast mechanism of tensor, the time evolution of orbit state is executed under the earth inertial system, and orbit state variable is obtained, and the geographical parameters of each satellite under the earth-fixed coordinate system are calculated simultaneously;Orbit state variable is converted to earth-fixed coordinate system;According to the orbit state variable under the earth-fixed coordinate system, the geographical parameters of each satellite and the position tensor of ground station, based on the tensor trigonometric function and vector projection operation, the observation parameters of satellite relative to ground station are calculated.The application realizes the high-precision, high-throughput, low-delay batch computation of large-scale satellite in long time sequence.

Description

Technical Field

[0001] This invention relates to the fields of aerospace and high-performance computing technology, and in particular to a method and system for batch calculation of satellite orbits based on tensor quantization acceleration. Background Technology

[0002] Satellite orbit calculation is a core component of applications such as satellite communication, space monitoring, and ground station scheduling. Currently, the SGP4 algorithm is widely used in both spaceborne and ground-based systems. It analyzes satellite orbital parameters based on TLE data and predicts their position and motion at specific points in time. However, with the rapid increase in the number of low-Earth orbit satellites, traditional satellite orbit calculation methods have revealed serious bottlenecks:

[0003] (1) Low computational efficiency: Existing methods perform serial computation on a per-time point basis using a single satellite as the unit, which cannot effectively utilize the parallel computing capabilities of the GPU. As a result, the computation time increases linearly with the number of satellites and the time span, making it difficult to meet the real-time requirements of large-scale constellations.

[0004] (2) Insufficient utilization of hardware resources: CPU multithreading is limited by context switching and memory bandwidth bottlenecks, making it difficult to realize the hardware potential when processing tens of thousands of satellites; while traditional GPU solutions lack unified tensor modeling, resulting in serious idle computing resources and low actual utilization.

[0005] (3) Poor system stability and limited practicality: In large-scale batch computing, problems such as memory overflow and computing interruption are prone to occur. It lacks automatic memory management and abnormal recovery mechanisms, making it difficult to support long-term, high-concurrency production-level task scheduling, which restricts its application in real business scenarios.

[0006] Therefore, there is an urgent need for a novel orbit calculation method that supports multi-satellite, long-term time series, and GPU-accelerated tensor batch processing to achieve efficient parallel processing, resource-efficient utilization, and stable system operation, meeting the dual requirements of real-time performance and practicality for current large-scale satellite constellations. Thus, a tensor-accelerated batch satellite orbit calculation method was developed to address the aforementioned issues. Summary of the Invention

[0007] This invention proposes a method and system for batch calculation of satellite orbits based on tensor quantization acceleration, in order to solve the problems of low computational efficiency, insufficient hardware resource utilization, and poor system stability of traditional satellite orbit calculation methods.

[0008] The present invention achieves the above objectives through the following technical solutions:

[0009] This invention provides a method for batch calculation of satellite orbits based on tensor quantization acceleration, comprising:

[0010] Obtain TLE orbital data for several satellites and parse out the orbital element parameters for each satellite;

[0011] The orbital elements of each satellite are transformed into a set of intermediate tensors with batch dimensions.

[0012] Tensor parallel processing is performed based on the improved SGP4 algorithm. The processing steps include:

[0013] The coefficients used to describe long-term and short-term perturbations in the SGP4 model are calculated based on the intermediate tensor set to obtain the tensor coefficients;

[0014] Based on the intermediate tensor set, tensor coefficients, and preset timestamp sequence, the orbital state time evolution is performed in the geocentric inertial frame using the tensor broadcasting mechanism to obtain orbital state variables, and the geographic parameters of each satellite in the Earth-fixed coordinate system are calculated simultaneously.

[0015] Transform the orbital state variables to the Earth-fixed coordinate system;

[0016] Based on the orbital state variables in the Earth-fixed coordinate system, the geographic parameters of each satellite, and the position tensor of the ground station, the observation parameters of the satellite relative to the ground station are calculated using tensor trigonometric functions and vector projection operations.

[0017] Furthermore, TLE orbital data for several satellites are obtained, and the orbital elements of each satellite are analyzed, including:

[0018] Read TLE orbit data from several satellites from an external storage device;

[0019] The TLE orbital data of several satellites are analyzed in groups of three rows to extract the orbital element parameters for each satellite. The orbital element parameters include orbital inclination, right ascension of the ascending node, eccentricity, argument of perigee, mean perigee, mean motion, satellite number, dataset number, reference epoch year, reference epoch, atmospheric drag coefficient, B coefficient, orbital number, and satellite name.

[0020] Furthermore, the orbital elements of each satellite are transformed into a set of intermediate tensors with batch dimensions, including:

[0021] The orbital elements of each satellite are encapsulated into a high-dimensional floating-point tensor with batch dimension. The specific encapsulation process includes:

[0022] The orbital inclination and right ascension of the ascending node are converted to radians. Then, the initial average angular velocity and its correction term are calculated based on the converted orbital inclination and right ascension of the ascending node.

[0023] The orbital semi-major axis is calculated based on the Earth's gravitational constant and average motion. The orbital eccentricity correction and the corrected orbital semi-major axis are calculated based on the orbital semi-major axis, eccentricity, and J2-order Earth non-spherical perturbation correction term.

[0024] Based on the preset orbit period and deep space orbit discrimination conditions, determine whether the output is a Boolean mask tensor of deep space orbit. If so, generate a high-dimensional floating-point tensor containing orbit initial state information.

[0025] The criteria for determining deep space orbits include:

[0026] The criteria for determining eccentricity are as follows: For geostationary orbit (GEO) satellites: when the eccentricity is >0.01 and <0.2, they are considered to be in deep space orbit; for other deep space orbit satellites: when the eccentricity is >0.1, they are identified as being in deep space orbit.

[0027] Criteria for determining orbital inclination: When the orbital inclination is >50°, it is determined to be a deep-space orbit.

[0028] Criteria for determining average motion: For deep space satellites, when the average motion is less than 100 (unit: revolutions / day), it is considered to be in a deep space orbit.

[0029] Multi-dimensional superposition judgment: The Boolean masks of all criteria are combined through "AND" operation to form a unified batch processing Boolean tensor, where each element represents whether the satellite is in deep space orbit at that moment.

[0030] High-dimensional floating-point tensors are uniformly mapped to float64 precision tensors on CUDA devices (Unified Compute Device Architecture devices) to obtain an intermediate tensor set.

[0031] Furthermore, the formula for calculating the J2-order Earth nonspherical perturbation correction term is as follows:

[0032]

[0033] in, This is the J2-order Earth nonspherical perturbation correction term. It is Earth's Non-spherical terms, It is the average radius of the Earth. It is the semi-major axis of the track. It is the eccentricity of the orbit. It is the track inclination angle.

[0034] Furthermore, based on the intermediate tensor set, the coefficients used to describe long-term and short-term perturbations in the SGP4 model are calculated to obtain the tensor coefficients, including:

[0035] Based on the Julian date conversion formula, the reference time of TLE orbital data is converted into Julian epochs, thereby unifying the time base and ensuring that orbital calculations for different satellites at different times have a unified time reference standard, thus guaranteeing accurate calculation of time differences.

[0036] Calculate the square of the orbital eccentricity based on the eccentricity in the intermediate tensor set, and then calculate the orbital geometry factor.

[0037] Perturbation correction terms are constructed based on the harmonic terms of Earth's gravitational field and atmospheric drag terms, generating higher-order perturbation coefficients;

[0038] Calculate the orbital plane precession rate, perigee precession rate, and rate of change of the horizontal perigee angle;

[0039] The orbital geometry factors are calculated based on the following intermediate tensors: orbital inclination, right ascension of the ascending node, eccentricity, and argument of perigee. These tensors, along with various perturbation coefficients, participate in batch calculations through a tensor broadcasting mechanism, including calculating the true perigee angle based on intermediate tensors and elliptical orbital geometry, and calculating three-dimensional spatial distances based on orbital inclination.

[0040] Higher-order perturbation coefficients are calculated using functions based on orbital radius and inclination.

[0041] Calculate the gravity perturbation terms of each order based on the intermediate tensor.

[0042] The orbital plane precession rate, the ascending node precession rate, and the rate of change of the mean anomaly angle are calculated based on the intermediate tensor and gravity perturbation terms of each order.

[0043] Simultaneously, a coefficient tensor for correcting the short-term periodic term of the orbit and coefficients for correcting the orbital eccentricity and position are generated.

[0044] All the obtained coefficients are returned as float64 tensors consistent with the batch dimension, forming a complete set of perturbation model parameters.

[0045] The long-term perturbation coefficients include: the atmospheric drag coefficient, which describes the long-term effect of the satellite's orbit slowly decaying due to atmospheric drag; the second perturbation coefficient, which reflects the influence of the non-spherical nature of the Earth's gravitational field on the long-term changes in the orbit; and the b coefficient, which comprehensively reflects the relationship between atmospheric drag and satellite characteristic parameters.

[0046] Short-term perturbation factors include: mean motion, which describes the short-term variation of the satellite's average velocity in its orbit; orbital inclination, which describes the short-term variation of the satellite's average velocity in its orbit; right ascension of the ascending node, which describes the relative position of the ascending node with respect to the Earth's rotation; argument of perigee, which describes the angular position of the perigee relative to the ascending node; and mean perigee, which is used to calculate the instantaneous angular position of the satellite in its elliptical orbit.

[0047] Correlation with long- and short-term perturbation coefficients:

[0048] The time integral of the atmospheric drag coefficient, after being converted to the Julian era, is used to calculate the decay effect; the cumulative effect of the second perturbation coefficient is used to calculate the long-term orbital drift caused by the Julian date change; the time evolution of the b coefficient is the product of the long-term decay rate and the Julian time.

[0049] Its correlation with short-term perturbation coefficient:

[0050] The instantaneous angular position is calculated using the Julian era, thereby updating the time of the mean aperimeter angle; combined with the Julian time, the long-term precession of the orbital plane is calculated, thereby correcting the long-term changes in the orbital inclination angle. The calculation process uses the precise time difference of the Julian era to correct the instantaneous motion state.

[0051] The calculation process is as follows: the input TLE time is converted into a Julian date-time difference tensor to generate long-term perturbation coefficients and the time tensor is multiplied by the dot product to obtain the cumulative effect term. The short-term perturbation parameters are updated synchronously with time.

[0052] Furthermore, based on the intermediate tensor set, tensor coefficients, and a preset timestamp sequence, and using a tensor broadcasting mechanism, the temporal evolution of the orbital state is performed in the geocentric inertial frame to obtain the orbital state variables, including:

[0053] Convert the preset timestamp sequence into a time offset that matches the orbit timescale;

[0054] Based on the tensor broadcasting mechanism and time offset, the intermediate tensors of all satellites are aggregated and advanced in parallel over time steps;

[0055] The Newton-Raphson iterative process is executed synchronously in the tensor dimension to ensure the precise convergence of the orbital state of each satellite. The convergence judgment is based on a unified precision threshold.

[0056] During the Newton-Raphson iteration, the state variables in the intermediate tensor set are continuously updated, and the short-term perturbation correction term in the tensor coefficients is introduced to correct the state variables, thus obtaining the orbital state variables.

[0057] The Newton-Raphson iteration serves as the core computational module in the parallel processing. Its iterative process executes on the intermediate result tensors generated by the preceding parallel processing. A preliminary solution is obtained through parallel processing, and then optimized to the final solution using an exact iterative method (Newton-Raphson).

[0058] Parallel propulsion phase: All satellites simultaneously perform orbital propulsion, generating intermediate trajectory tensors.

[0059] Iterative refinement stage: The intermediate orbit of each satellite is used as the input object of Newton-Raphson calculation to perform precise solution and output the final accurate orbit.

[0060] The unified accuracy threshold is a composite accuracy indicator that integrates the accuracy requirements of multiple dimensions, including position, speed, time synchronization, and orbital parameters.

[0061] Furthermore, based on the orbital state variables in the Earth-fixed coordinate system, the geographic parameters of each satellite, and the position tensor of the ground station, the observation parameters of the satellite relative to the ground station are calculated using tensor trigonometric functions and vector projection operations, including:

[0062] Construct a location tensor for the ground stations based on their location information, and then perform operations on the tensor to align the synchronization times of all ground stations.

[0063] Based on the orbital state variables in the Earth-fixed coordinate system, the geographic parameters of each satellite, and the position tensor of the ground station, the azimuth, elevation, distance, and rate of change of the satellite relative to the ground station are calculated using tensor trigonometric functions and vector projection operations.

[0064] The obtained elevation angle parameters are then asymmetrically corrected.

[0065] The calculated azimuth, elevation, distance, and rate of change of distance are output as float64 tensors to obtain the observation parameters of the satellite relative to the ground station.

[0066] The specific calculation process is as follows:

[0067] First, calculate the relative position tensor. For each time step and each satellite, subtract the ground station position tensor from the Earth-fixed satellite position tensor to obtain the relative position vector tensor. This difference operation is directly broadcast in the tensor dimension.

[0068] Calculate the distance by using the magnitude of the relative position vector to obtain the distance tensor;

[0069] Calculate azimuth and elevation angles: Construct the local observation direction using the latitude and longitude of the ground station, project the relative position vector onto the local horizontal and zenith directions, and obtain the azimuth and elevation angles from the projection results using inverse trigonometric functions.

[0070] Calculate the rate of change of distance: Project the Earth-fixed system satellite velocity tensor onto the relative position direction to obtain the velocity component along the line of sight, i.e., the rate of change of distance.

[0071] Calculate the asymmetric correction for elevation angle: If the elevation angle is >90°, then correct it to "180 - elevation angle" to meet the requirements of the actual observation perspective.

[0072] Furthermore, a location tensor for the ground stations is constructed based on their location information. Tensor operations are then performed to align the synchronization times of all ground stations, including:

[0073] Construct the location tensor of the ground station based on its latitude, longitude, and altitude information;

[0074] Calculate Greenwich Sidereal Time using the Julian epoch and Earth's rotation rate;

[0075] Based on Greenwich Mean Time, time synchronization of all ground stations is achieved using tensor quantization operations.

[0076] Furthermore, while processing the information according to the satellite orbit batch calculation model based on the SGP4 algorithm, a tensor deployment strategy is executed. The tensor deployment strategy includes:

[0077] Based on the current video memory capacity of the computing device, the required memory resources are calculated during the initialization phase using a preset video memory estimation model.

[0078] If the estimated value exceeds the available video memory threshold of the computing device, the batch size will be automatically reduced until the preset memory resource constraints are met.

[0079] When the total number of satellites exceeds the capacity of a single device, the TLE orbit data of several satellites are divided into multiple sub-batches according to the satellite ID order. A static sharding strategy is adopted to allocate different batches of tasks to multiple computing devices for parallel execution.

[0080] The present invention also provides a system for the aforementioned method for batch calculation of satellite orbits based on tensor quantization acceleration, characterized in that it comprises:

[0081] The data parsing module is used to acquire TLE orbit data of several satellites and parse out the satellite orbit element parameters of each satellite.

[0082] Tensor initialization module, which is used to convert the satellite orbital element parameters of each satellite into an intermediate tensor set with batch dimension;

[0083] The parallel computing module is used to perform tensor parallel processing based on the improved SGP4 algorithm. The processing includes:

[0084] The coefficients used to describe long-term and short-term perturbations in the SGP4 model are calculated based on the intermediate tensor set to obtain the tensor coefficients;

[0085] Based on the intermediate tensor set, tensor coefficients, and preset timestamp sequence, the orbital state time evolution is performed in the geocentric inertial frame using the tensor broadcasting mechanism to obtain orbital state variables, and the geographic parameters of each satellite in the Earth-fixed coordinate system are calculated simultaneously.

[0086] Transform the orbital state variables to the Earth-fixed coordinate system;

[0087] Based on the orbital state variables in the Earth-fixed coordinate system, the geographic parameters of each satellite, and the position tensor of the ground station, the observation parameters of the satellite relative to the ground station are calculated using tensor trigonometric functions and vector projection operations.

[0088] The beneficial effects of this invention are as follows:

[0089] The present invention proposes a method and system for batch calculation of satellite orbits based on tensor acceleration. The traditional SGP4 orbit calculation algorithm, which is executed on a time-point basis on a single satellite basis, is reconstructed into a parallel evolution framework driven by tensors in a full batch. Through unified tensor modeling and automatic broadcasting mechanism, it can realize high-precision, high-throughput, and low-latency batch calculation of orbit parameters of large-scale satellites in long time series. Attached Figure Description

[0090] Figure 1 This is a system architecture diagram of the satellite orbit batch calculation method based on tensor quantization acceleration in this application;

[0091] Figure 2 This is a flowchart of the batch calculation method for satellite orbits based on tensor quantization acceleration proposed in this application. Detailed Implementation

[0092] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. The components of the embodiments of the present invention described and shown in the accompanying drawings can generally be arranged and designed in various different configurations.

[0093] Therefore, the following detailed description of the embodiments of the invention provided in the accompanying drawings is not intended to limit the scope of the claimed invention, but merely to illustrate selected embodiments of the invention. All other embodiments obtained by those skilled in the art based on the embodiments of the invention without inventive effort are within the scope of protection of the invention.

[0094] The specific embodiments of the present invention will now be described in detail with reference to the accompanying drawings.

[0095] As attached Figure 1 As shown, the system of the present invention includes: a data parsing module: responsible for reading TLE files and parsing the orbital parameters of each satellite in groups of three lines; a tensor initialization module: converting the parameters into tensors of shape (batch_size, 86400) and deploying them to the GPU; a GPU parallel computing module: performing all tensor operations based on the SGP4 algorithm formula; and an observation parameter output module: outputting results such as elevation angle, azimuth angle, and distance.

[0096] like Figure 2 As shown, the present invention proposes a method for batch calculation of satellite orbits based on tensor quantization acceleration, and the specific steps are as follows:

[0097] S1: Tensor quantization preprocessing and batch initialization of multi-star TLE data.

[0098] The system reads TLE orbital data containing several satellites from an external storage device, parses it in groups of three rows, extracts the orbital element parameters for each satellite, and converts them into double-precision floating-point tensors. It then copies and expands each orbital parameter tensor along the time dimension to form a tensor sequence with batch dimensions, representing the orbital status of all satellites over a specified time span.

[0099] Specifically, tensor initialization is achieved using PyTorch's `torch.full` function. Parameters such as orbital inclination, right ascension of the ascending node, eccentricity, argument of periapsis, mean periapsis, and average motion are initialized as `torch.float64` tensors of shape `(batch_size, time_step)`. After tensor initialization, all orbital parameters are uniformly processed into a single high-dimensional tensor and deployed to the CUDA device. These parameters can be computed in parallel on the GPU, and efficient parallel processing is achieved on the GPU through PyTorch's automatic broadcast mechanism. In traditional CPU computation, each element is often processed sequentially. However, GPUs, utilizing a large number of parallel processing units, can process multiple data elements simultaneously, significantly improving computational efficiency. Mathematically, assuming a tensor of shape `(batch_size, time_step)`... tensor ,in Taking the track incl angle as an example, its initialization process can be expressed as:

[0100] ;

[0101] This means each The values ​​are all set to "value_incl". In a GPU, all these assignment operations can be performed simultaneously through parallel computation. The computation of each element is no longer performed serially, but is completed in parallel by multiple computation cores. Broadcasting is an indispensable part of GPU-accelerated computation; it enables tensors of different shapes to be automatically aligned and perform element-level operations. This mechanism effectively avoids explicit loop operations, thus significantly improving computational efficiency. Assume there are two tensors... and Their shapes are (batch_size, time_steps) and (time_steps, ), respectively. Through a broadcast mechanism, the tensor... It will automatically expand to a shape (batch_size, time_steps) and... Perform parallel computation. The broadcast mechanism can be expressed mathematically as follows:

[0102] ;

[0103] This mechanism expands small tensors to the shape of large tensors through vectorization, avoiding explicit processing of each element. This allows for parallel operations on all elements. The GPU distributes a large amount of computational tasks across its thousands of cores, each responsible for computing different elements. In this process, operations on all elements follow the same computational steps. Assume this invention applies to a tensor... Perform the operation, the operation is Then the calculation of each element can be expressed as:

[0104] ;

[0105] Here This represents a tensor operation (such as assignment, addition, multiplication, etc.). By uniformly representing orbital parameters and time series as tensors, this invention avoids the serial calculation mode of satellite-by-satellite and time-step-by-time, and achieves batch parallel processing of the entire satellite constellation. All orbital parameters and calculation processes (including angle transformation, perturbation correction, orbit evolution, etc.) are performed in tensor form and parallelized through PyTorch's automatic broadcasting mechanism, thus avoiding explicit loop structures. The combination of tensor broadcasting and GPU parallel computing not only improves the calculation speed but also maximizes the utilization of hardware resources.

[0106] S2: Tensor deployment strategy based on dynamic batch processing and multi-device fragmented scheduling.

[0107] Based on the current video memory capacity of the computing device, the system uses a video memory estimation model to calculate the required memory resources during the initialization phase:

[0108] `estimated_mem` = `batch_size * time_steps * param_dim * 8 * 2 * (1 + overhead_ratio)`, where `estimated_mem` is the estimated memory size, `batch_size` is the batch size, `time_steps` is the time step, `param_dim` is the parameter dimension, and `overhead_ratio` is the backpropagation and intermediate variable redundancy coefficient (usually 1.2-1.5). If the estimated value exceeds the GPU's available memory threshold, `batch_size` is automatically reduced until resource constraints are met, achieving adaptive batch adjustment. When the total number of satellites exceeds the capacity of a single device, the system divides the TLE data into multiple sub-batches according to satellite ID order, adopts a static sharding strategy, and distributes different batch tasks to multiple computing devices (such as multiple GPU cards) for parallel execution. Each computing device independently runs the orbit calculation process, and the results are uniformly collected through a shared memory mechanism to avoid data contention. This strategy ensures system stability and efficient resource utilization in high-concurrency, high-capacity scenarios for large-scale tasks.

[0109] A segmented scheduling mechanism is adopted to divide large-scale tasks into batches and distribute them to multiple computing devices for parallel execution. Each device runs the track calculation process independently, and the calculation results are merged through a unified mechanism to achieve collaborative processing of multiple devices. A memory estimation and dynamic batch processing mechanism is introduced to automatically adjust the batch size according to the resource capacity during the initialization phase to ensure that the system remains stable under high concurrency and large-capacity tasks.

[0110] S3: Full-batch parallel reconstruction of the SGP4 algorithm based on tensor broadcasting.

[0111] The traditional SGP4 algorithm, which relies on a single satellite's loop structure, is reconstructed into a full-batch tensor evolution framework. All orbital parameters, intermediate variables, and time evolution processes are uniformly processed in tensor form. Dimension alignment and parallel computation are achieved through PyTorch's automatic broadcasting mechanism, avoiding explicit loops.

[0112] First, the satellite orbital elements (including orbital inclination, right ascension of the ascending node, eccentricity, argument of perigee, mean perigee, and mean motion) extracted from the input TLE file are encapsulated into high-dimensional floating-point tensors with batch dimensions, and uniformly mapped to `float64` precision tensors on the CUDA device. Through vectorization operations, the parameters of all satellites within the batch are processed in parallel. At this stage, the system completes the following key processes: First, angular parameters (such as inclination and right ascension of the ascending node) are uniformly converted to radians; then, the initial mean angular velocity is calculated. and its correction terms; based on the Earth's gravitational constant With average motion Reverse thrust track semi-major axis :

[0113] ;

[0114] in, It is the standard gravitational constant of Earth. This represents the average motion of the satellite. Next, based on the Earth's gravitational constant and orbital parameters, a J2-order Earth non-spherical perturbation correction term is introduced to calculate the orbital eccentricity correction. With the corrected semi-major axis The formula for calculating the J2 correction term is:

[0115] ;

[0116] in, It is the J2 non-spherical term of Earth. It is the average radius of the Earth. It is the semi-major axis of the track. It is the eccentricity of the orbit. It's the track inclination angle. The corrected semi-major axis. It will be updated. Subsequently, the system estimates the orbital period and outputs a Boolean mask tensor indicating whether it is a deep space orbit based on the deep space orbit discrimination criteria. This generates an intermediate tensor set containing initial orbital state information for subsequent use. All orbital state variables (such as true anomaly, eccentricity, argument, etc.) are uniformly encapsulated as tensors of ((batch_size, time_steps)) dimensions, and are advanced in parallel over time steps through a tensor broadcasting mechanism. The Newton-Raphson iteration method is executed synchronously in the tensor dimension to ensure accurate convergence of the orbital state of each satellite. Convergence is judged based on a unified precision threshold (e.g., ...). All perturbation systems are generated at once based on batch orbit parameter tensors, avoiding repeated calculations for each satellite and significantly improving computational efficiency. The system supports simplified model flags (such as sgp4Simple) and dynamically selects high-precision or high-efficiency calculation paths according to requirements, thereby balancing accuracy and performance.

[0117] All orbital parameters and intermediate variables are processed in batch tensor form, and parallel computation is achieved through an automatic broadcast mechanism to avoid processing satellite by satellite; Newton-Raphson iteration is executed in parallel along the tensor dimension, and the convergence judgment threshold is configurable to ensure computational accuracy; simplified model flags are supported, and a balance strategy between computational accuracy and efficiency can be dynamically selected according to requirements.

[0118] S4: Calculation of tensor-based observation parameters from the geocentric inertial frame to the Earth-solid frame

[0119] The orbital state evolution is advanced step-by-step in the geocentric inertial coordinate system to calculate the satellite's three-dimensional position and velocity tensors. Subsequently, the orbital information is transformed into the Earth-fixed coordinate system. Based on the ground station position and time information, the ground station position tensor is constructed, and Greenwich Mean Time (GMST) is calculated using the Julian epoch and the Earth's rotation rate. Synchronization and time alignment of global ground stations are achieved through tensor quantization operations.

[0120] Based on tensor trigonometric functions and vector projection operations, the observation parameters of the satellite relative to the ground station are calculated, including elevation angle, azimuth angle, distance, and distance change rate. Among them, the elevation angle parameter is asymmetrically corrected before output; if the elevation angle is greater than 90°, it is set to (180° - elevation angle) to conform to the actual observation perspective and improve the practicality of remote sensing imaging and ground station scheduling.

[0121] The conversion process from the geocentric inertial frame to the Earth-fixed frame is achieved through tensor time synchronization and vector projection, supporting parallel computing across multiple ground stations; the elevation angle correction mechanism performs asymmetric processing based on time observation requirements, improving the practicality of the results.

[0122] S5: Tensor quantization output for downstream applications and system scalability assurance.

[0123] The calculation results are output in tensor form, forming a sequence of observation parameters with batch and time dimensions. It supports efficient indexing and slicing operations by satellite, time, observation point, etc., facilitating subsequent applications such as communication link planning, ground station scheduling, and remote sensing imaging. The system supports expansion to different time spans and batch sizes, adapting to diverse operational needs from single satellites to tens of thousands of satellites.

[0124] The invention will be further described below through specific application steps:

[0125] Call parse_tle to read TLE data. Taking 14436 satellites as an example, it corresponds to 14436 satellites.

[0126] The system processes information based on a satellite orbit batch calculation model using the SGP4 algorithm. During initialization, the system first estimates the required GPU memory. If the estimated value exceeds the available GPU memory (e.g., 37GB for an A100-40GB), the batch size is automatically downgraded until sufficient memory is available. The optimal batch size configuration is recorded for reuse in subsequent tasks. When the total number of satellites exceeds the single-card capacity, the system divides the TLE data into multiple sub-batches based on batch size_per_round=200.

[0127] The multiprocessing module distributes different batches to different GPU cards (such as A100-40GB) for parallel computation. Each subprocess independently runs the computation process of the SatelliteThrough class, and the computation results are uniformly collected and merged through the Queue mechanism.

[0128] The specific process of information processing in the satellite orbit batch calculation model based on the SGP4 algorithm is as follows:

[0129] First, the satellite orbital elements (including orbital inclination, right ascension of the ascending node, eccentricity, argument of perigee, mean perigee, and mean motion) extracted from the input TLE file are encapsulated into high-dimensional floating-point tensors with batch dimensions. These are then uniformly mapped to float64 precision tensors on the CUDA device. Through vectorization operations, the parameters of all satellites within the batch are processed in parallel. During this stage, the system completes the following key processes: converting angle parameters (degrees) to radians; calculating the initial mean angular velocity and its correction term; inferring the orbital semi-major axis based on the Earth's gravitational constant and mean motion; introducing a J2-order Earth non-spherical perturbation correction term, calculating the orbital eccentricity correction and the corrected semi-major axis; estimating the orbital period and deep-space orbit discrimination criteria, and outputting a Boolean mask tensor indicating whether it is a deep-space orbit; and generating an intermediate tensor set containing initial orbital state information for subsequent calls.

[0130] This stage, based on the orbital parameters output by S21, further calculates various coefficients in the SGP4 model used to describe long-term and short-term perturbations. All calculations are performed in the tensor dimension, avoiding iterative processing for each satellite and significantly improving computational efficiency. Specifically, this includes: converting the TLE reference time to Julian epochs using the Julian date conversion formula; calculating the square of the orbital eccentricity and the orbital geometry factor; constructing perturbation correction terms based on the Earth's gravitational field harmonics and atmospheric drag terms, generating higher-order perturbation coefficients, and introducing these higher-order perturbation coefficients into the sgp4Simple flag to determine whether to enter the simplified orbital model; calculating key evolution rates such as orbital plane precession rate, perigee precession rate, and mean perigee angle change rate; simultaneously generating coefficient tensors for correcting the short-term orbital periodicity term and coefficients for correcting orbital eccentricity and position; all outputs are returned in the form of float64 tensors consistent with the batch dimension, forming a complete perturbation model parameter set.

[0131] This stage receives the tensor outputs from S21 and S22, and combines them with the externally input timestamp sequence to perform the time evolution of the orbital state. The specific process is as follows: The timestamp sequence (millisecond level) is converted into a second-level offset (tsince) matching the orbital timescale; the time offset is applied to the orbital evolution equations of all satellites through a tensor broadcasting mechanism to achieve parallel time advancement; the Kepler equations are solved using the Newton-Raphson iterative method, and the convergence judgment mechanism of tensor quantization (EPSILON accuracy threshold) is used for iteration to ensure the convergence of the orbital state of each satellite. During the iteration process, state variables such as the true anomaly angle, eccentricity angle, and argument angle are continuously updated, and short-term perturbation correction terms (rk, uk, Xnodek, xinck) are introduced. Finally, the three-dimensional position tensors (positionX, positionY, positionZ) and three-dimensional velocity tensors (velocityX, velocityY, velocityZ) of each satellite in the geocentric inertial coordinate system are output, in kilometers (km) and kilometers per second (km / s). Simultaneously, the geographical parameters of the satellites in the Earth-fixed coordinate system, such as longitude, latitude, and altitude, are calculated to support subsequent ground station observation modeling.

[0132] After completing the orbital state calculation in the geocentric inertial frame, S6 is responsible for converting the orbital information to the Earth-fixed coordinate system and generating observational geometric parameters for applications such as satellite communication, remote sensing, and navigation. All calculations are performed in tensor dimensions. Based on the latitude, longitude, and altitude information of the ground stations, a ground station position tensor is constructed. Greenwich Mean Time (GMST) is calculated using the Julian epoch and the Earth's rotation rate, and global ground station synchronization is achieved through tensor operations. The azimuth, elevation, distance, and rate of change of distance of the satellite relative to the ground stations are calculated. High-precision azimuth / elevation angle calculations are achieved using tensor trigonometric functions and vector projection operations. The output elevation parameters are further asymmetrically corrected (adjusted by 180°-α when the elevation angle > 90°) to meet the requirements of actual observation perspectives. All output parameters (such as elevation, azimuth, and distance) are preserved in the form of float64 tensors.

[0133] For each time point, the elevation angle (elevation) is calculated, and the output is a tensor of (200, 86400). An asymmetric correction is applied to the output elevation angle: if elevation > 90°, it is set to 180° - elevation to match the actual observation perspective. The results are stored or output via an interface for subsequent applications. Specifically, the tensor initialization process is as follows (taking the tilt angle (incl) as an example):

[0134] Incl=torch.full(24*60*60,), value_incl, dtype=torch.float64, device='cuda: 0').

[0135] Here, `torch.full` indicates the creation of a tensor, with a shape and size of 24*60*60, and `value_incl` representing each element in the tensor; `dtype=torch.float64` indicates double precision, and `device='cuda:0'` indicates creation directly on GPU 0. The tensor initialization process can be represented as copying the satellite's inclination parameters along the time axis to 86,400 identical values ​​at each time point, facilitating subsequent broadcast / parallel computation with time-series tensors. `float64` makes some SGP4 calculations more sensitive to numerical stability in long-term series and large-batch operations, while double precision reduces accumulated errors and avoids divergence. `device='cuda:0'`: directly places the parameters on the GPU, eliminating the need for copying back and forth in subsequent tensor operations.

[0136] All variables are initialized in this manner to ensure consistency in batch processing. During computation, each formula in the improved SGP4 algorithm automatically supports tensor broadcasting without the need for explicit loops.

[0137] To verify the performance advantages of this invention, it was conducted using an Intel(R) Xeon(R) Silver4316 CPU @ 2.30GHz 40 cores; an NVIDIA A100-PCIE-40GB GPU; 256GB of memory; PyTorch: 2.5.1+121; and CUDA Toolkit: 12.1. The experiment was performed on an NVIDIA A100-40GB GPU (8 cards) environment. With a total of 14,436 satellites, the data was divided into 73 sub-batches with a batch size of 200. Multiprocessing was used for parallel computation on the eight cards, and the following comparative experiment was designed:

[0138] Experiment 1: Single-satellite mission. The experimental results are shown in Table 1.

[0139] Table 1

[0140]

[0141] As shown in Table 1, Python-GPU improves performance by 630% compared to Java-8 threads and is significantly better than Python-CPU.

[0142] Experiment 2: Multi-satellite mission (14,436 satellites, 24 hours). The experimental results are shown in Table 2.

[0143] Table 2

[0144]

[0145] As shown in Table 2, Python-GPU outperforms Java-64 threads by 677% and Python-CPU by 2104%, demonstrating a significant performance advantage.

[0146] Experiment 3: Java multithreading comparison (14436 chips, 24 hours). The experimental results are shown in Table 3.

[0147] Table 3

[0148]

[0149] As shown in Table 3, increasing the number of Java threads provides only a limited performance improvement, but it is far less effective than Python-GPU.

[0150] In conclusion, in large-scale task processing, Python-GPU significantly outperforms Java multithreading and Python-CPU in terms of acceleration. Based on a Java-64-thread benchmark, Python-GPU achieves a 577% performance improvement in a 24-hour task, demonstrating the overwhelming advantage of GPU parallel computing in large-scale satellite orbit calculations. As shown in Table 2, the method of this invention exhibits excellent performance across different task scales, especially in a 14,436-satellite task, where the execution time is only 31.88 seconds, far lower than other solutions.

[0151] As attached Figure 1 As shown, the system of the present invention includes: a data parsing module: responsible for reading TLE files and parsing the orbital parameters of each satellite in groups of three lines; a tensor initialization module: converting the parameters into tensors of shape (batch_size, 86400) and deploying them to the GPU; a GPU parallel computing module: processing the improved SGP4 orbital model and performing all tensor operations; and an observation parameter output module: outputting results such as elevation angle, azimuth angle, and distance.

[0152] The above description is only a preferred embodiment of the present invention. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the technical principles of the present invention, and these improvements and modifications should also be considered within the scope of protection of the present invention.

Claims

1. A method for batch calculation of satellite orbits based on tensor quantization acceleration, characterized in that, include: Obtain TLE orbital data for several satellites and parse out the orbital element parameters for each satellite; The orbital elements of each satellite are transformed into a set of intermediate tensors with batch dimensions. Tensor parallel processing is performed based on the improved SGP4 algorithm. The processing steps include: The coefficients used to describe long-term and short-term perturbations in the SGP4 model are calculated based on the intermediate tensor set to obtain the tensor coefficients; Based on the intermediate tensor set, tensor coefficients, and preset timestamp sequence, the orbital state time evolution is performed in the geocentric inertial frame using the tensor broadcasting mechanism to obtain orbital state variables, and the geographic parameters of each satellite in the Earth-fixed coordinate system are calculated simultaneously. Transform the orbital state variables to the Earth-fixed coordinate system; Based on the orbital state variables in the Earth-fixed coordinate system, the geographic parameters of each satellite, and the position tensor of the ground station, the observation parameters of the satellite relative to the ground station are calculated using tensor trigonometric functions and vector projection operations.

2. The method for batch calculation of satellite orbits based on tensor quantization acceleration according to claim 1, characterized in that, Obtain TLE orbital data for several satellites, and parse out the orbital elements parameters for each satellite, including: Read TLE orbit data from several satellites from an external storage device; The TLE orbital data of several satellites are analyzed in groups of three rows to extract the orbital element parameters for each satellite. The orbital element parameters include orbital inclination, right ascension of the ascending node, eccentricity, argument of perigee, mean perigee, mean motion, satellite number, dataset number, reference epoch year, reference epoch, atmospheric drag coefficient, B coefficient, orbital number, and satellite name.

3. The method for batch calculation of satellite orbits based on tensor quantization acceleration according to claim 2, characterized in that, The orbital elements of each satellite are transformed into a set of intermediate tensors with batch dimensions, including: The orbital elements of each satellite are encapsulated into a high-dimensional floating-point tensor with batch dimension. The specific encapsulation process includes: The orbital inclination and right ascension of the ascending node are converted to radians. Then, the initial average angular velocity and its correction term are calculated based on the converted orbital inclination and right ascension of the ascending node. The orbital semi-major axis is calculated based on the Earth's gravitational constant and average motion. The orbital eccentricity correction and the corrected orbital semi-major axis are calculated based on the orbital semi-major axis, eccentricity, and J2-order Earth non-spherical perturbation correction term. Based on the preset orbit period and deep space orbit discrimination conditions, determine whether the output is a Boolean mask tensor of deep space orbit. If so, generate a high-dimensional floating-point tensor containing orbit initial state information. The high-dimensional floating-point tensors are uniformly mapped to float64 precision tensors on the CUDA device to obtain an intermediate tensor set.

4. The method for batch calculation of satellite orbits based on tensor quantization acceleration according to claim 3, characterized in that, The formula for calculating the J2-order Earth non-spherical perturbation correction term is: ， in, This is the J2-order Earth nonspherical perturbation correction term. It is Earth's Non-spherical terms, It is the average radius of the Earth. It is the semi-major axis of the track. It is the eccentricity of the orbit. It is the track inclination angle.

5. The method for batch calculation of satellite orbits based on tensor quantization acceleration according to claim 3, characterized in that, The coefficients used to describe long-term and short-term perturbations in the SGP4 model are calculated based on the intermediate tensor set, resulting in tensor coefficients, including: Based on the Julian day conversion formula, the reference time of TLE orbital data is converted into the Julian epoch; Calculate the square of the orbital eccentricity based on the eccentricity in the intermediate tensor set, and then calculate the orbital geometry factor. Perturbation correction terms are constructed based on the harmonic terms of Earth's gravitational field and atmospheric drag terms, generating higher-order perturbation coefficients; Calculate the orbital plane precession rate, perigee precession rate, and rate of change of the horizontal perigee angle; Simultaneously, a coefficient tensor for correcting the short-term periodic term of the orbit and coefficients for correcting the orbital eccentricity and position are generated. All the obtained coefficients are returned as float64 tensors consistent with the batch dimension, forming a complete set of perturbation model parameters.

6. The method for batch calculation of satellite orbits based on tensor quantization acceleration according to claim 1, characterized in that, Based on the intermediate tensor set, tensor coefficients, and a preset timestamp sequence, and using a tensor broadcasting mechanism, the orbital state time evolution is performed in the geocentric inertial frame to obtain orbital state variables, including: Convert the preset timestamp sequence into a time offset that matches the orbit timescale; Based on the tensor broadcasting mechanism and time offset, the intermediate tensors of all satellites are aggregated and advanced in parallel over time steps; The Newton-Raphson iterative process is executed synchronously in the tensor dimension to ensure the precise convergence of the orbital state of each satellite. The convergence judgment is based on a unified precision threshold. During the Newton-Raphson iteration, the state variables in the intermediate tensor set are continuously updated, and the short-term perturbation correction term in the tensor coefficients is introduced to correct the state variables, thus obtaining the orbital state variables.

7. The method for batch calculation of satellite orbits based on tensor quantization acceleration according to claim 1, characterized in that, Based on the orbital state variables in the Earth-fixed coordinate system, the geographic parameters of each satellite, and the position tensor of the ground station, the observation parameters of the satellites relative to the ground station are calculated using tensor trigonometric functions and vector projection operations, including: Construct a location tensor for the ground stations based on their location information, and then perform operations on the tensor to align the synchronization times of all ground stations. Based on the orbital state variables in the Earth-fixed coordinate system, the geographic parameters of each satellite, and the position tensor of the ground station, the azimuth, elevation, distance, and rate of change of the satellite relative to the ground station are calculated using tensor trigonometric functions and vector projection operations. The obtained elevation angle parameters are then asymmetrically corrected. The calculated azimuth, elevation, distance, and rate of change of distance are output as float64 tensors to obtain the observation parameters of the satellite relative to the ground station.

8. The method for batch calculation of satellite orbits based on tensor quantization acceleration according to claim 7, characterized in that, A location tensor for each ground station is constructed based on its location information. Synchronization time alignment of all ground stations is then performed using tensor operations, including: Construct the location tensor of the ground station based on its latitude, longitude, and altitude information; Calculate Greenwich Sidereal Time using the Julian epoch and Earth's rotation rate; Based on Greenwich Mean Time, time synchronization of all ground stations is achieved using tensor quantization operations.

9. The method for batch calculation of satellite orbits based on tensor quantization acceleration according to claim 1, characterized in that, While processing information according to the SGP4-based satellite orbit batch calculation model, a tensor deployment strategy is executed, which includes: Based on the current video memory capacity of the computing device, the required memory resources are calculated during the initialization phase using a preset video memory estimation model. If the estimated value exceeds the available video memory threshold of the computing device, the batch size will be automatically reduced until the preset memory resource constraints are met. When the total number of satellites exceeds the capacity of a single device, the TLE orbit data of several satellites are divided into multiple sub-batches according to the satellite ID order. A static sharding strategy is adopted to allocate different batches of tasks to multiple computing devices for parallel execution.

10. A system for a batch calculation method of satellite orbits based on tensor quantization acceleration as described in any one of claims 1-9, characterized in that, include: The data parsing module is used to acquire TLE orbit data of several satellites and parse out the satellite orbit element parameters of each satellite. Tensor initialization module, which is used to convert the satellite orbital element parameters of each satellite into an intermediate tensor set with batch dimension; The parallel computing module is used to perform tensor parallel processing based on the improved SGP4 algorithm. The processing includes: The coefficients used to describe long-term and short-term perturbations in the SGP4 model are calculated based on the intermediate tensor set to obtain the tensor coefficients; Based on the intermediate tensor set, tensor coefficients, and preset timestamp sequence, the orbital state time evolution is performed in the geocentric inertial frame using the tensor broadcasting mechanism to obtain orbital state variables, and the geographic parameters of each satellite in the Earth-fixed coordinate system are calculated simultaneously. Transform the orbital state variables to the Earth-fixed coordinate system; Based on the orbital state variables in the Earth-fixed coordinate system, the geographic parameters of each satellite, and the position tensor of the ground station, the observation parameters of the satellite relative to the ground station are calculated using tensor trigonometric functions and vector projection operations.

Images