Baseline resolving method and system

Abstract

The invention discloses a baseline resolving method and system. The method comprises the following steps: carrying out Hash coding and clustering on fixed solution coordinates of each epoch, establishing longitude and latitude frequency mapping, and screening out initial coordinates without gross errors; and in combination with double-difference ambiguity data collected in a fixed solution process, constructing ambiguity retention mapping, and performing screening according to ambiguity retention duration. And a non-combined ambiguity repairing strategy and an ionosphere-free combined ambiguity repairing strategy are adopted for repairing, so that the reliability of ambiguity is improved. On the basis, a least square adjustment method is utilized to carry out overall adjustment on all observation values, and a final positioning result is optimized. Through refined coordinate screening, ambiguity restoration and adjustment optimization, the problem of large deviation of a fixed solution in the prior art is solved, the positioning precision is improved, the anti-interference capability is enhanced, and the stability of the system is ensured.

Description

Technical Field

[0001] The present invention belongs to the technical field of positioning, and more specifically, relates to a baseline solution method and system. Background Art

[0002] The traditional baseline solution method is to construct a baseline and ambiguity variance-covariance matrix. When a cycle slip occurs in the ambiguity, new ambiguity parameters are added, and then all the observed values are input to update the floating-point ambiguity. Finally, the ambiguity is fixed to obtain the baseline solution result. When the observation environment is poor and cycle slips or gross errors occur frequently, it is easy to increase the dimension of the baseline and ambiguity variance-covariance matrix, which is not conducive to ambiguity search. In addition, if the observation data is long and the variance of the floating-point solution is very small after convergence, it means that if a gross error is mixed in before the floating-point solution converges, it will be difficult to correct the previous deviation even if the gross error is processed correctly later, which may cause deviation in the final fixed solution.

[0003] The prior art patent with publication number CN119291745A proposes a UAV PPK post-processing method and device that combines filtering and ambiguity processing. This method involves multiple filtering of UAV positioning data and fusing the results of multiple filterings, and is relatively weak in adjustment optimization, multi-initial value processing, and anti-interference mechanisms. Summary of the Invention

[0004] In order to overcome the large deviation of the fixed solution in the prior art and the deficiencies in adjustment optimization, multi-initial value processing, and anti-interference mechanisms, the present invention provides a baseline solution method and system.

[0005] The primary object of the present invention is to solve the above technical problems, and the technical solution of the present invention is as follows:

[0006] The first aspect of the present invention provides a baseline solution method, including the following steps:

[0007] Calculate the fixed solution coordinates for the observed data of each epoch, and convert the fixed solution coordinates into latitude, longitude, and geodetic height;

[0008] Perform hash encoding and clustering on the latitude and longitude corresponding to the fixed solution coordinates of each epoch to obtain a mapping with the frequency of occurrence of the latitude and longitude coordinates as the key and the average geodetic coordinates of the latitude and longitude as the value;

[0009] Use the mapping to screen the fixed solution coordinates, eliminate the coordinate information containing gross errors, and output the initial coordinates;

[0010] Construct a ambiguity retention mapping using the double-difference ambiguities collected during the process of obtaining the fixed solution, screen the ambiguity data according to the ambiguity retention duration data in the mapping, and repair the screened ambiguities using the non-combination ambiguity repair strategy and the ionosphere-free combination ambiguity repair strategy to obtain the repaired ambiguities;

[0011] According to the initial coordinates and the repaired ambiguities, perform overall adjustment on all observations using the least squares adjustment method to obtain the adjustment result.

[0012] Further, the preset method for calculating the geocentric earth-fixed coordinates from the observation data of each epoch is the post-processing real-time kinematic positioning algorithm.

[0013] Further, perform hash encoding and clustering on the latitude and longitude corresponding to the fixed solution coordinates of each epoch, including the following steps:

[0014] Add π / 2 to the latitude to adjust the latitude range to [0, π); add π to the longitude to adjust the longitude range to [0, 2π);

[0015] Perform bit operations and precision adjustment on the adjusted latitude and longitude, and output the hash encoding value of n-bit unsigned integer type;

[0016] Use the hash encoding value as the key, record the latitude, longitude and geodetic height of each observation point, and form a hash mapping of the geodetic coordinates;

[0017] According to the hash encoding in the hash mapping, calculate the coordinate occurrence frequency of each geodetic coordinate in all epochs;

[0018] For each geodetic coordinate, calculate the average geodetic coordinate of this position based on the latitude, longitude and geodetic height corresponding to its occurrence frequency;

[0019] Use the coordinate occurrence frequency as the key and the average geodetic coordinate as the value to construct the mapping relationship between the coordinate occurrence frequency and the average geodetic coordinate.

[0020] Further, the clustering is stored and retrieved using a red-black tree.

[0021] Further, the method for screening the fixed solution coordinates using the mapping is: obtain the maximum value of all coordinate occurrence frequencies in the mapping. If the occurrence frequency of the fixed solution coordinate is less than n% of the maximum frequency, then ignore this fixed solution coordinate; otherwise, retain this fixed solution coordinate for subsequent calculations.

[0022] Further, constructing the ambiguity retention mapping using the double-difference ambiguities collected during the process of obtaining the fixed solution includes the following steps:

[0023] Collect the double-difference ambiguity data of each epoch during the process of obtaining the fixed solution, including the reference satellite ID, the current satellite ID, the ambiguity frequency point identifier, the start time of ambiguity retention, the end time of ambiguity retention, and the double-difference fixed ambiguity value;

[0024] Use the reference satellite ID, the current satellite ID, and the ambiguity frequency point identifier as the keys of the ambiguity retention mapping, and use the start time of ambiguity retention, the end time of ambiguity retention, and the double-difference fixed ambiguity value as the values to construct the ambiguity retention mapping using the obtained ambiguity data;

[0025] Filter according to the ambiguity retention duration, select the records of the top m% with the longest ambiguity retention time, and output the filtered ambiguity retention mapping.

[0026] Furthermore, the method for constructing the ambiguity retention mapping includes the following steps:

[0027] Traverse the ambiguity data of each fixed solution, insert it into the ambiguity retention mapping, and make a judgment during the insertion process. If the key of the ambiguity data already exists in the mapping, then check the difference between the current ambiguity value and the existing ambiguity. If the difference is less than the preset threshold, it is considered that the ambiguity retention has no change, and the end time is updated; otherwise, insert a new ambiguity record;

[0028] For the existing ambiguity records, check whether a reference exchange occurs. If an exchange occurs, update the ambiguity records according to the exchange rules to make them consistent, and obtain the updated ambiguity retention mapping.

[0029] Furthermore, using the non-combination ambiguity repair strategy for ambiguity repair includes the following steps:

[0030] Obtain the preset ambiguity repair range [-fcy, +fcy], use each offset value within this range to try to adjust the ambiguity one by one, and calculate the residual after repair. The expression is as follows:

[0031] res i = res + i * lam

[0032] where res represents the initial value of the double-difference residual, lam represents the frequency point wavelength, res i represents the double-difference residual corresponding to the value i. During the traversal process, record the minimum value res0 of the double-difference residual and the corresponding repair offset value i0;

[0033] If i0 = 0, it means that no repair is required, and output the repair flag flg = 0;

[0034] If the current double-difference residual res is less than half of the wavelength, it means that the repair is meaningless, and output the repair flag flg = -1;

[0035] If the minimum value res0 of the double-difference residual satisfies res0 < ratio * lam, it indicates successful repair. Here, ratio is a preset threshold, and the repair flag flg = 1 and the repaired residual value res are output. fix = res0; if res0 < ratio * lam is not satisfied, it indicates failed repair, and the repair flag flg = -1 is output.

[0036] Based on the repair flag flg and the repaired residual value res fix , the ambiguity data is updated.

[0037] The ambiguity repair is performed using the ionosphere-free combination ambiguity repair strategy, including the following steps:

[0038] Obtain the preset ambiguity repair range [-fcy, +fcy], and use each offset value within this range to try to adjust the ambiguity one by one, and calculate the double-difference residual after repair. The expression is as follows:

[0039] res i = res + i * a1 * lam1 + j * a2 * lam2

[0040] where res represents the initial value of the double-difference residual, lam1 and lam2 represent the wavelengths of the first frequency and the second frequency, res i represents the double-difference residual corresponding to the values i and j of the ambiguity repair range, a1 and a2 represent the coefficients of the ionosphere-free combination, and the minimum value res0 of the double-difference residual and the corresponding repair offset values i0 and j0 are recorded during the traversal process.

[0041] If i0 = 0 and j0 = 0, it indicates that no repair is required, and the repair flag flg = 0 is output.

[0042] If is satisfied, it indicates that the repair is meaningless, and the repair flag flg = -1 is output.

[0043] If is satisfied, it indicates successful repair. Here, ratio is a preset threshold, and the repair flag flg = 1 and the repaired residual value res are output. fix = res0; if not satisfied, it indicates failed repair, and the repair flag flg = -1 is output.

[0044] Based on the repair flag flg and the repaired residual value res fix , the ambiguity data is updated.

[0045] Furthermore, the least squares adjustment method is used to perform overall adjustment on all observations, including the following steps:

[0046] Traverse in the order of maintaining ambiguity from long to short in terms of maintaining time, and combine the reference satellite ID and the current satellite ID to calculate the observed value and the satellite baseline in sequence.

[0047] Calculate the satellite-earth distance according to the receiver baseline data and the satellite baseline.

[0048] Use the observed value to subtract the satellite-earth distance and the ambiguity to obtain the adjustment result.

[0049] If there are multiple groups of initial coordinates, least squares adjustment needs to be performed on each group of initial coordinates, calculate the root mean square error of each group of adjustment results, and select the adjustment result with the smallest root mean square error as the final output.

[0050] The second aspect of the present invention provides a baseline solution system, including a memory and a processor. The memory includes a baseline solution method program, and when the baseline solution method program is executed by the processor, it realizes the steps of a baseline solution method.

[0051] Compared with the prior art, the beneficial effects of the technical solution of the present invention are:

[0052] Through the adjustment optimization method and the ambiguity maintenance and repair strategy, the present invention provides fine correction of the observed data and optimized selection of multiple groups of initial values, overcoming the problem of large fixed solution deviation in the prior art. Through least squares adjustment, overall optimization of all observed values is carried out to ensure that the final positioning result is more accurate, significantly improving the positioning accuracy. In addition, the solution ensures the accuracy and reliability of the final result through multi-initial value processing and selection of the smallest root mean square error, avoiding error accumulation caused by improper selection of initial values, and further improving the stability and anti-interference ability of the system. Description of the Drawings

[0053] In order to make the objectives and technical solutions of the present invention clearer, the present invention provides the following drawings and descriptions:

[0054] Figure 1 It is the method flow chart provided by the embodiment of the present invention. Detailed Embodiments

[0055] In order to be able to more clearly understand the above objectives, features and advantages of the present invention, the present invention will be further described in detail below with reference to the drawings and specific embodiments. It should be noted that, without conflict, the embodiments of the present application and the features in the embodiments can be combined with each other.

[0056] Many specific details are set forth in the following description in order to fully understand the present invention. However, the present invention can also be implemented in other ways different from those described herein. Therefore, the protection scope of the present invention is not limited by the specific embodiments disclosed below.

[0057] Example 1:

[0058] The present invention provides a baseline solution method. As shown in the following flowchart of a baseline solution method, the specific steps are as follows: Figure 1 Shown as a flowchart of a baseline solution method, the specific steps are as follows:

[0059] S1: Calculate the fixed solution coordinates for the observation data of each epoch, and convert the fixed solution coordinates into latitude, longitude, and geodetic height.

[0060] More specifically, the preset method for calculating the Earth-centered Earth-fixed coordinates from the observation data of each epoch is the post-processing real-time kinematic positioning algorithm.

[0061] S2: Perform hash encoding and clustering on the latitude and longitude corresponding to the fixed solution coordinates of each epoch to obtain a mapping with the frequency of occurrence of the latitude and longitude coordinates as the key and the average geodetic coordinates of the latitude and longitude as the value.

[0062] More specifically, the clustering is stored and retrieved using a red-black tree.

[0063] The specific process is as follows:

[0064] Add π / 2 to the latitude to adjust the latitude range to [0, π); add π to the longitude to adjust the longitude range to [0, 2π);

[0065] Perform bit operations and precision adjustment on the adjusted latitude and longitude, and output a 64-bit unsigned integer hash encoding value for easy storage and retrieval using the red-black tree mapping;

[0066] Use the hash encoding value as the key to record the latitude, longitude, and geodetic height of each observation point to form a hash mapping of the geodetic coordinates;

[0067] According to the hash encoding in the hash mapping, calculate the frequency of occurrence of each geodetic coordinate in all epochs to obtain the number of times each position is observed, and this number reflects the stability of this position in multiple observations;

[0068] For each geodetic coordinate, calculate the average geodetic coordinate of this position based on the latitude, longitude, and geodetic height corresponding to its frequency of occurrence;

[0069] Construct a mapping relationship between the frequency of occurrence of the coordinates and the average geodetic coordinates with the frequency of occurrence of the coordinates as the key and the average geodetic coordinates as the value.

[0070] The 64-bit unsigned integer hash encoding process for latitude and longitude is as follows:

[0071] Input:

[0072] lat - latitude (double type)

[0073] lon - Longitude (double type)

[0074] prec - Precision level (int type), usually ranging from 1 to GEO_HASH_MAX_PREC_LEV. The precision levels are as follows: levels 11 - 12: millimeter level; levels 9 - 10: centimeter level; levels 7 - 8: decimeter level; levels 5 - 6: meter level; levels 3 - 4: ten - meter level; levels 1 - 2: hundred - meter level;

[0075] Output:

[0076] ihash - Encoded hash value (uint64_t type)

[0077] Constants:

[0078] GEO_HASH_MAX_PREC_LEV = 12

[0079] PI = 3.14159265358979323846 (or represented using mathematical constants)

[0080] Algorithm steps:

[0081] 1. Adjust the latitude lat to the positive range and add π / 2 to convert it to the range [0, π):

[0082] lat_adjusted = lat + PI / 2;

[0083] 2. Add π to the longitude lon to convert it to the range [0, 2π):

[0084] lon_adjusted = lon + PI;

[0085] 3. Convert the adjusted latitude and longitude to 64 - bit unsigned integers (type casting):

[0086] ilat = (uint64_t)lat_adjusted (type casting)

[0087] ilon = (uint64_t)lon_adjusted;

[0088] 4. Right - shift ilat and ilon by 20 bits and keep the lower 32 bits:

[0089] ilat >>= 20

[0090] ilon >>= 20

[0091] ilat &= 0x00000000ffffffff

[0092] ilon &= 0x00000000ffffffff;

[0093] 5. Initialize x and y to 0 (or appropriate initial values, but the initial values are not important in this algorithm as they will be overwritten later):

[0094] x = 0

[0095] y = 0;

[0096] 6. Perform a series of bit operations on x to generate a part of the Geohash value:

[0097] x = (x | (x << 16)) & 0x0000ffff0000ffff

[0098] x = (x | (x << 8)) & 0x00ff00ff00ff00ff

[0099] x = (x | (x << 4)) & 0x0f0f0f0f0f0f0f0f

[0100] x = (x | (x << 2)) & 0x3333333333333333

[0101] x = (x | (x << 1)) & 0x5555555555555555;

[0102] 7. Perform the same bit operations on y as on x to generate another part of the Geohash value;

[0103] 8. Combine x and y to form a preliminary hash value:

[0104] ihash = x | (y << 1);

[0105] 9. Shift the preliminary Geohash value to the right according to the precision level prec:

[0106] shift_amount = (GEO_HASH_MAX_PREC_LEV - prec) * 5

[0107] ihash >>= shift_amount;

[0108] 10. Return the final hash value:

[0109] return ihash.

[0110] The latitude-longitude clustering process is as follows:

[0111] Input:

[0112] listGeo: List of geodetic coordinates (vector <cgeopoint>Type, the members of CGeoPoint are the latitude m_lat, longitude m_lon, and geodetic height m_hgt, which are of double type)

[0113] prec: Precision level (used for hash encoding of latitude and longitude)

[0114] Output:

[0115] sortRes: A mapping (map<int, CGeoPoint>) with the average number of times as the key and the average geodetic coordinates as the value. Algorithm steps:

[0116] 1. Initialize an empty mapping dictHashCount (the key is the latitude and longitude hash code ihash of type uint64_t, and the value is of type CAuxItem. The members of CAuxItem are m_blh of type CGeoPoint and m_count of type average number of times);

[0117] 2. Traverse each geodetic coordinate ci in listGeo:

[0118] 1.1. Perform hash encoding on the latitude and longitude of ci to obtain ihash;

[0119] 1.2. Search for ihash in dictHashCount:

[0120] 1.2.1. If ihash is not found, insert a new key-value pair into dictHashCount, where the key is ihash and the value is a new CAuxItem (its m_blh is initialized to ci and m_count is initialized to 1);

[0121] 1.2.2. If ihash is found, update the key-value pair;

[0122] 1.2.3. Calculate the new average latitude, longitude, and height (perform weighted averaging of the current value of ci and the previous average);

[0123] 1.2.4. Increase the value of m_count;

[0124] 3. Initialize an empty mapping sortRes (the key is of type int, which is the average number of times, and the value is of type CGeoPoint);

[0125] 4. Traverse each key-value pair (ihash, auxItem) in dctHashCount:

[0126] 4.1. Insert auxItem's m_count as the key and m_blh as the value into sortRes; 5. Return sortRes.

[0127] S3: Use the mapping to screen for fixed solution coordinates, eliminate coordinate information containing gross errors, and output the initial coordinates for ambiguity fixing and adjustment.

[0128] More specifically, the method for screening fixed solution coordinates using the mapping is as follows: Obtain the maximum frequency of all coordinates in the mapping. If the frequency of the fixed solution coordinates is less than 1 / 3 of the maximum frequency, ignore the fixed solution coordinates; otherwise, retain the fixed solution coordinates for subsequent calculations.

[0129] S4: Construct an ambiguity retention mapping using the double-difference ambiguities collected during the process of obtaining the fixed solution. Screen the ambiguity data according to the ambiguity retention duration data in the mapping, select the top 80% of the ambiguities with the longest retention duration as the basis for fixing and adjustment, and use the non-combination ambiguity fixing strategy and the ionosphere-free combination ambiguity fixing strategy to fix the selected ambiguities to obtain the fixed ambiguities.

[0130] More specifically, constructing an ambiguity retention mapping using the double-difference ambiguities collected during the process of obtaining the fixed solution includes the following steps:

[0131] Collect the double-difference ambiguity data for each epoch during the process of obtaining the fixed solution, including the reference satellite ID, current satellite ID, ambiguity frequency point identifier, ambiguity retention start time, ambiguity retention end time, and double-difference fixed ambiguity value;

[0132] Use the reference satellite ID, current satellite ID, and ambiguity frequency point identifier as the keys of the ambiguity retention mapping, and use the ambiguity retention start time, ambiguity retention end time, and double-difference fixed ambiguity value as the values to construct the ambiguity retention mapping using the obtained ambiguity data;

[0133] Screen according to the ambiguity retention duration, select the top 80% of the records with the longest ambiguity retention time, and output the screened ambiguity retention mapping.

[0134] More specifically, the method for constructing the ambiguity retention mapping includes the following steps:

[0135] Traverse the ambiguity data of each fixed solution and insert it into the ambiguity retention mapping. During the insertion process, make a judgment. If the key (reference satellite ID, current satellite ID, and ambiguity frequency point identifier) of the ambiguity data already exists in the mapping, check the difference between the current ambiguity value and the existing ambiguity. If the difference is less than the preset threshold, which is 1E-3 in this embodiment. This threshold is mainly for the GLONASS system. Since the fixed ambiguity of this system is not an integer and considering the accuracy of the ambiguity is 1E-2 cycles, it is set to 1E-3, then it is considered that the ambiguity retention has no change and update the end time; otherwise, insert a new ambiguity record;

[0136] For the existing ambiguity record, check whether a datum exchange has occurred. If an exchange has occurred, update the ambiguity record according to the exchange rules to make it consistent, and obtain the updated ambiguity preservation mapping.

[0137] The process of updating the ambiguity preservation mapping is as follows:

[0138] Input:

[0139] tki: Current epoch time structure

[0140] listFixedAmb: Fixed ambiguity list for the current epoch (element fields: ref reference satellite ID (int), svi current satellite ID (int), fid ambiguity frequency point identifier (int), amb double-difference fixed ambiguity value (double))

[0141] ambDataBase: Ambiguity preservation mapping (map<key, value>, where key is the encoding of fields 1 to 3, and value is a structure vector of fields 4 to 6)

[0142] Output:

[0143] ambDataBase: Ambiguity preservation mapping (map<key, value>, where key is the encoding of fields 1 to 3, and value is a structure vector of fields 4 to 6)

[0144] Algorithm steps:

[0145] 1. Initialize the update list listUpdate (type set <key>), initialize the reference satellite list listRefSat (type set <key>);

[0146] 2. Normal insertion, traverse listFixedAmb:

[0147] 2.1. Use ref, svi, and fid as keys to retrieve ambDataBase. If the value is found, proceed to the next step; otherwise, continue traversing;

[0148] 2.2. Determine whether amb and value.back().amb are close enough, for example, a threshold of 1E-3. If they meet the criteria, proceed to the next step; otherwise, jump to step 2.4;

[0149] 2.3. Update value.back().tkend to tki, and then jump to step 2.5;

[0150] 2.4. Use the input parameters to construct a new element and insert it at the end of value, and then jump to step 2.5;

[0151] 2.5. Record the updated ambiguity key to listUpdate;

[0152] 3. Reference satellite baseline transformation insertion, traverse listFixedAmb, skip the keys recorded by listUpdate:

[0153] 3.1. Swap ref and svi, use svi, ref, and fid as keys to retrieve ambDataBase. If the value is found, proceed to the next step; otherwise, continue traversing;

[0154] 3.2. Determine whether -amb and value.back().amb are close enough, for example, a threshold of 1E-3. If they meet the criteria, proceed to the next step; otherwise, jump to step 3.4;

[0155] 3.3. Update value.back().tkend to tki, and then jump to step 3.5;

[0156] 3.4. Use the input parameters to construct a new element and insert it at the end of value, and then jump to step 3.5;

[0157] 3.5. Record the updated ambiguity key to listUpdate;

[0158] 4. Current satellite baseline transformation insertion, traverse listFixedAmb, skip the keys recorded by listUpdate:

[0159] 4.1. Traverse listRefSat, perform ambiguity baseline exchange using the key provided by listRefSat and the current key to obtain the key and amb after the exchange;

[0160] 4.2. Determine whether amb and value.back().amb are close enough, for example, the threshold is 1E-3. If they meet the condition, proceed to the next step; otherwise, jump to step 4.4;

[0161] 4.3. Update value.back().tkend to tki, and then jump to step 4.5;

[0162] 4.4. Use the input parameters to construct a new element and insert it at the end of value, and then jump to step 4.5;

[0163] 4.5. Record the updated ambiguity key to listUpdate;

[0164] 5. New ambiguity insertion, traverse listFixedAmb, skip the keys recorded by listUpdate:

[0165] 5.1. Use ref, svi, and fid as keys and construct an empty value;

[0166] 5.2. Use the input parameters to construct a new element and insert it at the end of value.

[0167] During the operation of the real-time kinematic (RTK) algorithm, reference satellite switching may occur. Reference satellite switching does not affect the maintenance of ambiguity, but a benchmark needs to be switched to make a judgment. Improve the logic in step 4 above:

[0168] Assume the input ambiguity is (ref0, svi0, fid) -> amb00. For other existing ambiguities in ambDataBase, such as (svi1, svi0, fid) -> amb10, if the input ambiguity also has (ref0, svi1, fid) -> amb01, then the input ambiguity can be transferred from the ref0 benchmark to the svi1 benchmark, and then can be compared through (svi1, svi2, fid) to determine whether the ambiguity continues to be maintained:

[0169] (ref0, svi0, fid) - (ref0, svi1, fid) = (svi1, svi0, fid)

[0170] amb00 - amb01 = amb10;

[0171] The result obtained from (ref0, svi0, fid)-(ref0, svi1, fid) can be compared with the existing (svi1, svi0, fid).

[0172] The process of screening ambiguity retention by retention duration is as follows:

[0173] Input:

[0174] ambDataBase: Ambiguity retention mapping (map<key, value>, where key is the encoding of fields 1-3, and value is a structure vector of fields 4-6)

[0175] Output:

[0176] ambSort: Ambiguity retention sorting index (set<{dt, key, ind}>, where dt is the ambiguity retention duration, key is the encoding of fields 1-3, and ind is the element subscript of vector value)

[0177] Algorithm steps:

[0178] 1. Traverse ambDataBase:

[0179] 1.1. Calculate the retention duration of each key-value pair, i.e., dt = tkend - tkstart, and at the same time obtain the subscript ind of the ambiguity in vector value;

[0180] 1.2. After obtaining {dt, key, ind}, insert it into ambSort to complete the sorting.

[0181] After obtaining ambSort, select elements from largest to smallest, and obtain the ambiguity from ambDataBase through {key, ind}.

[0182] Use the non-combined ambiguity repair strategy for ambiguity repair, including the following steps:

[0183] Obtain the preset ambiguity repair range [-fcy, +fcy], use each offset value in this range to try to adjust the ambiguity one by one, and calculate the residual after repair. The expression is as follows:

[0184] res i = res + i * lam

[0185] where res represents the initial value of the double-difference residual, lam represents the frequency point wavelength, and res i represents the double-difference residual corresponding to the value i. Record the minimum value res0 of the double-difference residual and the corresponding repair offset value i0 during the traversal;

[0186] If i0 = 0, it means no repair is needed, and the repair flag flg = 0 is output;

[0187] If the current double-difference residual res is less than half of the wavelength, it means the repair is meaningless, and the repair flag flg = -1 is output;

[0188] If the minimum value of the double-difference residual res0 < ratio * lam is satisfied, it means the repair is successful, where ratio is a preset threshold, and the repair flag flg = 1 and the repaired residual value res fix = res0; if res0 < ratio * lam is not satisfied, it means the repair fails, and the repair flag flg = -1 is output;

[0189] According to the repair flag flg and the repaired residual value res fix , update the ambiguity data for subsequent baseline solution steps;

[0190] The non-combination ambiguity repair process is as follows:

[0191] Input:

[0192] res: double-difference residual (double)

[0193] amb: double-difference fixed ambiguity (double)

[0194] lam: frequency point wavelength (double)

[0195] fcy: ambiguity repair range (int)

[0196] ratio: accepted ratio after repair (double)

[0197] Output:

[0198] flg: repair flag (int, -1 for repair failure, 0 for no repair needed, 1 for repair success)

[0199] resfix: processed double-difference residual (double)

[0200] Algorithm steps:

[0201] 1. Traverse the repair range i in [-fcy, +fcy]:

[0202] 1.1. Calculate res + i * lam, record the minimum residual res0, and the used i0;

[0203] 2. If i0 is equal to 0, it means no repair is needed, go to the next step, otherwise jump to step 4;

[0204] 3. If res is less than 0.5 * lam, then return flg as 0; otherwise, return flg as -1;

[0205] 4. If res0 is less than ratio * lam, it indicates successful repair, return flg as 1; otherwise, return flg as -1.

[0206] The ambiguity repair is carried out using the ionosphere-free combination ambiguity repair strategy, including the following steps:

[0207] Obtain the preset ambiguity repair range [-fcy, +fcy], and use each offset value within this range to try to adjust the ambiguity one by one, and calculate the double-difference residual after repair. The expression is as follows:

[0208] res i = res + i * a1 * lam1 + j * a2 * lam2

[0209] where res represents the initial value of the double-difference residual, lam1 and lam2 represent the wavelengths of the first frequency point and the second frequency point, res i represents the double-difference residual corresponding to the values i and j of the ambiguity repair range, a1 and a2 represent the coefficients of the ionosphere-free combination, and record the minimum value res0 of the double-difference residual and the corresponding repair offset values i0 and j0 during the traversal process;

[0210] If i0 = 0 and j0 = 0, it means no repair is needed, and output the repair flag flg = 0;

[0211] If is satisfied, it means the repair is meaningless, and output the repair flag flg = -1;

[0212] If is satisfied, it means the repair is successful. Among them, ratio is the preset threshold, and output the repair flag flg = 1 and the residual value res fix = res0; if not satisfied, it means the repair fails, and output the repair flag flg = -1;

[0213] According to the repair flag flg and the residual value res fix after repair, update the ambiguity data for subsequent baseline solution steps.

[0214] In this embodiment, the value of ratio is 0.15, that is, the residual judgment threshold for whether the repair is successful is 0.15 times the frequency point wavelength. This is considering that the multipath effect of the carrier observation value generally does not exceed 1 / 4 of the wavelength, and it is also the common numerical range of the residual after the ambiguity is fixed.

[0215] The ionosphere-free combination involves two ambiguities. Therefore, when performing the repair, it is necessary to traverse the combinations of the two ambiguities. The ionosphere-free combination ambiguity repair algorithm process is as follows:

[0216] Input:

[0217] res: Ionosphere-free combination double difference residual (double)

[0218] amb1: Double difference fixed ambiguity at frequency point 1 (double)

[0219] amb2: Double difference fixed ambiguity at frequency point 2 (double)

[0220] lam1: Wavelength at frequency point 1 (double)

[0221] lam2: Wavelength at frequency point 2 (double)

[0222] a1: Coefficient of the ionosphere-free combination at frequency point 1 (double)

[0223] a2: Coefficient of the ionosphere-free combination at frequency point 2 (double)

[0224] fcy: Ambiguity repair range (int)

[0225] ratio: Accepted ratio after repair (double)

[0226] Output:

[0227] flg: Repair flag (int, -1 repair failed, 0 no need to repair, 1 repair successful)

[0228] resfix: Processed double difference residual (double)

[0229] Algorithm steps:

[0230] 1. Traverse the repair range i in [-fcy, +fcy]:

[0231] 1.1 Traverse the repair range j in [-fcy, +fcy]:

[0232] 1.1. Calculate res + i * a1 * lam1 + j * a2 * lam2, record the minimum residual res0, and the used i0 and j0;

[0233] 2. If i0 is equal to 0 and j0 is equal to 0, it means no repair is needed, execute the next step, otherwise jump to the;

[0234] 3. If res is less than 0.5 * sqrt(a1 * a1 * lam1 * lam1 + a2 * a2 * lam2 * lam2), then return flg as 0; otherwise, return flg as -1.

[0235] 4. If res0 is less than ratio * sqrt(a1 * a1 * lam1 * lam1 + a2 * a2 * lam2 * lam2), it indicates successful repair, return flg as 1; otherwise, return flg as -1.

[0236] S5: According to the initial coordinates and the repaired ambiguities, use the least squares adjustment method to perform overall adjustment on all observations to obtain the adjustment result.

[0237] The specific process is as follows:

[0238] Traverse using the ambiguity-preserving mapping in the order of decreasing holding time, and combine the reference satellite ID and the current satellite ID to calculate the observations and satellite baselines in sequence.

[0239] Calculate the satellite-earth distance based on the receiver baseline data and the satellite baseline.

[0240] Use the observations to subtract the satellite-earth distance and the ambiguities to obtain the adjustment result.

[0241] If there are multiple groups of initial coordinates, it is necessary to perform least squares adjustment on each group of initial coordinates, calculate the root mean square error of each group of adjustment results, and select the adjustment result with the smallest root mean square error as the final output.

[0242] The process of the least squares adjustment algorithm is as follows:

[0243] Input:

[0244] blh: Initialized latitude, longitude, and geodetic height, generated by step one

[0245] obsDataBase: Observation mapping (retrieve observations {tk, svi} -> obs using time and satellite ID)

[0246] ephDataBase: Ephemeris mapping (retrieve satellite baselines {tk, svi} -> satpos using time and satellite ID)

[0247] ambDataBase: Ambiguity-preserving mapping (map<key, value>, where key is the encoding of fields 1 to 3, and value is a vector of structures of fields 4 to 6), generated by step two

[0248] ambSort: Ambiguity Preservation Sorting Index (set<{dt, key, ind}>, where dt is the ambiguity preservation duration, key is the encoding of 1 to 3 fields, and ind is the element subscript of the vector value)

[0249] Output:

[0250] xyz: Adjustment Result (Earth-Centered Earth-Fixed Coordinates)

[0251] Algorithm Steps:

[0252] 1. Traverse ambSort to obtain key and ind, and traverse in descending order of dt:

[0253] 1.1. Use key and ind to find the double-difference fixed ambiguity value amb, its reference satellite ID (ref), and the current satellite ID (svi) from ambDataBase. Starting from the start time tkstart and ending at the end time tkend, traverse this time interval using the sampling interval:

[0254] 1.1.1. For the current time tk, retrieve the observation value obs using ref and svi from obsDataBase;

[0255] 1.1.2. For the current time tk, retrieve the satellite baseline satpos using ref and svi from ephDataBase;

[0256] 1.1.3. Calculate the double-difference satellite-earth distance using the adjusted baseline, subtract the double-difference satellite-earth distance and the double-difference fixed ambiguity from the double-difference observation value to obtain the double-difference residual res;

[0257] 1.1.4. Execute Step 3 for the double-difference residual res, that is, fix the ambiguity;

[0258] 1.1.5. Calculate the observation value weight using the strategy;

[0259] 1.1.6. Calculate the satellite view vector to obtain the normal equation matrix and the weighted residual vector;

[0260] 1.1.7. Accumulate the normal equation matrix and the weighted residual vector;

[0261] 2. Calculate the offset of the parameter to be determined, judge the convergence situation, and complete the adjustment process. If multiple initial values are provided in Step 1, then the least squares adjustment needs to be performed for each initial value, and finally the adjustment result with the smallest RMS (Root Mean Square) is selected for output. Through the adjustment optimization method and the ambiguity retention and repair strategy, the present invention provides a fine correction of the observed data and an optimized selection of multiple groups of initial values, overcoming the problem of large fixed solution deviation in the prior art. Through the least squares adjustment to optimize all observed values as a whole, it ensures that the final positioning result is more accurate, significantly improving the positioning accuracy. In addition, the solution ensures the accuracy and reliability of the final result through multi-initial value processing and the selection of the smallest root mean square error, avoiding the error accumulation caused by improper selection of the initial value, and further improving the stability and anti-interference ability of the system.

[0262] Embodiment 2:

[0263] This embodiment provides a baseline solution system, including a memory and a processor. The memory includes a baseline solution method program, and when the baseline solution method program is executed by the processor, it realizes the steps of a baseline solution method as described in Embodiment 1.

[0264] Obviously, the above embodiments of the present invention are merely examples for clearly illustrating the present invention, rather than limiting the implementation manners of the present invention. For those of ordinary skill in the art, other different forms of changes or modifications can be made based on the above description. It is not necessary and impossible to enumerate all the implementation manners here. Any modifications, equivalent replacements, and improvements made within the spirit and principle of the present invention shall be included in the protection scope of the claims of the present invention.< / key> < / key> < / cgeopoint>

Claims

1. A baseline solution method, characterized in that, The steps are as follows: Calculate the fixed solution coordinates for the observation data of each epoch, and convert the fixed solution coordinates into latitude, longitude, and geodetic height; Perform hash encoding and clustering on the latitude and longitude corresponding to the fixed solution coordinates of each epoch to obtain a mapping with the frequency of occurrence of longitude and latitude coordinates as the key and the average geodetic coordinates of longitude and latitude as the value; Use the mapping to screen the fixed solution coordinates, eliminate the coordinate information containing gross errors, and output the initial coordinates; Construct a ambiguity preservation mapping using the double-difference ambiguities collected during the process of obtaining the fixed solution. Screen the ambiguity data according to the ambiguity preservation duration data in the mapping, and repair the screened ambiguities using the non-combination ambiguity repair strategy and the ionosphere-free combination ambiguity repair strategy to obtain the repaired ambiguities; According to the initial coordinates and the repaired ambiguities, perform overall adjustment on all observations using the least squares adjustment method to obtain the adjustment result.

2. The baseline solution method according to claim 1, wherein The preset method for calculating the Earth-Centered Earth-Fixed coordinates for the observation data of each epoch is the post-processing real-time kinematic positioning algorithm.

3. The baseline solution method according to claim 1, characterized in that, Performing hash encoding and clustering on the latitude and longitude corresponding to the fixed solution coordinates of each epoch includes the following steps: Add π / 2 to the latitude to adjust the latitude range to [0, π); add π to the longitude to adjust the longitude range to [0, 2π); Perform bit operations and precision adjustment on the adjusted latitude and longitude, and output the hash encoding value of n-bit unsigned integer type; Use the hash encoding value as the key to record the latitude, longitude, and geodetic height of each observation point to form a hash mapping of geodetic coordinates; According to the hash encoding in the hash mapping, calculate the frequency of occurrence of each geodetic coordinate in all epochs; For each geodetic coordinate, calculate the average geodetic coordinate of this position based on the latitude, longitude, and geodetic height corresponding to its frequency of occurrence; Construct a mapping relationship between the frequency of coordinate occurrence and the average geodetic coordinate with the frequency of coordinate occurrence as the key and the average geodetic coordinate as the value.

4. A baseline solution method according to claim 1, characterized in that, The clustering is stored and retrieved using a red-black tree.

5. A baseline solution method according to claim 1, characterized in that, The method for screening the fixed solution coordinates using the mapping is: obtain the maximum value of the frequency of occurrence of all coordinates in the mapping. If the frequency of occurrence of the fixed solution coordinates is less than n% of the maximum frequency, then ignore the fixed solution coordinates; otherwise, retain the fixed solution coordinates for subsequent calculations.

6. The baseline solution method according to claim 1, wherein Constructing the ambiguity preservation mapping using the double-difference ambiguities collected during the process of obtaining the fixed solution includes the following steps: Collect the double-difference ambiguity data of each epoch during the process of obtaining the fixed solution, including the reference satellite ID, current satellite ID, ambiguity frequency point identifier, ambiguity preservation start time, ambiguity preservation end time, and double-difference fixed ambiguity value; Use the reference satellite ID, current satellite ID, and ambiguity frequency point identifier as the key of the ambiguity preservation mapping, and use the ambiguity preservation start time, ambiguity preservation end time, and double-difference fixed ambiguity value as the value to construct the ambiguity preservation mapping using the obtained ambiguity data; Screen according to the ambiguity preservation duration, select the records with the longest ambiguity preservation time in the top m%, and output the screened ambiguity preservation mapping.

7. A baseline solution method according to claim 6, characterized in that, The method for constructing the ambiguity preservation mapping includes the following steps: Traverse the ambiguity data of each fixed solution and insert it into the ambiguity retention mapping. During the insertion process, make a judgment. If the key of the ambiguity data already exists in the mapping, then check the difference between the current ambiguity value and the existing ambiguity. If the difference is less than the preset threshold, it is considered that the ambiguity retention has not changed, and update the end time; otherwise, insert a new ambiguity record; For the existing ambiguity records, check whether a reference exchange has occurred. If an exchange has occurred, then update the ambiguity records according to the exchange rules to make them consistent, and obtain the updated ambiguity retention mapping.

8. A baseline solution method according to claim 1, characterized in that, Perform ambiguity repair using the non-combination ambiguity repair strategy, including the following steps: Obtain the preset ambiguity repair range [-fcy, +fcy], and use each offset value within this range to try to adjust the ambiguity one by one, and calculate the residual after repair. The expression is as follows: res i = res + i * lam where res represents the initial value of the double-difference residual, lam represents the frequency-point wavelength, and res i represents the double-difference residual corresponding to value i. During the traversal process, record the minimum value res0 of the double-difference residual and the corresponding repair offset value i0; If i0 = 0, it means that no repair is required, and output the repair flag flg = 0; If the current double-difference residual res is less than half of the wavelength, it means that the repair is meaningless, and output the repair flag flg = -1; If the minimum value res0 of the double-difference residual satisfies res0 < ratio * lam, it indicates successful repair, where ratio is a preset threshold, and the repair flag flg = 1 and the repaired residual value res are output. fix = res0; if res0 < ratio * lam is not satisfied, it indicates repair failure, and the repair flag flg = -1 is output. According to the repair flag flg and the residual value res after repair fix , update the ambiguity data; Perform ambiguity repair using the ionosphere-free combination ambiguity repair strategy, including the following steps: Obtain the preset ambiguity repair range [-fcy, +fcy], and use each offset value within this range to try to adjust the ambiguity one by one, and calculate the double-difference residual after repair. The expression is as follows: res i = res + i * a1 * lam1 + j * a2 * lam2 Among them, res represents the initial value of the double-difference residual, lam1 and lam2 represent the wavelengths of the first frequency point and the second frequency point, and res i represents the double-difference residuals corresponding to the values i and j representing the ambiguity repair range. a1 and a2 represent the coefficients of the ionosphere-free combination. During the traversal process, the minimum value res0 of the double-difference residual and the corresponding repair offset values i0 and j0 are recorded; If i0 = 0 and j0 = 0, it means that no repair is required, and output the repair flag flg = 0; If the following conditions are met it means that the repair is meaningless, and the repair flag flg = -1 is output; If the following condition is met it indicates successful repair. Here, ratio is a preset threshold, and the repair flag flg = 1 and the residual value res after repair are output fix = res0; if the condition is not met, it indicates failed repair, and the repair flag flg = -1 is output; According to the repair flag flg and the residual value res after repair fix , update the ambiguity data.

9. A baseline solution method according to claim 1, characterized in that, Perform overall adjustment on all observations using the least squares adjustment method, including the following steps: Traverse the ambiguity retention mapping in the order of decreasing retention time, and combine the reference satellite ID and the current satellite ID to calculate the observations and satellite baselines in sequence; Calculate the satellite-to-ground distance according to the receiver baseline data and the satellite baseline; Obtain the adjustment result by subtracting the satellite-to-ground distance and the ambiguity from the observations; If there are multiple sets of initial coordinates, perform least squares adjustment on each set of initial coordinates, calculate the root mean square error of each set of adjustment results, and select the adjustment result with the smallest root mean square error as the final output.

10. A baseline solution system, characterized in that, The system includes: a memory and a processor. The memory includes a baseline solution method program. When the baseline solution method program is executed by the processor, the steps of a baseline solution method as described in any one of claims 1 to 9 are implemented.

Images