A Python-based Fast Statistical Analysis System and Method for GNSS Synchronous and Asynchronous Loops

Abstract

This invention discloses a rapid statistical analysis system and method for GNSS synchronous and asynchronous loops based on Python. The statistical system includes a data preprocessing module, a data reading module, a loop identification module, a loop parameter calculation module, and a result output module. The specific steps are as follows: GNSS baseline data is preprocessed for reading and statistical analysis by the data reading module; the preprocessed GNSS baseline data is read, useful observation information is extracted, and a standard list dataset is generated; valid synchronous and asynchronous loops are identified using a specific algorithm; key parameters are calculated for the identified synchronous and asynchronous loops; and the statistically calculated information on synchronous and asynchronous loops is output in an intuitive manner. This invention enables rapid statistical analysis of all synchronous and asynchronous loop information in GNSS data, greatly improving work efficiency and accuracy, and possesses good versatility and scalability.

Description

Technical Field

[0001] This invention relates to the field of Global Navigation Satellite System (GNSS) data processing, specifically to a system and method for automatically identifying and rapidly statistically analyzing GNSS synchronous and asynchronous loops based on the Python programming language. Background Technology

[0002] In GNSS measurements, the statistical analysis of synchronous and asynchronous loops is crucial for evaluating the quality and reliability of measurement data. A synchronous loop is a closed loop formed by observation baselines observed at the same time, while an asynchronous loop is a closed loop formed by observation baselines observed at different times. Accurately analyzing the parameters of synchronous and asynchronous loops, such as closure error and PPM, can help determine whether there are problems such as errors or signal interference during the measurement process.

[0003] However, existing synchronous and asynchronous ring statistical techniques have limitations, including at least the following problems: First, ring statistics rely entirely on GNSS software, lacking specialized and independent statistical tools; second, the statistical methods also have many shortcomings. Existing methods include manual statistics and automated statistics using software. Manual statistics are prone to errors, especially when processing large amounts of GNSS data, resulting in extremely low efficiency; while automated statistics using software, although time-saving, suffer from problems such as not distinguishing between synchronous and asynchronous rings and incomplete counting of effective rings; finally, some software tools may be specific to certain operating systems or hardware environments, lacking versatility and flexibility.

[0004] With the rapid development of the times, Python, as an efficient, flexible and powerful programming language, is widely used in fields such as data processing and text analysis, providing technical support and tools for GNSS data processing. Through its rich third-party libraries, such as csv, itertools and fractions, Python can efficiently solve problems such as data input and output, classification and combination, and index calculation in GNSS data processing. Therefore, a fast statistical analysis system and method for GNSS synchronous and asynchronous loops based on Python has emerged. Summary of the Invention

[0005] To address the shortcomings of existing technologies, this invention provides a Python-based system and method for rapid statistical analysis of GNSS synchronous and asynchronous loops. This system can efficiently and accurately collect information on all synchronous and asynchronous loops in GNSS data, improving data processing efficiency and the accuracy of quality assessment, and also has good versatility and scalability.

[0006] To achieve the above objectives, this invention provides a Python-based rapid statistical system for GNSS synchronous and asynchronous rings. The statistical system includes a data preprocessing module, a data reading module, a ring identification module, a ring parameter calculation module, and a result output module.

[0007] The data preprocessing module is used to preprocess GNSS baseline data, which is then read and statistically analyzed by the data reading module.

[0008] The data reading module is used to read preprocessed GNSS baseline data, extract useful observation information, and generate a standard list dataset, including start point, end point, time period, DX, DY, DZ, and slant range.

[0009] The ring identification module identifies valid synchronous and asynchronous rings based on the read observation information using a specific algorithm. This module employs dynamic path construction and a multi-starting-point trial mechanism to ensure that the first suitable closed path is found when multiple potential rings exist, while strictly satisfying vector and mathematical closure requirements to achieve the search and calculation of all valid rings. This module uses efficient data structures and algorithms to quickly traverse and analyze large amounts of data, accurately identifying all valid synchronous and asynchronous rings.

[0010] The parameter calculation module calculates key parameters for the identified synchronous and asynchronous loops, such as closure error, PPM, ratio, and total loop length.

[0011] The result output module outputs the statistically calculated information of the synchronous and asynchronous rings in an intuitive way. This module supports multiple output formats such as text and table formats, and can directly output to a specified file on a specified drive, so that the number, parameters and other information of the synchronous and asynchronous rings can be easily viewed in the future.

[0012] A further technical solution of the present invention: The data preprocessing involves performing the following processing on baseline data exported from GNSS software in various formats: adding time period columns to the file, specifying header information, and converting the data to a specified CSV format for storage, while also supporting other common data formats; the baseline data includes start point, end point, storage status, static ambiguity, GNSS type, start time, time period length, type, solution type, frequency, DX, DY, DZ, plane accuracy, elevation accuracy, plane + elevation accuracy, slant range, slant range standard deviation, reference station antenna height, and rover antenna height. The information and names exported by different software are not entirely the same; the header must include multiple columns such as start point (start), end point (end), time period (period), DX (dx), DY (dy), DZ (dz), and slant range (ds). The column names should be consistent with the above description, and Chinese, English, or a mixture of both are acceptable.

[0013] A further technical solution of the present invention: The data reading module uses Python's csv library to read the file content, parses out the start point, end point, time period, DX, DY, DZ and slope distance information according to the csv format specification, and stores them in a list data structure.

[0014] A further technical solution of the present invention: identifying valid synchronous rings and valid asynchronous rings using a specific algorithm specifically includes the following steps:

[0015] (1) Based on the read data, using the entire side length as the unit, the powerful permutation and combination and its own logical judgment function of the third-party library itertools in Python are used to identify all rings, including 3-sided rings, 4-sided rings and 5-sided rings.

[0016] (2) Perform multi-starting point trial mechanism, dual-mode connection detection, dynamic path verification and error prevention mechanism operation on all loops identified in step (1) to find all valid loops that meet the requirements of vector and mathematical closure;

[0017] (3) The effective synchronous loop and the effective asynchronous loop are distinguished by comparing the time period values ​​in each effective loop. Because the time period column was edited in the preprocessing, the same value was assigned to the synchronous observation time period. Here, the effective synchronous loop and the effective asynchronous loop are judged based on the time period values ​​in each effective loop. If all the time period values ​​in the effective loop are the same, it is determined to be an effective synchronous loop; otherwise, it is an effective asynchronous loop.

[0018] The preferred technical solution of the present invention is as follows: the key parameters calculated by the parameter calculation module include the closure difference, ratio, PPM (parts per million relative error), and total loop length of the synchronous and asynchronous loops;

[0019] The key parameter calculation in the parameter calculation module utilizes Python's numpy, math, and fractions libraries for efficient numerical computation.

[0020] The preferred technical solution of the present invention is as follows: the result output module is used to directly display the total information of the synchronous ring and asynchronous ring obtained by the parameter calculation module in the form of an interface. The detailed parameter information is used to create a data table using Python's os library and csv library, and output in csv format to a specified file on a specified drive.

[0021] To achieve the above technical objectives, this invention also provides a Python-based method for rapid statistical analysis of GNSS synchronous and asynchronous rings. The statistical analysis is performed using the aforementioned Python-based rapid statistical analysis system for GNSS synchronous and asynchronous rings, specifically including the following steps:

[0022] S1. Preprocess the baseline data exported from the GNSS software; the preprocessing specifically includes adding a "time period" column to the file and setting the header information, and converting the GNSS data into a format that is easy to read;

[0023] S2. By using Python's file reading and parsing libraries, observation information in the data can be extracted quickly and accurately, including start point, end point, time period, DX, DY, DZ, and slope distance;

[0024] S3. Based on the read data, using the entire side length column as the unit, the powerful permutation and combination function of the Python third-party library itertools and its own logical judgment function are used to identify all the cycles. Then, the valid cycles that meet the requirements of vector and mathematical closure are identified, and the valid cycles are distinguished as valid synchronous cycles and valid asynchronous cycles by the consistency of time periods.

[0025] S4. For the identified valid synchronous and asynchronous loops, calculate the parameters of the valid synchronous and asynchronous loops by accurately determining the vector direction and using Python's numerical calculation library; the specific parameters calculated include closure error, ratio, PPM, and total loop length.

[0026] S5. Output the parameters of the effective synchronous ring and effective asynchronous ring obtained from the statistics and calculations in step S4 in an intuitive way.

[0027] The preferred technical solution of the present invention is as follows: In step S1, the header information includes the start point, end point, time period, DX, DY, DZ and slope distance, and the column names are consistent with the above description, using Chinese, English or a combination thereof; the GNSS data is converted into CSV format for storage.

[0028] The preferred technical solution of this invention: The process of determining the valid ring in step S3 is as follows:

[0029] S301. A multi-starting-point trial mechanism is adopted, which uses an outer loop to traverse all edges as the starting edge to avoid missing other possible cycles due to the fixed use of the first edge.

[0030] S302. Dual-mode connection detection: When the current endpoint is equal to the starting point of the next edge, perform forward connection matching; when the current endpoint is equal to the endpoint of the next edge, perform reverse connection matching; at the same time, the coordinate components of the detected reverse connection matching edge length are assigned in reverse.

[0031] S303. Dynamic Path Verification: Check for closure immediately after each new edge is added. The path must contain at least 3 edges, and the path closure condition must be set: the ending name of the newly added edge must be the same as the starting name of the starting edge.

[0032] S304. Error prevention mechanism: Prevent the use of repeated edges and set termination conditions to avoid infinite loops.

[0033] The preferred technical solution of this invention: In step S4, the closure error, PPM (parts per million), ratio, and total ring length of the effective synchronous ring and the effective asynchronous ring are calculated based on the DX, DY, DZ and slope distance of each edge in the ring; the specific process is as follows:

[0034]

[0035]

[0036]

[0037]

[0038]

[0039] PPM = W S / L*1000000

[0040] R A = 1 / PPM * 1000000

[0041] In the above formula: n—number of ring side lengths; L—total ring length, in meters; R A — Ratio;

[0042] DS—Slope distance; PPM—Parts per million of relative error; —The total closure error of the loop, in meters;

[0043] — This represents the closure difference of the three-dimensional coordinate components in the X, Y, and Z directions of the ring, in meters.

[0044] Compared with the prior art, the present invention has the following characteristics and beneficial effects:

[0045] (1) This invention proposes an innovative method for fast statistical analysis of GNSS synchronous and asynchronous rings based on Python. It does not rely on any GNSS software and is an independent and complete small program for statistical analysis of GNSS synchronous and asynchronous rings. It can be run directly without installation.

[0046] (2) This invention utilizes Python’s concise syntax and rich library resources, and uses a modular parallel processing framework to quickly process large amounts of GNSS data, greatly shortening the statistical time of synchronous and asynchronous loops and improving work efficiency.

[0047] (3) This invention optimizes ring identification by using the length of the entire column as the unit for combination ring finding, and adopts measures such as multi-starting point trial mechanism, dual-mode connection detection, dynamic path verification and error prevention mechanism to ensure the accuracy of effective rings; at the same time, by selecting a suitable mathematical model and appropriate Python library, it has high accuracy in parameter calculation, ensuring the reliability of GNSS data quality assessment; this invention utilizes the cross-platform characteristics of Python language, can run on multiple operating systems, and can be easily integrated with other data processing tools, with good versatility and scalability. Attached Figure Description

[0048] Figure 1 This is a system flowchart of the present invention;

[0049] Figure 2 This is a flowchart of the ring recognition module algorithm in this invention;

[0050] Figure 3 This is a screenshot showing the interface display effect in the embodiment. Detailed Implementation

[0051] To enable those skilled in the art to better understand the technical solutions of this disclosure, and to fully understand and implement the process of how this disclosure applies technical means to solve technical problems and achieve corresponding technical effects, the technical solutions of the embodiments of this invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this invention, and not all embodiments. All other embodiments obtained by those skilled in the art based on the embodiments of this invention without creative effort are within the scope of protection of this invention.

[0052] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention pertains. The terminology used herein in the description of the invention is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention.

[0053] The embodiment provides a Python-based fast statistical system for GNSS synchronous and asynchronous rings. The statistical system includes a data preprocessing module, a data reading module, a ring identification module, a ring parameter calculation module, and a result output module.

[0054] The data preprocessing module is used to preprocess GNSS baseline data for reading and statistical analysis by the data reading module. The data preprocessing involves the following steps on baseline data exported from GNSS software in various formats: adding time period columns to the file, specifying header information, and converting the data to a specified CSV format for storage. Other common data formats are also supported. The baseline data includes start point, end point, storage status, static ambiguity, GNSS type, start time, time period length, type, solution type, frequency, DX, DY, DZ, plane accuracy, elevation accuracy, plane + elevation accuracy, slant range, slant range standard deviation, reference station antenna height, and rover antenna height. The information and names exported by different software may vary. The header must include multiple columns: start point, end point, time period, DX (dx), DY (dy), DZ (dz), and slant range (ds). Column names should be consistent with the above description; Chinese, English, or a combination of both are acceptable.

[0055] The data reading module is used to read preprocessed GNSS baseline data, extract useful observation information, and generate a standard list dataset. The data reading module uses Python's csv library to read the file content, parses the start point, end point, time period, DX, DY, DZ, and slant range information according to the csv format, and stores them in a list data structure.

[0056] The ring identification module identifies valid synchronous and asynchronous rings based on the read observation information using a specific algorithm. This module employs dynamic path construction and a multi-starting-point trial mechanism to ensure that the first suitable closed path is found when multiple potential rings exist, while strictly satisfying vector and mathematical closure requirements to achieve the search and calculation of all valid rings. This module uses efficient data structures and algorithms to quickly traverse and analyze large amounts of data, accurately identifying all valid synchronous and asynchronous rings.

[0057] Identifying valid synchronous and asynchronous rings using specific algorithms includes the following steps:

[0058] (1) Based on the read data, using the entire side length as the unit, the powerful permutation and combination and its own logical judgment function of the third-party library itertools in Python are used to identify all rings, including 3-sided rings, 4-sided rings and 5-sided rings.

[0059] (2) Perform multi-starting point trial mechanism, dual-mode connection detection, dynamic path verification and error prevention mechanism operation on all loops identified in step (1) to find all valid loops that meet the requirements of vector and mathematical closure;

[0060] (3) The effective synchronous loop and the effective asynchronous loop are distinguished by comparing the time period values ​​in each effective loop. Because the time period column was edited in the preprocessing, the same value was assigned to the synchronous observation time period. Here, the effective synchronous loop and the effective asynchronous loop are judged based on the time period values ​​in each effective loop. If all the time period values ​​in the effective loop are the same, it is determined to be an effective synchronous loop; otherwise, it is an effective asynchronous loop.

[0061] The parameter calculation module calculates key parameters for the identified synchronous and asynchronous loops. These key parameters include the closure error, ratio, PPM (parts per million relative error), and total loop length. The closure error includes the total loop closure error and the coordinate component closure error. The module utilizes Python's numpy, math, and fractions libraries for efficient numerical computation. By accurately determining vector directions and leveraging Python's numerical computation libraries, this module can quickly and accurately calculate various parameters, providing a basis for subsequent data quality assessment. The calculations for each parameter are as follows:

[0062]

[0063]

[0064]

[0065]

[0066]

[0067] PPM = W S / L*1000000

[0068] R A = 1 / PPM * 1000000

[0069] In the above formula: n—number of ring side lengths; L—total ring length, in meters; R A -ratio;

[0070] DS—Slope distance; PPM—Parts per million of relative error;

[0071] W X —The closure error of the X-axis coordinate component of the loop, in meters; W Y —The closure error of the Y-axis coordinate components of the loop, in meters; W Z —The Z-direction coordinate component closure error of the loop, in meters; —The total closure difference of the loop, in meters.

[0072] The result output module outputs the statistically calculated information of synchronous and asynchronous loops in an intuitive manner. This module supports multiple output formats, including text and tables, and directly outputs the data to a specified file on a specified drive. This allows for convenient viewing of the number and parameters of synchronous and asynchronous loops later. The module also displays the total information of synchronous and asynchronous loops obtained from the parameter calculation module in a graphical interface. Detailed parameter information is generated using Python's `os` and `csv` libraries to create data tables, which are then output as CSV files to a specified file on a specified drive.

[0073] The statistical method of the present invention will be further described below with reference to specific embodiments, and the specific steps are as follows:

[0074] S1. The baseline data exported from the GNSS software is processed by the data preprocessing module to facilitate program reading and calculation. The preprocessing includes: ① adding a "period" column to the file; ② setting the header information: the header must include columns such as start, end, period, DX (dx), DY (dy), DZ (dz), and slant distance (ds). The column names should be consistent with the above description. Chinese, English, or a mixture of both are acceptable; ③ the program can support a variety of common data formats. This system uses the commonly used CSV format for storage.

[0075] S2. Read the pre-processed GNSS data file through the data reading module, extract useful observation information and generate a standard list dataset; Read the processed CSV format data file through the interface, using Python's csv library to read the file content; First, open the data file, read the data line by line, and parse out key information such as start, end, period, DX (dx), DY (dy), DZ (dz), and slant distance (ds) according to the CSV format specifications, and store it in a list data structure;

[0076] The data reading module is implemented as follows:

[0077] S3. Based on the read data, the ring recognition module uses the entire side length column as a unit and the powerful permutation and combination function of the Python third-party library itertools and its own logical judgment function to identify all rings. Then, it determines the valid rings that meet the requirements of vector and mathematical closure, and distinguishes the valid rings from the valid rings by the consistency of time periods.

[0078] The specific identification process is as follows:

[0079] (1) Valid ring identification: First, use the powerful permutation and combination and its own logical judgment function of the third-party library itertools in Python to form all rings (3-point ring, 4-point ring, 5-point ring, etc.) using the baseline sequence as the unit.

[0080] (2) Then perform the following operations on all the cycles: ① Use a multi-starting point trial mechanism, traverse all edges as starting edges through the outer loop to avoid missing other possible cycles due to the fixed use of the first edge; ② Dual-mode connection detection: forward connection matching (current endpoint = starting point of the next edge), reverse connection matching (current endpoint = endpoint of the next edge); ③ Dynamic path verification: check whether it is closed immediately after each new edge is added, requiring the path to contain at least 3 edges (to prevent AB-BA pseudo-cycles), and set the path closure condition: the end name of the newly added edge is consistent with the start name of the starting edge; ④ Error prevention mechanism: prevent the use of duplicate edges, set termination conditions to avoid infinite loops, etc.

[0081] (3) By using dynamic path construction and multi-starting point trial mechanism, we can ensure that the first closed path that meets the conditions can be found when there are multiple potential cycles. At the same time, we strictly meet the vector and mathematical closure requirements to realize the search and calculation of all valid cycles.

[0082] (4) Distinguishing between valid synchronous loops and valid asynchronous loops: Synchronous loops and asynchronous loops are distinguished by comparing the number of time periods in the valid loops. For example, if the number of time periods in the loops are the same, it is determined to be a synchronous loop; otherwise, it is an asynchronous loop.

[0083] The ring recognition implementation program is as follows:

[0084] The program for valid ring identification is as follows:

[0085] The program for identifying synchronous and asynchronous rings is as follows:

[0086] S4. The parameter calculation module calculates various parameters of the identified valid synchronous and asynchronous loops by accurately determining the vector direction and using Python's numerical calculation library. Specific parameters include closure error, ratio, PPM, and total loop length. Taking closure error calculation as an example, the closure error of each loop is calculated using mathematical formulas for vector operations based on the coordinate information of the baseline vector. Efficient numerical calculations are performed using Python's numpy, math, and fractions libraries to ensure the accuracy of the results.

[0087] The parameter calculation implementation program is as follows:

[0088] S5. The results output module directly displays the total information of effective synchronous loops and effective asynchronous loops obtained from the statistics and calculations in step S4 in an interface. For detailed parameter information, the Python os library and csv library are used to create data tables and output them as CSV files in a specified file on a specified drive. This makes it convenient to view the detailed information of synchronous loops and asynchronous loops and assess data quality in the future.

[0089] The program that outputs the result is as follows:

[0090] Practical Application Results and Experimental Verification: The following uses GNSS control network data from 14 time periods processed by Leica software to run this program, and the interface effect is as follows. Figure 3 As shown:

[0091] The file looks like this (partial data):

[0092] ['15049','22042']-['22042','22085']-['22085','15049'] 0.0005 0.0876 1 / 11410904 0 -0.0003 -0.0004 5705.4522 Synchronization loop ['15049','22042']-['22042','22085']-['22085','22016']-['22016','15049'] 0.0015 0.2127 1 / 4700815 0.0002 -0.0011 -0.001 7051.2231 Synchronization loop ['15049','22042']-['22042','22085']-['22085','22053']-['22053','15049'] 0.0237 3.2006 1 / 312439 0.002 -0.0199 0.0128 7404.8147 Asynchronous ring ['15049','22042']-['22042','22085']-['22085','22089']-['22089','22053']-['22053','15049'] 0.0253 3.358 1 / 297792 0.003 -0.0222 0.0118 7534.1376 Asynchronous ring

[0093] Then, using the same observation data, we performed statistical processing of synchronous and asynchronous loops using traditional processing software (Leica software as an example). The results are as follows:

[0094] ① Automatic software processing: Although it takes very little time, it only counts 37 valid rings, and it does not distinguish between synchronous and asynchronous rings. The program's count is 1811 valid rings, including 98 synchronous rings and 1713 asynchronous rings. Upon comparison, it was found that the software's automatic ring count significantly missed some rings.

[0095] ② Manual statistics: Only a portion of the rings were counted, which took several hours. If all 1811 rings were counted, it would take days. Moreover, rings are easily missed, duplicated, or even incorrect.

[0096] Experimental results show that, compared with traditional GNSS processing software, this program has a response time measured in seconds when statistically analyzing synchronous and asynchronous loops, which is far more efficient than manual statistics, and data integrity is guaranteed. This demonstrates the effectiveness and superiority of the Python-based GNSS data processing method.

[0097] The above description is merely one embodiment of the present invention, and while it is detailed and specific, it should not be construed as limiting the scope of the invention. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of the present invention, and these modifications and improvements all fall within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the appended claims.

Claims

1. A fast statistical system for GNSS synchronous and asynchronous loops based on Python, characterized in that: The statistical system includes a data preprocessing module, a data reading module, a ring identification module, a ring parameter calculation module, and a result output module; The data preprocessing module is used to preprocess GNSS baseline data, which is then read and statistically analyzed by the data reading module. The data reading module is used to read preprocessed GNSS baseline data, extract useful observation information from it, and generate a standard list dataset. The ring identification module identifies valid synchronous rings and valid asynchronous rings based on the read observation information using a specific algorithm; the process of determining valid rings is as follows: A multi-starting-point trial mechanism is adopted, which uses an outer loop to traverse all edges as the starting edge to avoid missing other possible cycles due to the fixed use of the first edge. Dual-mode connection detection: When the current endpoint equals the starting point of the next edge, perform a sequential connection matching; when the current endpoint equals the endpoint of the next edge, perform a reverse connection matching. Dynamic path verification: Check whether the path is closed immediately after each new edge is added. The path must contain at least 3 edges, and the path closure condition is set: the ending name of the newly added edge must be the same as the starting name of the starting edge. Error prevention mechanism: Prevent the use of repeated edges and set termination conditions to avoid infinite loops; The parameter calculation module calculates the key parameters for the identified synchronous and asynchronous rings; The result output module outputs the statistically calculated information of the synchronous and asynchronous rings in an intuitive way.

2. The fast statistical program for GNSS synchronous and asynchronous loops based on Python according to claim 1, characterized in that: The data preprocessing involves performing the following steps on baseline data exported from GNSS software in various formats: adding time period columns to the file, specifying header information, and converting the data to a specified CSV format. The baseline data includes the start point, end point, storage status, static ambiguity, GNSS type, start time, time period length, type, solution type, frequency, DX, DY, DZ, plane accuracy, elevation accuracy, plane + elevation accuracy, slant range, slant range standard deviation, reference station antenna height, and rover antenna height. The header must include the start point, end point, time period, DX, DY, DZ, and slant range.

3. A fast statistical system for GNSS synchronous and asynchronous loops based on Python, as described in claim 1 or 2, characterized in that... The data reading module uses Python's csv library to read file content, parses out the start point, end point, time period, DX, DY, DZ and slope distance information according to the csv format specification, and stores it in a list data structure.

4. A fast statistical system for GNSS synchronous and asynchronous loops based on Python, as described in claim 1 or 2, characterized in that... Identifying valid synchronous and asynchronous rings using specific algorithms includes the following steps: (1) Based on the read data, using the entire side length as the unit, the powerful permutation and combination and its own logical judgment function of the third-party library itertools in Python are used to identify all the rings; (2) Perform multi-starting point trial mechanism, dual-mode connection detection, dynamic path verification and error prevention mechanism operation on all loops identified in step (1) to find all valid loops that meet the requirements of vector and mathematical closure; (3) Distinguish between effective synchronous loops and effective asynchronous loops by comparing the time period values ​​in each effective loop; If the number of time periods in a valid ring is the same, it is determined to be a valid synchronous ring; otherwise, it is a valid asynchronous ring.

5. A fast statistical system for GNSS synchronous and asynchronous loops based on Python, as described in claim 1 or 2, characterized in that: The key parameters calculated by the parameter calculation module include the closure difference, ratio, PPM, and total ring length of the synchronous and asynchronous rings. The key parameter calculation in the parameter calculation module utilizes Python's math and fractions libraries for efficient numerical computation.

6. A fast statistical system for GNSS synchronous and asynchronous rings based on Python, as described in claim 1 or 2, characterized in that: The result output module is used to directly display the total information of the synchronous and asynchronous rings obtained by the parameter calculation module in a graphical interface. Detailed parameter information is generated by creating data tables using Python's os and csv libraries and output in CSV format to a specified file on a specified drive.

7. A fast statistical method for GNSS synchronous and asynchronous loops based on Python, characterized in that, The statistical method is based on the Python-based fast statistical system for GNSS synchronous and asynchronous rings as described in any one of claims 1 to 6, and specifically includes the following steps: S1. Preprocess the baseline data exported from the GNSS software; the preprocessing specifically includes adding a "time period" column to the file and setting the header information, and converting the GNSS data into a format that is easy to read; S2. By using Python's file reading and parsing libraries, observation information in the data can be extracted quickly and accurately, including start point, end point, time period, DX, DY, DZ, and slope distance; S3. Based on the read data, using the entire side length column as the unit, the powerful permutation and combination function of the Python third-party library itertools and its own logical judgment function are used to identify all the cycles. Then, the valid cycles that meet the requirements of vector and mathematical closure are identified, and the valid cycles are distinguished as valid synchronous cycles and valid asynchronous cycles by the consistency of time periods. S4. For the identified valid synchronous and asynchronous loops, calculate the parameters of the valid synchronous and asynchronous loops by accurately determining the vector direction and using Python's numerical computing library; the specific parameters calculated include closure error, ratio, PPM, and total loop length. S5. Output the parameters of the effective synchronous ring and effective asynchronous ring obtained from the statistics and calculations in step S4 in an intuitive way.

8. The fast statistical method for GNSS synchronous and asynchronous loops based on Python according to claim 7, characterized in that: In step S1, the header information includes the start point, end point, time period, DX, DY, DZ, and slant distance. The column names are consistent with the above description and can be in Chinese, English, or a combination thereof. The GNSS data is converted to CSV format for storage.

9. A fast statistical method for GNSS synchronous and asynchronous loops based on Python, as described in claim 7, characterized in that... In step S4, the closure difference, PPM, ratio, and total ring length of the effective synchronous and asynchronous rings are calculated based on the DX, DY, DZ, and slope distance of each edge in the ring. The specific process is as follows: ； ； ； ； ； PPM = W S / L*1000000; R A = 1 / PPM *1000000; In the above formula: n—number of ring side lengths; L—total ring length, in meters; R A — Ratio; DS—Slope distance; PPM—Parts per million of relative error; —The total closure error of the loop, in meters; — This represents the closure difference of the three-dimensional coordinate components in the X, Y, and Z directions of the ring, in meters.

Images