Patent Publication Number: US-10768312-B1

Title: Integrity analysis method based on kinematic-to-kinematic relative positioning scenario

Description:
CROSS-REFERENCE TO RELATED PATENT APPLICATION 
     This non-provisional application claims priority to and the benefit of, pursuant to 35 U.S.C. § 119(a), patent application Serial No. CN201911081247.X filed in China on Nov. 7, 2019. The disclosure of the above application is incorporated herein in its entirety by reference. 
     Some references, which may include patents, patent applications and various publications, are cited and discussed in the description of this disclosure. The citation and/or discussion of such references is provided merely to clarify the description of the present disclosure and is not an admission that any such reference is “prior art” to the disclosure described herein. All references cited and discussed in this specification are incorporated herein by reference in their entireties and to the same extent as if each reference were individually incorporated by reference. 
     TECHNICAL FIELD 
     The present invention relates to the technical field of satellite navigation, and in particular, to the technical field of integrity monitoring for kinematic-to-kinematic relative positioning by using carrier phases in satellite navigation. 
     BACKGROUND 
     With the continuous development of GNSS system high-precision positioning, the demand for GNSS positioning grows incessantly in various industries. The conventional real-time kinematic positioning (RTK) technology is widely applied to “static-kinematic” scenarios in engineer application. However, in a “kinematic-kinematic” scenario, the issue of high-precision relative positioning between two moving targets needs to be solved, and the original technology can no longer meet requirements of users. Therefore, a kinematic-to-kinematic differential positioning technology has emerged. In kinematic-to-kinematic differential positioning, the position of a reference station does not need to be known accurately, while a relative position between the reference station and a moving station is the focus of concern. After the ambiguity is fixed correctly, the relative position between the reference station and the moving station can be determined precisely in real time. 
     Meanwhile, in a highly kinematic situation, for example, during autonomous aerial re-fueling and autonomous landing, high integrity and high accuracy need to be satisfied at the same time. In these application scenarios, it is necessary to use carrier phase measurement to improve precision. Therefore, the issue of position domain integrity of integer ambiguity calculation in a carrier phase measurement quantity in a satellite navigation system is proposed. Generally, it is conservatively assumed that all incorrect fix of ambiguities may lead to high-risk positioning errors. Although such a conservative assumption is simple, it unnecessarily limits the availability of navigation that has strict requirements on integrity and accuracy. Accuracy and integrity risks are basic performance indexes affecting the availability of the navigation system. In the Global Navigation Satellite System (GNSS), the integrity risk refers to a capability of sending an alarm to a user in time when the navigation system cannot be used for a navigation service. In addition, for a new aerospace application, a carrier phase observation quantity needs to be used to ensure that high integrity and high accuracy are satisfied at the same time. 
     In these application scenarios, to use a kinematic-to-kinematic differential carrier phase measurement quantity, the following problems need to be solved: First of all, in order to implement centimeter-level positioning precision by using carrier phase measurement, the issue of integer ambiguity needs to be solved. In the existing integer ambiguity calculation algorithm, an LAMBDA algorithm, a TCRA algorithm, and a WL-NL algorithm are mainly used. The core idea is to calculate the integer ambiguity by using different combined observation values. However, in some application scenarios with a long baseline distance, a positioning error convergence speed declines, and calculation of the integer ambiguity becomes difficult. The second problem is how to rationally quantify the integrity risk in a kinematic-to-kinematic positioning scenario through carrier phase measurement in satellite navigation. The existing theories are based on the conservative assumption. It is assumed that all incorrectly fixed integer ambiguities lead to a relatively large positioning error, and an integrity risk is calculated based on this condition. Such an assumption greatly limits the availability of the positioning system, and cannot be applied to practical scenarios desirably. 
     For the first problem, the concept of On The Fly (OTF) was initially proposed by Seeber et al. in 1989. Positioning is implemented by a combined observation quantity of a pseudorange and a carrier phase. Besides, in 1990, Hatch proposed the concept of calculating an integer ambiguity with the least square method, in which an ambiguity space is searched and screened by selecting an optimal combination and a suboptimal combination, to finally calculate the ambiguity. This method is also further developed. In 1992, Abidin et al. optimized the least square search algorithm and proposed an on-the-fly ambiguity calculation method in combination with an ambiguity function method. In 2002, based on the foregoing method, Yang Yunchun et al. developed a single-epoch ambiguity calculation technology. In another type of ambiguity calculation methods, an ambiguity covariance approach is used. Integer ambiguities are searched by using a state vector and a variance-covariance matrix. The least-squares ambiguity decorrelation adjustment method, i.e., the LAMBDA algorithm, is the most commonly used method currently. The LAMBDA algorithm was initially proposed by Teunissen in 1993, and is one of the leading ambiguity calculation methods in use at present. It is generally considered at home and abroad that the LAMBDA algorithm achieves the highest search speed, is most reliable, and is also most compact theoretically. However, in a long-baseline case, it is still difficult to calculate an integer ambiguity in a kinematic-to-kinematic relative positioning scenario. Scholars in Beijing University of Aeronautics and Astronautics proposed an improved method based on the LAMBDA integer ambiguity calculation algorithm. In a short-baseline case, an integer ambiguity is directly calculated by using the LAMBDA algorithm. In a long-baseline case, WL-NL is used to fix integer ambiguities by means of direct rounding, and subsequently, L1 ambiguities can be searched for by using the LAMBDA algorithm after wide-line ambiguities are obtained. The two algorithms are combined, and then ambiguity searching and fixing are performed. Wide-line ambiguities are fixed first, and then narrow-lane L1-frequency ambiguities are calculated by using an ionosphere-free composite model and a wide-lane observation value composite equation, so that the complexity of calculation can be effectively reduced, the calculation load is decreased, and geometric integrity can be ensured, thus facilitating rapid calculation of the integer ambiguity and shortening a convergence time of a positioning error. 
     For the second problem, with the continuous upgrade of satellite navigation application scenarios, the position domain integrity risk is quantified rationally and the centimeter-level positioning precision is implemented by using carrier phase measurement. A prior probability of correct fix of integer ambiguities may be obtained by correctly fixing the integer ambiguities, and such a probability is referred to as Probability of Correct Fix (PCF). Moreover, the PCF needs to meet the integrity risk requirement. In addition, in the process of calculating the integrity risk, a Probability of Incorrect Fix (PIF) is defined. Besides, a PIF threshold is derived, where the PIF threshold should be distributed from the total navigation integrity risk and be less than the total navigation integrity risk. In a typical positioning navigation process, an ambiguity subset may be determined by merely using a probability lower than the PIF threshold in combination with a probability of incorrect fix, while float solutions of the rest of ambiguities are reserved. Then, partially fixed ambiguities are used to calculate a position estimated value and calculate a corresponding position domain protection level. Finally, the influence of incorrectly fixed ambiguities is evaluated in the position domain to calculate the integrity risk. 
     In view of the research status of the kinematic-to-kinematic relative positioning and the integrity thereof, and in combination with the conception of the existing methods, this patent proposes an improvement in a long-baseline case based on the LAMBDA integer ambiguity calculation algorithm, to correctly fix integer ambiguities, so that the success rate of ambiguity calculation reaches 99% or higher, and a fixing rate of the integer ambiguities is as high as 97%. After that, the influence caused by incorrectly fixed ambiguities in the position domain is evaluated to define an upper limit of an integrity risk in a navigation process. An integrity threshold calculated based on a partial ambiguity resolution algorithm is proposed. Finally, the integrity calculation in kinematic-to-kinematic relative positioning is implemented. 
     SUMMARY 
     An objective of the present invention is to overcome the defects in the prior art and provide an integrity analysis method based on a kinematic-to-kinematic relative positioning scenario, which provides an integer ambiguity calculation algorithm for a kinematic-to-kinematic positioning system in the case of a long baseline, to calculate carrier phase integrity, where integer ambiguities are fixed using a partial ambiguity resolution method without traversing all integer spaces, thus greatly improving the calculation efficiency. 
     In order to solve the foregoing method, the present invention uses the following technical solution: An integrity analysis method based on a kinematic-to-kinematic relative positioning scenario includes the following steps: 
     a) establishing a kinematic-to-kinematic relative positioning model, and inputting navigation data; 
     b) calculating a float solution of an integer ambiguity; 
     c) detecting and correcting cycle slips based on a total electron content rate, including: 
     step 1: performing linear combination of wide-lane phase minus narrow-lane pseudorange and detecting an ionospheric total electron content rate for the foregoing solution data respectively: 
     
       
         
           
             
               
                 
                   
                     
                       [ 
                       
                         
                           Δ 
                           ⁢ 
                           
                             
                               N 
                               1 
                               P 
                             
                             ⁡ 
                             
                               ( 
                               k 
                               ) 
                             
                           
                         
                         - 
                         
                           Δ 
                           ⁢ 
                           
                             
                               N 
                               2 
                               P 
                             
                             ⁡ 
                             
                               ( 
                               k 
                               ) 
                             
                           
                         
                       
                       ] 
                     
                     = 
                     
                       
                         
                           
                             N 
                             WL 
                             P 
                           
                           ⁡ 
                           
                             ( 
                             
                               k 
                               - 
                               1 
                             
                             ) 
                           
                         
                         - 
                         
                           
                             N 
                             WL 
                             P 
                           
                           ⁡ 
                           
                             ( 
                             k 
                             ) 
                           
                         
                       
                       = 
                       
                         
                           [ 
                           
                               
                           
                           ⁢ 
                           
                             
                               
                                 Φ 
                                 1 
                                 P 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   k 
                                   - 
                                   1 
                                 
                                 ) 
                               
                             
                             - 
                             
                               
                                 Φ 
                                 2 
                                 P 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   k 
                                   - 
                                   1 
                                 
                                 ) 
                               
                             
                             - 
                             
                               
                                 
                                   
                                     f 
                                     1 
                                   
                                   ⁢ 
                                   
                                     
                                       P 
                                       1 
                                       P 
                                     
                                     ⁡ 
                                     
                                       ( 
                                       
                                         k 
                                         - 
                                         1 
                                       
                                       ) 
                                     
                                   
                                 
                                 + 
                                 
                                   
                                     f 
                                     2 
                                   
                                   ⁢ 
                                   
                                     
                                       P 
                                       2 
                                       P 
                                     
                                     ⁡ 
                                     
                                       ( 
                                       
                                         k 
                                         - 
                                         1 
                                       
                                       ) 
                                     
                                   
                                 
                               
                               
                                 
                                   λ 
                                   WL 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     
                                       f 
                                       1 
                                     
                                     + 
                                     
                                       f 
                                       2 
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                           ] 
                         
                         - 
                         
                           [ 
                           
                               
                           
                           ⁢ 
                           
                             
                               
                                 Φ 
                                 1 
                                 P 
                               
                               ⁡ 
                               
                                 ( 
                                 k 
                                 ) 
                               
                             
                             - 
                             
                               
                                 Φ 
                                 2 
                                 P 
                               
                               ⁡ 
                               
                                 ( 
                                 k 
                                 ) 
                               
                             
                             - 
                             
                               
                                 
                                   
                                     f 
                                     1 
                                   
                                   ⁢ 
                                   
                                     
                                       P 
                                       1 
                                       P 
                                     
                                     ⁡ 
                                     
                                       ( 
                                       k 
                                       ) 
                                     
                                   
                                 
                                 + 
                                 
                                   
                                     f 
                                     2 
                                   
                                   ⁢ 
                                   
                                     
                                       P 
                                       2 
                                       P 
                                     
                                     ⁡ 
                                     
                                       ( 
                                       k 
                                       ) 
                                     
                                   
                                 
                               
                               
                                 
                                   λ 
                                   WL 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     
                                       f 
                                       1 
                                     
                                     + 
                                     
                                       f 
                                       2 
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                           ] 
                         
                       
                     
                   
                   ; 
                 
                 ⁢ 
                 
                   
 
                 
                 [ 
                 
                   
                     
                       λ 
                       1 
                     
                     ⁢ 
                     Δ 
                     ⁢ 
                     
                       
                         N 
                         1 
                         P 
                       
                       ⁡ 
                       
                         ( 
                         k 
                         ) 
                       
                     
                   
                   - 
                   
                     
                       λ 
                       2 
                     
                     ⁢ 
                     Δ 
                     ⁢ 
                     
                       
                         N 
                         2 
                         P 
                       
                       ⁡ 
                       
                         ( 
                         k 
                         ) 
                       
                     
                   
                 
                 ] 
               
               = 
               
                 
                   
                     4 
                     ⁢ 
                     
                       0 
                       . 
                       3 
                     
                     × 
                     1 
                     ⁢ 
                     
                       0 
                       
                         1 
                         ⁢ 
                         6 
                       
                     
                     ⁢ 
                     
                       ( 
                       
                         γ 
                         - 
                         1 
                       
                       ) 
                     
                     ⁢ 
                     Δ 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       t 
                       · 
                       
                         
                           TECR 
                           Φ 
                         
                         ⁡ 
                         
                           ( 
                           k 
                           ) 
                         
                       
                     
                   
                   
                     f 
                     1 
                     2 
                   
                 
                 - 
                 
                   
                     λ 
                     1 
                   
                   ⁡ 
                   
                     [ 
                     
                       
                         
                           Φ 
                           1 
                           P 
                         
                         ⁡ 
                         
                           ( 
                           k 
                           ) 
                         
                       
                       - 
                       
                         
                           Φ 
                           1 
                           P 
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             - 
                             1 
                           
                           ) 
                         
                       
                     
                     ] 
                   
                 
                 + 
                 
                   
                     λ 
                     2 
                   
                   ⁡ 
                   
                     [ 
                     
                       
                         
                           Φ 
                           2 
                           P 
                         
                         ⁡ 
                         
                           ( 
                           k 
                           ) 
                         
                       
                       - 
                       
                         
                           Φ 
                           2 
                           P 
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             - 
                             1 
                           
                           ) 
                         
                       
                     
                     ] 
                   
                 
               
             
             ; 
           
         
       
     
     where f 1 , f 2  represent two frequencies of a received double-frequency satellite signal; λ 1 , λ 2  represent wavelengths at corresponding frequencies; 
               γ   =       f   1   2       f   2   2         ;       λ   WL     =     C     (       f   1     -     f   2       )         ;         
TECR Φ (k) represents an ionospheric total electron content rate at an epoch K; Φ 1   P (k) and Φ 1   P (k−1) represent carrier phase measurement values between two adjacent epochs at the frequency f 1 ; P 1   P (k) and P 1   P (k−1) represent pseudorange measurement values between two adjacent epochs at the frequency f 1 ; ΔN 1   P (k) and ΔN 1   P (k) represent cycle slips that are detected at the frequencies f 1  and f 2  using a cycle as a unit respectively; c represents a light velocity; N WL   P (k) and N WL   P (k−1) represent integer ambiguities between two adjacent epochs;
 
     step 2: calculating influence of a pseudo random error on cycle slip detection;
 
SPIE max =max{|δ P   1   P ( k )|,|δ 2   P ( k )|},δ P   1   P ( k ),δ P   2   P ( k )∈(−∞,+∞);
 
     where δP 1   P (k) and δP 2   P (k) represent pseudorange measurements at f 1  and f 2  at the epoch K respectively, and SPIE max  represents a maximum value of a pseudo random error; 
     step 3: calculating cycle slip search areas;
 
 SS   ΔN     1       P   ( k ):Δ N   1   P ( k )−δΔ N   1   P ( k )≤Δ N   1   P ( k ) cand   ≤ΔN   1   P ( k )+δΔ N   1   P ( k );
 
 SS   ΔN     2       P   ( k ):Δ N   2   P ( k )−δΔ N   2   P ( k )≤Δ N   2   P ( k ) cand   ≤ΔN   2   P ( k )+δΔ N   2   P ( k );
 
     where ΔN 1   P (k) cand  represents a correct cycle slip search area at L1 and ΔN 2   P (k) cand  represents a correct cycle slip search area at L2; 
     step 4: calculating a wide-lane cycle slip variation by using a cycle slip search rule 1; and calculating a total electron content rate threshold by using a cycle slip search rule 2;
 
TECR Φ ( k )= H{λ   1 [Φ 1   P ( k )−Φ 1   P ( k− 1)]+λ 2 [Φ 2   P ( k− 1)−Φ 2   P ( k )]+[λ 1   ΔN   1   P ( k ) cand −λ 2   ΔN   2   P ( k ) cand ]};
 
     wherein 
     
       
         
           
             
               H 
               = 
               
                 
                   f 
                   1 
                   2 
                 
                 
                   4 
                   ⁢ 
                   
                     0 
                     . 
                     3 
                   
                   × 
                   1 
                   ⁢ 
                   
                     0 
                     
                       1 
                       ⁢ 
                       6 
                     
                   
                   ⁢ 
                   
                     ( 
                     
                       γ 
                       - 
                       1 
                     
                     ) 
                   
                   ⁢ 
                   Δ 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   t 
                 
               
             
             ; 
           
         
       
     
     d) calculating a probability of correct fix PCF and a probability of incorrect fix PIF for the integer ambiguity; 
     calculating a probability of a candidate ambiguity value Z: 
     
       
         
           
             
               P 
               ⁡ 
               
                 ( 
                 
                   
                     a 
                     ⋓ 
                   
                   = 
                   z 
                 
                 ) 
               
             
             = 
             
               
                 ∏ 
                 
                   i 
                   = 
                   1 
                 
                 m 
               
               ⁢ 
               
                 [ 
                 
                   
                     Φ 
                     ⁡ 
                     
                       ( 
                       
                         
                           1 
                           - 
                           
                             2 
                             ⁢ 
                             
                               
                                 I 
                                 i 
                                 T 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   a 
                                   - 
                                   z 
                                 
                                 ) 
                               
                             
                           
                         
                         
                           2 
                           ⁢ 
                           
                             σ 
                             
                               i 
                               / 
                               I 
                             
                           
                         
                       
                       ) 
                     
                   
                   + 
                   
                     Φ 
                     ⁡ 
                     
                       ( 
                       
                         
                           1 
                           + 
                           
                             2 
                             ⁢ 
                             
                               
                                 I 
                                 i 
                                 T 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   a 
                                   - 
                                   z 
                                 
                                 ) 
                               
                             
                           
                         
                         
                           2 
                           ⁢ 
                           
                             σ 
                             
                               i 
                               / 
                               I 
                             
                           
                         
                       
                       ) 
                     
                   
                   - 
                   1 
                 
                 ] 
               
             
           
         
       
     
     where ă represents an integer ambiguity estimated using a bootstrap method; a represents a correctly fixed integer ambiguity; represents σ i/I  standard deviation of ambiguities, and the standard deviation depends on a set I={1, 2, . . . , i−1}; I i  represents the i th  column vector of a unit-lower-triangular matrix L −T  generated from decomposition of LDL T  of a fuzzy covariance matrix; m represents the number of fixed integer ambiguities, and 
                 Φ   ⁡     (   x   )       =       ∫     -   ∞     x     ⁢       (     1   /       2   ⁢   π         )     ⁢     exp   ⁡     (       -     1   2       ⁢     v   2       )       ⁢   d   ⁢   v         ;         
a−z represents a difference obtained by subtracting an integer ambiguity calculated using a correlation method from an integer ambiguity calculated using a bootstrap method;
 
     when the correctly fixed integer ambiguity a is equal to the candidate ambiguity value Z, the probability of correct fix PCF can be calculated: 
     
       
         
           
             
               P 
               ⁡ 
               
                 ( 
                 
                   
                     a 
                     ⋓ 
                   
                   = 
                   a 
                 
                 ) 
               
             
             = 
             
               
                 ∏ 
                 
                   i 
                   = 
                   1 
                 
                 m 
               
               ⁢ 
               
                 [ 
                 
                   
                     2 
                     ⁢ 
                     
                       Φ 
                       ⁡ 
                       
                         ( 
                         
                           1 
                           
                             2 
                             ⁢ 
                             
                               σ 
                               
                                 i 
                                 / 
                                 I 
                               
                             
                           
                         
                         ) 
                       
                     
                   
                   - 
                   1 
                 
                 ] 
               
             
           
         
       
     
     the probability of incorrect fix PIF can be calculated by using an exclusion relation between a correct fix event and an incorrect fix event; 
     e) determining a fault to be detected and a satellite fault probability; 
     f) calculating a standard deviation δ v|CF  and a position domain deviation b m ; 
     wherein the following models are established: y=Gx+ε and 
     
       
         
           
             { 
             
               
                 
                   
                     
                       
                         x 
                         ^ 
                       
                       = 
                       Sy 
                     
                   
                 
                 
                   
                     
                       S 
                       = 
                       
                         
                           
                             ( 
                             
                               
                                 G 
                                 T 
                               
                               ⁢ 
                               WG 
                             
                             ) 
                           
                           
                             - 
                             1 
                           
                         
                         ⁢ 
                         GW 
                       
                     
                   
                 
               
               ; 
             
           
         
       
     
     and an ambiguity float solution-relative position vector matrix Ŝ and a related estimated error covariance matrix can be obtained according to the foregoing equations: 
     
       
         
           
             
               
                 S 
                 ^ 
               
               = 
               
                 [ 
                 
                   
                     
                       
                         x 
                         ^ 
                       
                     
                   
                   
                     
                       
                         N 
                         ^ 
                       
                     
                   
                 
                 ] 
               
             
             ; 
             
               P 
               = 
               
                 [ 
                 
                   
                     
                       
                         P 
                         
                           x 
                           ^ 
                         
                       
                     
                     
                       
                         P 
                         
                           
                             x 
                             ^ 
                           
                           ⁢ 
                           
                             N 
                             ^ 
                           
                         
                       
                     
                   
                   
                     
                       
                         P 
                         
                           
                             N 
                             ^ 
                           
                           ⁢ 
                           
                             x 
                             ^ 
                           
                         
                       
                     
                     
                       
                         P 
                         
                           N 
                           ^ 
                         
                       
                     
                   
                 
                 ] 
               
             
             ; 
           
         
       
     
     step 1: calculating the k th  integer ambiguity element N Z   (k) ;
 
 N   Z   (k) =round([0 1×3   Z   k ] S   (k-1) );
 
     where Z k  represents the k th  row of a transition matrix Z; Z 1:k =[0 1×(k-1) 1 0 1×(n-k) ]; s (k-1)  represents an updated state vector S based on fixed ambiguities 1→K; 
     step 2: calculating the standard deviation δ v|CF ; and continuously updating position vector estimation and remaining ambiguity real values S;
 
 K=P   (k-1) [0 1×3   Z   k ] T ([0 1×3   Z   k ] T   P   (k-1) [0 1×3   Z   k ] T ) −1  
 
 S   (k)   =S   (k-1)   +K ( N   Z   (k) −[0 1×3   Z   k ] T   S   (k-1) )
 
 P   (k) =( I−K [0 1×3   Z   k ]) P   (k-1)  
 
     where K represents a gain; P represents a covariance matrix of position and float ambiguity state estimated error; P (k)  represents a covariance matrix of an updated state vector after the k th  ambiguity is fixed; and it is assumed that δ v|CF =√{square root over (P (3,3)   (m) )} after m iterations; 
     step 3: 
     calculating the position domain deviation b m ;
 
 K=P [0 m×3   Z   1:m ] T ([0 m×3   Z   1:m ] P [0 m×3   Z   1:m ] T ) −1  
 
 S ( m )= Ŝ+K ( N   Z   (1:m) −[0 m×3   Z   1:m ] T   Ŝ )
 
     where Z 1:m  represents a transition matrix Z of a row vector 1 to Z 1:m =[I m×m  0 m×(n-m) ]; N Z   (1:m)  represents a fixed solution for fix of 1 to m integer ambiguities; 
     the position domain deviation b m  caused by a relative position error of the m th  incorrect candidate pair (a−z) m  is:
 
 b   m   =S   CF   (m)   −S   IF   (m)   =K ( a−z ) m  
 
     where a m  represents a correctly fixed ambiguity vector; z m  represents an incorrectly fixed ambiguity vectors; S CF   (m)  represents a correct state obtained after fix of m ambiguities; S IF   (m)  represents an incorrect state obtained after fix of m ambiguities;
 
 S   CF   (m)   =Ŝ+K ( a   m −[0 m×3   Z   1:m ] Ŝ )
 
 S   IF   (m)   =Ŝ+K ( z   m −[0 m×3   Z   1:m ] Ŝ );
 
     g) calculating an integrity risk value I H0  of a carrier phase; 
     
       
         
           
             
               I 
               
                 H 
                 ⁢ 
                 0 
               
             
             = 
             
               1 
               - 
               
                 
                   ( 
                   
                     1 
                     - 
                     
                       P 
                       ⁢ 
                       
                         { 
                         
                           
                             
                                
                               
                                 
                                   
                                     x 
                                     ^ 
                                   
                                   v 
                                 
                                 - 
                                 
                                   x 
                                   v 
                                 
                               
                                
                             
                             &gt; 
                             VAL 
                           
                           | 
                           
                             C 
                             ⁢ 
                             F 
                           
                         
                         } 
                       
                     
                   
                   ) 
                 
                 ⁢ 
                 PCF 
               
               - 
               
                 
                   ∑ 
                   
                     n 
                     = 
                     1 
                   
                   k 
                 
                 ⁢ 
                 
                   
                     ( 
                     
                       1 
                       - 
                       
                         P 
                         ⁢ 
                         
                           { 
                           
                             
                               
                                  
                                 
                                   
                                     
                                       x 
                                       ^ 
                                     
                                     v 
                                   
                                   - 
                                   
                                     x 
                                     v 
                                   
                                 
                                  
                               
                               &gt; 
                               VAL 
                             
                             | 
                             
                               IF 
                               n 
                             
                           
                           } 
                         
                       
                     
                     ) 
                   
                   ⁢ 
                   
                     PIF 
                     n 
                   
                 
               
             
           
         
       
     
     where P VALCF =P{|{circumflex over (x)} v −x v |&gt;VAL|CF} represents a probability that a vertical error is greater than an alarm threshold under the condition of correct fix; PCF represents a probability of correct fix; PIF n  represents a probability of incorrect fix; P VALIF =P{|{circumflex over (x)} v −x v |&gt;VAL|IF n } represents a probability that a vertical error is greater than an alarm threshold under the condition of incorrect fix. 
     Preferably, the calculating a float solution of an integer ambiguity includes the following steps: establishing a function model y=f(x,β) corresponding to m satellite-collect points (x 1 ,y 1 ,z 1 ), (x 2 ,y 2 ,z 2 ), . . . , (x m ,y m ,z m ), and calculating a minimum value β of a residual sum of squares, to minimize the residual sum of squares; 
                 S   ⁡     (   β   )       =       ∑     i   =   1     m     ⁢           ⁢         r   i     ⁡     (   β   )       2         ;         
and a residual r i =y i −f(x i , β) can be calculated; and the minimum value can be calculated by taking a derivative of the foregoing equation:
 
     
       
         
           
             
               
                 ∂ 
                 S 
               
               
                 ∂ 
                 
                   β 
                   j 
                 
               
             
             = 
             
               
                 2 
                 ⁢ 
                 
                   
                     ∑ 
                     i 
                   
                   ⁢ 
                   
                     
                       r 
                       i 
                     
                     ⁢ 
                     
                       
                         ∂ 
                         
                           r 
                           i 
                         
                       
                       
                         ∂ 
                         
                           β 
                           j 
                         
                       
                     
                   
                 
               
               = 
               
                 0 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   
                     ( 
                     
                       
                         j 
                         = 
                         1 
                       
                       , 
                       … 
                       ⁢ 
                       
                           
                       
                       , 
                       n 
                     
                     ) 
                   
                   . 
                 
               
             
           
         
       
     
     Preferably, a maximum allowable number of satellite faults is calculated according to N fault,max =max{r∈1, . . . , N sat |P multiple  (r+1, P event,1 , . . . , P event,N     sat     +N     const   )≤P FAVLT_THRES }; where P event,i =PIF i  represents a prior probability of an independent error event i; N fault,max  represents a probability of a multi-fault modes consisting of r independent events; N sat  represents the number of satellites; N const  represents the number of constellations; P multiple  represents a probability that multiple satellite are faulty; and P FAVLT-THRES  represents an alarm threshold. 
     Preferably, N fault,max  of a combination corresponding to all subsets can be determined according to the N fault,max , and is used to determine the satellite fault probability. 
     Preferably, a conditional variance σ i/I   2  of an ambiguity i is defined, the conditional variance depends on previously fixed integer ambiguities of the set I={1, 2, . . . , i−1}, and an item (i, i) in a diagonal matrix D is generated from decomposition of a float solution estimated error covariance matrix LDL T  of cycle ambiguities. 
     Preferably, by calculating the influence of the pseudo random error on cycle slip detection, a maximum value δΔN 1   P  of cycle slips detected at the frequency f 1  using a cycle as a unit, a maximum value δΔN 2   P (k) max  of cycle slips detected at the frequency f 2  using a cycle as a unit, and a difference δ[ΔN 1   P (k)−ΔN 2   P (k)] max  between the maximum values of cycle slips detected at the frequencies f 1  and f 2  using a cycle as a unit can be calculated: 
     
       
         
           
             
               δ 
               ⁡ 
               
                 [ 
                 
                   
                     Δ 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       
                         N 
                         1 
                         P 
                       
                       ⁡ 
                       
                         ( 
                         k 
                         ) 
                       
                     
                   
                   - 
                   
                     Δ 
                     ⁢ 
                     
                       
                         N 
                         2 
                         P 
                       
                       ⁡ 
                       
                         ( 
                         k 
                         ) 
                       
                     
                   
                 
                 ] 
               
             
             = 
             
               int 
               ⁡ 
               
                 [ 
                 
                   
                     
                       
                         f 
                         1 
                       
                       ⁢ 
                       δ 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           P 
                           1 
                           P 
                         
                         ⁡ 
                         
                           ( 
                           k 
                           ) 
                         
                       
                     
                     + 
                     
                       
                         f 
                         2 
                       
                       ⁢ 
                       δ 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           P 
                           2 
                           P 
                         
                         ⁡ 
                         
                           ( 
                           k 
                           ) 
                         
                       
                     
                   
                   
                     
                       λ 
                       WL 
                     
                     ⁡ 
                     
                       ( 
                       
                         
                           f 
                           1 
                         
                         + 
                         
                           f 
                           2 
                         
                       
                       ) 
                     
                   
                 
                 ] 
               
             
           
         
       
       
         
           
             
               δΔ 
               ⁢ 
               
                   
               
               ⁢ 
               
                 
                   N 
                   1 
                   P 
                 
                 ⁡ 
                 
                   ( 
                   k 
                   ) 
                 
               
             
             = 
             
               int 
               ⁡ 
               
                 [ 
                 
                   
                     
                       - 
                       
                         λ 
                         2 
                       
                     
                     
                       ( 
                       
                         
                           λ 
                           1 
                         
                         - 
                         
                           λ 
                           2 
                         
                       
                       ) 
                     
                   
                   ⁢ 
                   
                     
                       
                         
                           f 
                           1 
                         
                         ⁢ 
                         δ 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             P 
                             1 
                             P 
                           
                           ⁡ 
                           
                             ( 
                             k 
                             ) 
                           
                         
                       
                       + 
                       
                         
                           f 
                           2 
                         
                         ⁢ 
                         δ 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             P 
                             2 
                             P 
                           
                           ⁡ 
                           
                             ( 
                             k 
                             ) 
                           
                         
                       
                     
                     
                       
                         λ 
                         WL 
                       
                       ⁡ 
                       
                         ( 
                         
                           
                             f 
                             1 
                           
                           + 
                           
                             f 
                             2 
                           
                         
                         ) 
                       
                     
                   
                 
                 ] 
               
             
           
         
       
       
         
           
             
               δ 
               ⁢ 
               Δ 
               ⁢ 
               
                 
                   N 
                   2 
                   P 
                 
                 ⁡ 
                 
                   ( 
                   k 
                   ) 
                 
               
             
             = 
             
               int 
               ⁡ 
               
                 [ 
                 
                   
                     
                       - 
                       
                         λ 
                         1 
                       
                     
                     
                       ( 
                       
                         
                           λ 
                           1 
                         
                         - 
                         
                           λ 
                           2 
                         
                       
                       ) 
                     
                   
                   ⁢ 
                   
                     
                       
                         
                           f 
                           1 
                         
                         ⁢ 
                         δ 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             P 
                             1 
                             P 
                           
                           ⁡ 
                           
                             ( 
                             k 
                             ) 
                           
                         
                       
                       + 
                       
                         
                           f 
                           2 
                         
                         ⁢ 
                         δ 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             P 
                             2 
                             P 
                           
                           ⁡ 
                           
                             ( 
                             k 
                             ) 
                           
                         
                       
                     
                     
                       
                         λ 
                         WL 
                       
                       ⁡ 
                       
                         ( 
                         
                           
                             f 
                             1 
                           
                           + 
                           
                             f 
                             2 
                           
                         
                         ) 
                       
                     
                   
                 
                 ] 
               
             
           
         
       
     
     Preferably, the wide-lane cycle slip variation can be calculated by using the maximum value SPIE max  of the pseudo random error. 
     Preferably, a threshold model of the total electron content rate can further reduce remaining cycle slip candidate pairs, and can further revise carrier phase measurement values at the frequencies f 1  and f 2  for candidate pairs ΔN 1   P (k) cand  at the frequency f 1  and candidate pairs ΔN 2   P (k) cand  at the frequency f 2 :
 
 =Φ 1   P ( k )+Δ N   1   P ( k ) cand  
 
 =Φ 2   P ( k )+Δ N   2   P ( k ) cand  
 
     Preferably, when the probability of correct fix PCF and the probability of incorrect fix PIF are calculated for the integer ambiguity, a conditional variance of an ambiguity i is defined as σ i/I   2 , the conditional variance depends on previously fixed integer ambiguities of the set I={1, 2, . . . , i−1}, and an item (i, i) in a diagonal matrix D is generated from decomposition of a float solution estimated error covariance matrix LDL T  of cycle ambiguities. 
     Preferably, the probability of correct fix PCF is calculated, and for the calculation of the probability of incorrect fix PIF, a value of (a z) can be used, and a candidate value of interest in an incorrect fix event is calculated. 
     The present invention provides a kinematic-to-kinematic relative positioning processing procedure in the case of a long baseline: geometric correlation between two moving stations is determined according to a distance between the two moving stations, and different integer ambiguity calculation algorithms are selected, where an LAMBDA algorithm is directly used for calculation in the case of a short baseline distance, and in the case of a medium to long baseline distance, a wide-lane integer ambiguity is first calculated through direct rounding, and then an ambiguity at a single frequency, that is, a narrow-lane ambiguity, is calculated by using the LAMBDA algorithm. 
     The present invention proposes calculation of a probability of incorrect fix by calculating an ambiguity subset: for calculation of a probability of incorrect fix and a probability of correct fix for ambiguities, integer ambiguities are sequentially fixed using a bootstrap method, and sequential adjustment is performed according to variances of the integer ambiguity solutions, where an ambiguity with a minimum conditional variance needs to be fixed first, so as to improve a fixing rate of the integer ambiguities. 
     The present invention proposes construction of ambiguity candidate pairs by calculating partial ambiguities: a threshold of the probability of incorrect fix is calculated according to ambiguities that are already fixed; if the threshold is less than a specified integrity risk, the threshold is considered to be available. If a protection level calculated by using the ambiguities that are already fixed is greater than an alarm threshold, a candidate set of incorrect fix (IF) needs to be constructed; then an integrity risk value I H0  is calculated; next, it is compared whether the integrity risk value I H0  is less than I H0req  required by zero-fault integrity; if yes, the geometric mechanism is considered to be available; if the integrity risk value I H0  is greater than I H0req  required by zero-fault integrity, a float solution of a next ambiguity needs to be fixed, without traversing all the ambiguity candidate pairs. 
     The present invention proposes a method for calculating a VPL value: determining an upper limit and a lower limit of a VPL; checking whether a VPL position error statistical limit satisfies an overall integrity risk, and finding and outputting a VPL value that satisfies the integrity risk. 
     The present invention uses an integrity risk in a position domain with partial ambiguity resolution, and improves integrity and availability requirements of the position domain. When a satellite is visible in a time period that is longer than a maximum pre-filtering time, a pre-filtering time is set to be the maximum pre-filtering time; by applying a position domain integrity risk in navigation, position precision can be greatly improved, strict integrity and availability requirements can be satisfied, and calculation efficiency can be improved. Moreover, the integrity risk formula is also applicable to other cyclic resolution algorithms, and can fix a quantified probability at any given ambiguity candidate set. In a positioning and navigation process, an ambiguity subset is determined by using a probability lower than a PIF threshold in combination with a probability of incorrect fix, and float solutions of other ambiguities are reserved; then, a position estimated value is calculated by using partially fixed ambiguities, and a corresponding position domain protection level is calculated. Finally, influence of incorrect ambiguity fix is evaluated in the position domain, to calculate an integrity risk. 
     Compared with the prior art, the present invention achieves the following beneficial effects: 
     1. The present invention provides an integer ambiguity calculation algorithm for a kinematic-to-kinematic positioning system in the case of a long baseline, to calculate carrier phase integrity. 
     2. The present invention proposes fix of integer ambiguities by using a partial ambiguity resolution method, without traversing all integer spaces, thus greatly improving the calculation efficiency 
     3. The present invention provides a feasible calculation algorithm for long-baseline kinematic-to-kinematic relative positioning, thus effectively solving the problem of difficulty in ambiguity fix in the case of medium to long baselines. 
     4. The present invention helps motivate the research on carrier phase integrity, and can be effectively applied to practical kinematic-to-kinematic positioning application scenarios, to meet the integrity requirement while improving the positioning precision. 
     5. The present invention provides an idea for subsequent calculation of carrier phase protection level. 
     It should be appreciated that, the foregoing general description and the following detailed description are merely exemplary illustration and explanation, and should not be used as a limitation on the content claimed by the present invention. 
    
    
     
       BRIEF DESCRIPTION OF DRAWINGS 
       With reference to the accompanying drawings, more objectives, functions and advantages of the present invention will be illustrated through the following description of embodiments of the present invention, where: 
         FIG. 1  is a schematic flow block diagram of an analysis method according to the present invention; 
         FIG. 2  is a schematic flow block diagram of exchange of collected sample information according to an embodiment of the present invention; 
         FIG. 3  is a schematic flowchart of kinematic-to-kinematic relative positioning calculation according to the present invention; 
         FIG. 4  is a schematic flowchart of cycle slip detection according to the present invention; and 
         FIG. 5  is a schematic flowchart of calculating a position domain integrity risk based on partial fixation according to the present invention. 
     
    
    
     DETAILED DESCRIPTION 
     With reference to the exemplary embodiments, the objectives and functions of the present invention as well as methods for implementing the objectives and functions can be illustrated. However, the present invention is not limited to the exemplary embodiments disclosed below, and can be implemented in different forms. The essence of the specification is merely to help those in the related art understand the specific details of the present invention comprehensively. 
     In the following description, the embodiments of the present invention will be described with reference to the accompanying drawings. In the drawings, identical reference numerals represent identical or similar components, or identical or similar steps. 
     To make the content of the present invention described more clearly, a data source is described first. As shown in  FIG. 2 , which is a flow block diagram of exchange of collected sample information in an embodiment of the present invention, a satellite  100  provides collected information data to a first mobile station  200  and a second mobile station  300  respectively; a receive end  201  in the first mobile station  200  receives the information and performs algorithm processing on the information by using a data processor  202 ; a receive end  301  in the second mobile station  300  receives the information and performs algorithm processing on the information by using a data processor  302 ; information is exchanged between the receive end  201  and the receive end  301 . 
     The method in the present invention is specifically described through an example. For a carrier phase integrity algorithm, a specific processing procedure and calculation of data are described as follows (as shown in  FIG. 1 ): 
     a) Establish a kinematic-to-kinematic relative positioning model, and input navigation data. 
     b) Calculate a float solution of an integer ambiguity. 
     The float solution of the integer ambiguity is calculated by using a Gauss-Newton iterative method. The core idea is to approximately replace a nonlinear regression model by using a Taylor series expansion, then correct a regression coefficient multiple times through multiple iterations so that the regression coefficient continuously approximates an optimal regression coefficient of the nonlinear regression model, and finally a residual sum of squares of the original model is minimized. 
     (1) There are m known points:
         (x i , y 1 , z 1 ), (x 2 ,y 2 ,z 2 ), . . . , (x m ,y m ,z m )   (2) The function prototype is: y=f(x, β) where m≥n, and β=(β 1 , β 2 , . . . , β n ); the key is to find an optimal solution β to minimize the residual sum of squares:       

                 S   ⁡     (   β   )       =       ∑     i   =   1     m     ⁢           ⁢         r   i     ⁡     (   β   )       2         ,         
and thereore a residual can be calculated: r i =y i −f(x i ,β), where r i =y i −f(x i ,β).
 
     (3) A derivative of the formula (2) is taken, so that a minimum value of the residual sum of squares can be obtained; 
     
       
         
           
             
               
                 ∂ 
                 S 
               
               
                 ∂ 
                 
                   β 
                   j 
                 
               
             
             = 
             
               
                 2 
                 ⁢ 
                 
                   
                     ∑ 
                     i 
                   
                   ⁢ 
                   
                     
                       r 
                       i 
                     
                     ⁢ 
                     
                       
                         ∂ 
                         
                           r 
                           i 
                         
                       
                       
                         ∂ 
                         
                           β 
                           j 
                         
                       
                     
                   
                 
               
               = 
               
                 0 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   ( 
                   
                     
                       j 
                       = 
                       1 
                     
                     , 
                     … 
                     ⁢ 
                     
                         
                     
                     , 
                     n 
                   
                   ) 
                 
               
             
           
         
       
     
     A parameter calculated using an iterative least square method is closer to a parameter in a standard function, and a standard deviation is smaller. Therefore, the float solution of the ambiguity is calculated using the iterative least square method. 
     c) Detect and correct cycle slips based on a total electron content rate (TECR). 
     Based on a Melboume-Wübbena Wide Lane (MWWL) linear combination integrated with TECR information, cycle slips can be detected and corrected in real time. This method can completely eliminate influence of SIPE on cycle slip detection and correction, and the issue of cycle slip detection and correction is solved by using a single dual-frequency receiver (as shown in  FIG. 4 ). 
     This method uses total electron content rate (TECR) information in dual-frequency data from a single satellite of a single global positioning system receiver, while the pseudorange measurement is affected by an error in any range. A sudden increase in the pseudo random error (SIPE) is similar to a periodic fluctuation in nature, and is very common in various data collection scenarios. The basic principle of this method is the fact that an ionospheric TECR does not exceed a specific threshold (0.35 TECU/s). By evaluating the influence of the SIPE on cycle slip detection, a predefined large enough SIPE is given, and a search space for cycle slip candidate pairs is defined. Two cycle slip verification rules are proposed to verify cycle slip candidate pairs. Through the application of the two verification rules, over 99.9% of candidate pairs can be excluded. Based on the SIPE, the TECR threshold, and the size of a data sampling interval, a theoretic maximum number of remaining cycle slip candidate pairs (NRCP) can be calculated precisely. 
     Step 1: MW-based linear combination and TECR measurement 
     First of all, two formulas are provided, which represent MWWL-based linear combination and ionospheric TECR measurement respectively. The MWWL linear combination has been widely applied to cycle slip detection and correction, because it eliminates influence of atmosphere (including ionosphere and troposphere), a geometric structure of the satellite, and a receiver clock. 
     
       
         
           
             
               
                 
                   
                     [ 
                     
                       
                         Δ 
                         ⁢ 
                         
                           
                             N 
                             1 
                             P 
                           
                           ⁡ 
                           
                             ( 
                             k 
                             ) 
                           
                         
                       
                       - 
                       
                         Δ 
                         ⁢ 
                         
                           
                             N 
                             2 
                             P 
                           
                           ⁡ 
                           
                             ( 
                             k 
                             ) 
                           
                         
                       
                     
                     ] 
                   
                   = 
                   
                     
                       
                         
                           N 
                           WL 
                           P 
                         
                         ⁡ 
                         
                           ( 
                           
                             k 
                             - 
                             1 
                           
                           ) 
                         
                       
                       - 
                       
                         
                           N 
                           WL 
                           P 
                         
                         ⁡ 
                         
                           ( 
                           k 
                           ) 
                         
                       
                     
                     = 
                     
                       
                         [ 
                         
                             
                         
                         ⁢ 
                         
                           
                             
                               Φ 
                               1 
                               P 
                             
                             ⁡ 
                             
                               ( 
                               
                                 k 
                                 - 
                                 1 
                               
                               ) 
                             
                           
                           - 
                           
                             
                               Φ 
                               2 
                               P 
                             
                             ⁡ 
                             
                               ( 
                               
                                 k 
                                 - 
                                 1 
                               
                               ) 
                             
                           
                           - 
                           
                             
                               
                                 
                                   f 
                                   1 
                                 
                                 ⁢ 
                                 
                                   
                                     P 
                                     1 
                                     P 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     
                                       k 
                                       - 
                                       1 
                                     
                                     ) 
                                   
                                 
                               
                               + 
                               
                                 
                                   f 
                                   2 
                                 
                                 ⁢ 
                                 
                                   
                                     P 
                                     2 
                                     P 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     
                                       k 
                                       - 
                                       1 
                                     
                                     ) 
                                   
                                 
                               
                             
                             
                               
                                 λ 
                                 WL 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     f 
                                     1 
                                   
                                   + 
                                   
                                     f 
                                     2 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                         ] 
                       
                       - 
                       
                         [ 
                         
                             
                         
                         ⁢ 
                         
                           
                             
                               Φ 
                               1 
                               P 
                             
                             ⁡ 
                             
                               ( 
                               k 
                               ) 
                             
                           
                           - 
                           
                             
                               Φ 
                               2 
                               P 
                             
                             ⁡ 
                             
                               ( 
                               k 
                               ) 
                             
                           
                           - 
                           
                             
                               
                                 
                                   f 
                                   1 
                                 
                                 ⁢ 
                                 
                                   
                                     P 
                                     1 
                                     P 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     k 
                                     ) 
                                   
                                 
                               
                               + 
                               
                                 
                                   f 
                                   2 
                                 
                                 ⁢ 
                                 
                                   
                                     P 
                                     2 
                                     P 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     k 
                                     ) 
                                   
                                 
                               
                             
                             
                               
                                 λ 
                                 
                                   W 
                                   ⁢ 
                                   L 
                                 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   
                                     f 
                                     1 
                                   
                                   + 
                                   
                                     f 
                                     2 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                         ] 
                       
                     
                   
                 
                 ; 
               
               ⁢ 
               
                 
 
               
               [ 
               
                 
                   
                     λ 
                     1 
                   
                   ⁢ 
                   Δ 
                   ⁢ 
                   
                     
                       N 
                       1 
                       P 
                     
                     ⁡ 
                     
                       ( 
                       k 
                       ) 
                     
                   
                 
                 - 
                 
                   
                     λ 
                     2 
                   
                   ⁢ 
                   Δ 
                   ⁢ 
                   
                     
                       N 
                       2 
                       P 
                     
                     ⁡ 
                     
                       ( 
                       k 
                       ) 
                     
                   
                 
               
               ] 
             
             = 
             
               
                 
                   4 
                   ⁢ 
                   
                     0 
                     . 
                     3 
                   
                   × 
                   1 
                   ⁢ 
                   
                     0 
                     
                       1 
                       ⁢ 
                       6 
                     
                   
                   ⁢ 
                   
                     ( 
                     
                       γ 
                       - 
                       1 
                     
                     ) 
                   
                   ⁢ 
                   Δ 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     t 
                     · 
                     
                       
                         TECR 
                         Φ 
                       
                       ⁡ 
                       
                         ( 
                         k 
                         ) 
                       
                     
                   
                 
                 
                   f 
                   1 
                   2 
                 
               
               - 
               
                 
                   λ 
                   1 
                 
                 ⁡ 
                 
                   [ 
                   
                     
                       
                         Φ 
                         1 
                         P 
                       
                       ⁡ 
                       
                         ( 
                         k 
                         ) 
                       
                     
                     - 
                     
                       
                         Φ 
                         1 
                         P 
                       
                       ⁡ 
                       
                         ( 
                         
                           k 
                           - 
                           1 
                         
                         ) 
                       
                     
                   
                   ] 
                 
               
               + 
               
                 
                   λ 
                   2 
                 
                 ⁡ 
                 
                   [ 
                   
                     
                       
                         Φ 
                         2 
                         P 
                       
                       ⁡ 
                       
                         ( 
                         k 
                         ) 
                       
                     
                     - 
                     
                       
                         Φ 
                         2 
                         P 
                       
                       ⁡ 
                       
                         ( 
                         
                           k 
                           - 
                           1 
                         
                         ) 
                       
                     
                   
                   ] 
                 
               
             
           
         
       
     
     where f 1 , f 2  represent two frequencies of a received double-frequency satellite signal; λ 1 , λ 2  represent wavelengths at corresponding frequencies; 
               γ   =       f   1   2       f   2   2         ;       λ   WL     =     C     (       f   1     -     f   2       )         ;         
TECR Φ (k) represents an ionospheric total electron content rate at an epoch K; Φ 1   P (k) and Φ 1   P (k−1) represent carrier phase measurement values between two adjacent epochs at the frequency f 1 ; P 1   P (k) and P 1   P (k−1) represent pseudorange measurement values between two adjacent epochs at the frequency f 1 ; ΔN 1   P (k) and ΔN 2   P (k) represent cycle slips that are detected at the frequencies f 1  and f 2  using a cycle as a unit respectively.
 
     Step 2: Influence of SPIE on cycle slip detection 
     Precise influence of a pseudorange error on cycle slip detection and positioning is estimated. At the epoch K, pseudorange measurements at two frequencies are required. If a pseudorange measurement value is SPIE, cycle slip detection in the formula is very likely to be affected. Pseudorange measurements of SPIE at two frequencies are defined as δP 1   P (k) and δP 2   P (k). Therefore, a maximum value of SPIE is:
 
SPIE max   ={|δP   1   P ( k )|,|δ P   2   P ( k )|},δ P   1   P ( k ),δ P   2   P ( k )∈(−∞,+∞)
 
     Therefore, δΔN 1   P (k) max , δΔN 2   P (k) max  and δ[ΔN 1   P (k)−ΔN 2   P (k)] max  can be obtained through based on the foregoing equation, where the formulas are as follows: 
     
       
         
           
             
               δ 
               ⁡ 
               
                 [ 
                 
                   
                     Δ 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       
                         N 
                         1 
                         P 
                       
                       ⁡ 
                       
                         ( 
                         k 
                         ) 
                       
                     
                   
                   - 
                   
                     Δ 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       
                         N 
                         2 
                         P 
                       
                       ⁡ 
                       
                         ( 
                         k 
                         ) 
                       
                     
                   
                 
                 ] 
               
             
             = 
             
               int 
               ⁡ 
               
                 [ 
                 
                   
                     
                       
                         f 
                         1 
                       
                       ⁢ 
                       δ 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           P 
                           1 
                           P 
                         
                         ⁡ 
                         
                           ( 
                           k 
                           ) 
                         
                       
                     
                     + 
                     
                       
                         f 
                         2 
                       
                       ⁢ 
                       δ 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           P 
                           2 
                           P 
                         
                         ⁡ 
                         
                           ( 
                           k 
                           ) 
                         
                       
                     
                   
                   
                     
                       λ 
                       WL 
                     
                     ⁡ 
                     
                       ( 
                       
                         
                           f 
                           1 
                         
                         + 
                         
                           f 
                           2 
                         
                       
                       ) 
                     
                   
                 
                 ] 
               
             
           
         
       
       
         
           
             
               δ 
               ⁢ 
               Δ 
               ⁢ 
               
                 
                   N 
                   1 
                   P 
                 
                 ⁡ 
                 
                   ( 
                   k 
                   ) 
                 
               
             
             = 
             
               int 
               ⁡ 
               
                 [ 
                 
                   
                     
                       - 
                       
                         λ 
                         2 
                       
                     
                     
                       ( 
                       
                         
                           λ 
                           1 
                         
                         - 
                         
                           λ 
                           2 
                         
                       
                       ) 
                     
                   
                   ⁢ 
                   
                     
                       
                         
                           f 
                           1 
                         
                         ⁢ 
                         δ 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             P 
                             1 
                             P 
                           
                           ⁡ 
                           
                             ( 
                             k 
                             ) 
                           
                         
                       
                       + 
                       
                         
                           f 
                           2 
                         
                         ⁢ 
                         δ 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             P 
                             2 
                             P 
                           
                           ⁡ 
                           
                             ( 
                             k 
                             ) 
                           
                         
                       
                     
                     
                       
                         λ 
                         WL 
                       
                       ⁡ 
                       
                         ( 
                         
                           
                             f 
                             1 
                           
                           + 
                           
                             f 
                             2 
                           
                         
                         ) 
                       
                     
                   
                 
                 ] 
               
             
           
         
       
       
         
           
             
               δ 
               ⁢ 
               Δ 
               ⁢ 
               
                 
                   N 
                   2 
                   P 
                 
                 ⁡ 
                 
                   ( 
                   k 
                   ) 
                 
               
             
             = 
             
               int 
               ⁡ 
               
                 [ 
                 
                   
                     
                       - 
                       
                         λ 
                         1 
                       
                     
                     
                       ( 
                       
                         
                           λ 
                           1 
                         
                         - 
                         
                           λ 
                           2 
                         
                       
                       ) 
                     
                   
                   ⁢ 
                   
                     
                       
                         
                           f 
                           1 
                         
                         ⁢ 
                         δ 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             P 
                             1 
                             P 
                           
                           ⁡ 
                           
                             ( 
                             k 
                             ) 
                           
                         
                       
                       + 
                       
                         
                           f 
                           2 
                         
                         ⁢ 
                         δ 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             P 
                             2 
                             P 
                           
                           ⁡ 
                           
                             ( 
                             k 
                             ) 
                           
                         
                       
                     
                     
                       
                         λ 
                         WL 
                       
                       ⁡ 
                       
                         ( 
                         
                           
                             f 
                             1 
                           
                           + 
                           
                             f 
                             2 
                           
                         
                         ) 
                       
                     
                   
                 
                 ] 
               
             
           
         
       
     
     Step 3: Define cycle slip search areas 
     Correct cycle slips at L1 can be inferred from the foregoing description, which are represented as represent: ΔN 1   P (k) cand . Similarly, correct cycle slips at L2 are defined as ΔN 2 (k) cand . Therefore, a correct cycle slip search space can be obtained:
 
 SS   ΔN     1       P   ( k ):Δ N   1   P ( k )−δΔ N   1   P ( k )≤Δ N   1   P ( k ) cand   ≤ΔN   1   P ( k )+δΔ N   1   P ( k );
 
 SS   ΔN     2       P   ( k ):Δ N   2   P ( k )−δΔ N   2   P ( k )≤Δ N   2   P ( k ) cand   ≤ΔN   2   P ( k )+δΔ N   2   P ( k );
 
     Step 4: Cycle slip search rules and estimation of remaining candidate pairs 
     Cycle slip search is implemented mainly through two processes. First, most cycle slip candidate pairs are excluded through a wide-lane cycle slip variation rule, and then remaining candidate pairs are further estimated by using a TCER threshold. 
     Cycle slip search rule 1: wide-lane cycle slip variation 
     The wide-lane cycle slip variation can be calculated by using SPIE max , and the difference from the previous wide-lane cycle slip calculation is that SPIE is not taken into consideration in the previous calculation. 
     Cycle Slip Search Rule 2: TECR Threshold 
     The TECR threshold model can further reduce the NRCP, and each candidate pair ΔN 1   P (k) cand  and ΔN 2   P (k) cand  can further correct carrier phase measurement values:
 
 =Φ 1   P ( k )+Δ N   1   P ( k ) cand  
 
 =Φ 2   P ( k )+Δ N   2   P ( k ) cand  
 
     The value of TECR can be calculated between adjacent epochs:
 
TECR Φ ( k )= H{λ   1 [Φ 1   P ( k )−Φ 1   P ( k− 1)]+λ 2 [Φ 2   P ( k− 1)−Φ 2   P ( k )]+[λ 1   ΔN   1   P ( k ) cand −λ 2   ΔN   2   P ( k ) cand ]};
 
     where 
     
       
         
           
             
               H 
               = 
               
                 
                   f 
                   1 
                   2 
                 
                 
                   4 
                   ⁢ 
                   
                     0 
                     . 
                     3 
                   
                   × 
                   1 
                   ⁢ 
                   
                     0 
                     
                       1 
                       ⁢ 
                       6 
                     
                   
                   ⁢ 
                   
                     ( 
                     
                       γ 
                       - 
                       1 
                     
                     ) 
                   
                   ⁢ 
                   Δ 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   t 
                 
               
             
             ; 
           
         
       
     
     d) Calculate a probability of correct fix PCF and a probability of incorrect fix PIF for the integer ambiguity. 
     Calculation of a probability that a certain group of ambiguities is correct depends on a fixation method in use. In the calculation process, a bootstrap method is used. This method provides a prior probability quality function about an integer estimation error in a closed form. It is required that the ambiguities should be fixed sequentially according to a particular standard sequence, and that PCF calculation should be provided in each step in the fix process. Sequential adjustment is performed according to variances of the integer ambiguity solutions, where an ambiguity with a minimum conditional variance needs to be fixed first 
     It is defined that a conditional variance of an ambiguity i is σ i/l   2 , the conditional variance depends on previously fixed integer ambiguities of a set I={1, 2, . . . , i−1}, and an item (i, i) in a diagonal matrix D is generated from decomposition of a float solution estimated error covariance matrix LDL T  of cycle ambiguities. In each step (such as the m th  step) of the sequence, it is assumed that a correctly fixed integer ambiguity is a, and a probability that the integer ambiguity value {hacek over (a)} (which is a vector of m×1) estimated using a bootstrap method is equal to the candidate ambiguity value Z calculated from the correctly fixed integer ambiguity a is shown by the following equation: 
     
       
         
           
             
               P 
               ⁢ 
               
                 ( 
                 
                   
                     a 
                     ⋓ 
                   
                   = 
                   z 
                 
                 ) 
               
             
             = 
             
               
                 ∏ 
                 
                   i 
                   = 
                   1 
                 
                 m 
               
               ⁢ 
               
                 [ 
                 
                   
                     Φ 
                     ⁡ 
                     
                       ( 
                       
                         
                           1 
                           - 
                           
                             2 
                             ⁢ 
                             
                               
                                 I 
                                 i 
                                 T 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   a 
                                   - 
                                   z 
                                 
                                 ) 
                               
                             
                           
                         
                         
                           2 
                           ⁢ 
                           
                             σ 
                             
                               i 
                               / 
                               I 
                             
                           
                         
                       
                       ) 
                     
                   
                   + 
                   
                     Φ 
                     ⁡ 
                     
                       ( 
                       
                         
                           1 
                           + 
                           
                             2 
                             ⁢ 
                             
                               
                                 I 
                                 i 
                                 T 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   a 
                                   - 
                                   z 
                                 
                                 ) 
                               
                             
                           
                         
                         
                           2 
                           ⁢ 
                           
                             σ 
                             
                               i 
                               / 
                               I 
                             
                           
                         
                       
                       ) 
                     
                   
                   - 
                   1 
                 
                 ] 
               
             
           
         
       
     
     where I i  represents the i th  column vector of a unit-lower-triangular matrix L −T  generated from decomposition of LDL T  of a fuzzy covariance matrix; m represents the number of fixed integer ambiguities, m&lt;n, and 
     
       
         
           
             
               
                 Φ 
                 ⁡ 
                 
                   ( 
                   x 
                   ) 
                 
               
               = 
               
                 
                   ∫ 
                   
                     - 
                     ∞ 
                   
                   x 
                 
                 ⁢ 
                 
                   
                     ( 
                     
                       1 
                       / 
                       
                         
                           2 
                           ⁢ 
                           π 
                         
                       
                     
                     ) 
                   
                   ⁢ 
                   
                     exp 
                     ⁡ 
                     
                       ( 
                       
                         
                           - 
                           
                             1 
                             2 
                           
                         
                         ⁢ 
                         
                           v 
                           2 
                         
                       
                       ) 
                     
                   
                   ⁢ 
                   d 
                   ⁢ 
                   v 
                 
               
             
             ; 
           
         
       
     
     when the correctly fixed integer ambiguity a is equal to the candidate ambiguity value Z, the probability of correct fix PCF can be calculated: 
     
       
         
           
             
               P 
               ⁡ 
               
                 ( 
                 
                   
                     a 
                     ⋓ 
                   
                   = 
                   a 
                 
                 ) 
               
             
             = 
             
               
                 ∏ 
                 
                   i 
                   = 
                   1 
                 
                 m 
               
               ⁢ 
               
                 [ 
                 
                   
                     2 
                     ⁢ 
                     
                       Φ 
                       ⁡ 
                       
                         ( 
                         
                           1 
                           
                             2 
                             ⁢ 
                             
                               σ 
                               
                                 i 
                                 / 
                                 I 
                               
                             
                           
                         
                         ) 
                       
                     
                   
                   - 
                   1 
                 
                 ] 
               
             
           
         
       
     
     For the calculation of PIF, a value of (a−z) can be used, and a candidate value of interest in an incorrect fix event is calculated. For example, if an error of one cycle exists in the first event of incorrect fix of ambiguity (IF 1 ), it can be obtained that (a−z)=[1 0 . . . 0] T . 
     e) Determine a fault to be detected and a satellite fault probability 
     A method for detecting a fault mode is established by using the probability of incorrect fix PIF calculated in step d). It is specified that PIF i =P event,i , where P event,i  represents a prior probability of an independent error event i. In addition, it is defined that a maximum number of faulty satellites is N fault,max . N fault,max  is calculated by calculating a probability of a multi-fault mode consisting of r or more independent events, and also represents a maximum allowable number of faults.
 
 N   fault,max =max{ r∈ 1, . . . , N   sat   |P   multiple ( r+ 1, P   event,1   , . . . ,P   event,N     sat     +N     const   )≤ P   FAVLT_THRES }
 
     Once N fault,max  is determined, N fault,max  of a combination corresponding to all subsets is determined, and thus a satellite fault probability can be determined. 
     f) Calculate a standard deviation δ v|CF  and a position domain deviation b m . 
     A series of models with errors can be effectively prevented by using a solution separation method. Therefore, this method is usually used as an optimal statistic. In some cases, the solution separation method has optimality. Test is carried out with Gaussian noise, to establish the following models: y=Gx+ε and 
             {               x   ^     =   Sy               S   =         (       G   T     ⁢   WG     )       -   1       ⁢   GW             ;           
thus the standard deviation δ v|CF  and the position domain deviation b m  are calculated.
 
     It is assumed that an ambiguity float solution-relative position vector matrix Ŝ and a related estimated error covariance matrix are defined as follows: 
     
       
         
           
             
               
                 S 
                 ^ 
               
               = 
               
                 [ 
                 
                   
                     
                       
                         x 
                         ^ 
                       
                     
                   
                   
                     
                       
                         N 
                         ^ 
                       
                     
                   
                 
                 ] 
               
             
             ; 
             
               P 
               = 
               
                 [ 
                 
                   
                     
                       
                         P 
                         
                           x 
                           ^ 
                         
                       
                     
                     
                       
                         P 
                         
                           
                             x 
                             ^ 
                           
                           ⁢ 
                           
                             N 
                             ^ 
                           
                         
                       
                     
                   
                   
                     
                       
                         P 
                         
                           
                             N 
                             ^ 
                           
                           ⁢ 
                           
                             x 
                             ^ 
                           
                         
                       
                     
                     
                       
                         P 
                         
                           N 
                           ^ 
                         
                       
                     
                   
                 
                 ] 
               
             
           
         
       
     
     Step 1: Round the k th  ambiguity {circumflex over (N)} Z   (k)  to the closest integer N Z   (k)  in Z transition decorrelation space, where the expression is as follows: N Z   (k) =round([0 1×3  Z k ]S (k-1) ), 
     where Z k  represents the k th  row in a transition matrix Z; Z 1:k =[ 0   1×(k-1)  1 0 1×(n-k) ]; S (k-1)  represents an updated state vector S based on fixed ambiguities 1→K; 
     Step 2: Calculate the standard deviation δ v|CF . 
     Position vector estimation and remaining ambiguity real values S are updated continuously, where the process is as follows:
 
 K=P   (k-1) [0 1×3   Z   k ] T ([0 1×3   Z   k ] T   P   (k-1) [0 1×3   Z   k ] T ) −1  
 
 S   (k)   =S   (k-1)   +K ( N   Z   (k) −[0 1×3   Z   k ] T   S   (k-1) )
 
 P   (k) =( I−K [0 1×3   Z   k ]) P   (k-1)  
 
     P represents a covariance matrix of position and float ambiguity state estimated error; P (k)  represents a covariance matrix of an updated state vector after the k th  ambiguity is fixed; and it is assumed that δ v|CF =√{square root over (P (3,3)   (m) )} after m iterations. 
     Step 3: Calculate the position domain deviation b m . 
     For calculation of the position domain deviation b m , after m ambiguities are fixed, the following calculation may be carried out:
 
 K=P [0 m×3   Z   1:m ] T ([0 m×3   Z   1:m ] P [0 m×3   Z   1:m ] T ) −1  
 
 S ( m )= Ŝ+K ( N   Z   (1:m) −[0 m×3   Z   1:m ] T   Ŝ )
 
     where Z 1:m  represents a transition matrix Z of a row vector 1 to m; and Z 1:m  is expressed as Z 1:m =[I m×m  0 m×(n-m) ] 
     If it is assumed that a correctly fixed ambiguity vector is a m  and an incorrectly fixed ambiguity vector is z m , the estimation state will become a correct state S CF  or an incorrect state S IF  after fix of the ambiguity, where the formulas are as follows:
 
 S   CF   (m)   =Ŝ+K ( a   m −[0 m×3   Z   1:m ] Ŝ )
 
 S   IF   (m)   =Ŝ+K ( z   m −[0 m×3   Z   1:m ] Ŝ );
 
     Therefore, the position domain deviation b m  caused by a relative position error of the m th  incorrect candidate pair (a−z) m  is:
 
 b   m   =S   CF   (m)   −S   IF   (m)   =K ( a−z ) m  
 
     g) Calculate an integrity risk value of a carrier phase. 
     It is specified that P VALCF =P{|{circumflex over (x)} v −x v |&gt;VAL|CF}, P VALIF =P{|{circumflex over (x)} v −x v |&gt;VAL|IF n }. Before an estimation vertical error exceeds a probability of a vertical protection level probability, for the purpose of simplification without loss of generality, conditional events CF and IF n  are replaced by a general event B. To solve the difference between the correct fix event CF and the incorrect fix event IF and discuss a specific method of each event, by expanding an absolute value in a conditional probability formula, the following formula can be obtained based on a probability that a vertical error of occurrence of a given event B exceeds the VAL:
 
 P{|{circumflex over (x)}   v   −x   v   |&gt;VAL}B=P {( {circumflex over (x)}   v   −x   v )&lt;− VAL|B}+P {( {circumflex over (x)}   v   −x   v )&gt; VAL|B} 
 
     A position vector is estimated linearly by using GNSS measurement. It is assumed that the GNSS measurement has a zero-mean Gaussian error distribution. Therefore, the distribution of vertical position estimation errors is also a Gaussian distribution, and the standard deviation thereof is defined as ϵ v|B . The mean of such a distribution depends on the event B, and the mean is denoted as μ B . If the mean μ B  and the standard deviation δ v|B  are known, probabilities of the first item and the second item in the foregoing formula can be calculated by using a normal cumulative distribution function at extremes of −VAL and VAL respectively. 
     The standard deviation of the vertical position error is not affected by the incorrect fix. Therefore, δ v|B =δ v|CF , so P VALIF  can be calculated by using a normal cumulative distribution function, where the standard deviation is δ=δ v|CF , and the mean is μ IFn =b m . 
     Therefore, the integrity risk value I H0  is expressed as follows: 
     
       
         
           
             
               I 
               
                 H 
                 ⁢ 
                 0 
               
             
             = 
             
               1 
               - 
               
                 
                   ( 
                   
                     1 
                     - 
                     
                       P 
                       ⁢ 
                       
                         { 
                         
                           
                             
                                
                               
                                 
                                   
                                     x 
                                     ^ 
                                   
                                   v 
                                 
                                 - 
                                 
                                   x 
                                   v 
                                 
                               
                                
                             
                             &gt; 
                             VAL 
                           
                           | 
                           
                             C 
                             ⁢ 
                             F 
                           
                         
                         } 
                       
                     
                   
                   ) 
                 
                 ⁢ 
                 PCF 
               
               - 
               
                 
                   ∑ 
                   
                     n 
                     = 
                     1 
                   
                   k 
                 
                 ⁢ 
                 
                   
                     ( 
                     
                       1 
                       - 
                       
                         P 
                         ⁢ 
                         
                           { 
                           
                             
                               
                                  
                                 
                                   
                                     
                                       x 
                                       ^ 
                                     
                                     v 
                                   
                                   - 
                                   
                                     x 
                                     v 
                                   
                                 
                                  
                               
                               &gt; 
                               VAL 
                             
                             | 
                             
                               IF 
                               n 
                             
                           
                           } 
                         
                       
                     
                     ) 
                   
                   ⁢ 
                   
                     PIF 
                     n 
                   
                 
               
             
           
         
       
     
     The present invention provides a kinematic-to-kinematic relative positioning processing procedure in the case of a long baseline: geometric correlation between two moving stations is determined according to a distance between the two moving stations, and different integer ambiguity calculation algorithms are selected, where an LAMBDA algorithm is directly used for calculation in the case of a short baseline distance, and in the case of a medium to long baseline distance, a wide-lane integer ambiguity is first calculated through direct rounding, and then an ambiguity at a single frequency, that is, a narrow-lane ambiguity, is calculated by using the LAMBDA algorithm. 
     The present invention proposes calculation of a probability of incorrect fix by calculating an ambiguity subset: for calculation of a probability of incorrect fix and a probability of correct fix for ambiguities, integer ambiguities are sequentially fixed using a bootstrap method, and sequential adjustment is performed according to variances of the integer ambiguity solutions, where an ambiguity with a minimum conditional variance needs to be fixed first, so as to improve a fixing rate of the integer ambiguities. 
     The present invention proposes construction of ambiguity candidate pairs by calculating partial ambiguities: a threshold of the probability of incorrect fix is calculated according to ambiguities that are already fixed; if the threshold is less than a specified integrity risk, the threshold is considered to be available. If a protection level calculated by using the ambiguities that are already fixed is greater than an alarm threshold, a candidate set of incorrect fix (IF) needs to be constructed; then an integrity risk value I H0  is calculated; next, it is compared whether the integrity risk value I H0  is less than I H0req  required by zero-fault integrity; if yes, the geometric mechanism is considered to be available; if the integrity risk value I H0  is greater than I H0req  required by zero-fault integrity, a float solution of a next ambiguity needs to be fixed, without traversing all the ambiguity candidate pairs (as shown in  FIG. 5 ), where {circumflex over (N)} represents a float solution of an ambiguity, and N represents a fixed solution of the ambiguity obtained after the float solution of the ambiguity is fixed. 
     The present invention proposes a method for calculating a vertical protection level VPL value: determining an upper limit and a lower limit of a VPL; checking whether a VPL position error statistical limit satisfies an overall integrity risk, and finding and outputting a VPL value that satisfies the integrity risk. 
     The present invention uses an integrity risk in a position domain with partial ambiguity resolution, and improves integrity and availability requirements of the position domain. When a satellite is visible in a time period that is longer than a maximum pre-filtering time, a pre-filtering time is set to be the maximum pre-filtering time; by applying a position domain integrity risk in navigation, position precision can be greatly improved, strict integrity and availability requirements can be satisfied, and calculation efficiency can be improved. Moreover, the integrity risk formula is also applicable to other cyclic resolution algorithms, and can fix a quantified probability at any given ambiguity candidate set. In a positioning and navigation process, an ambiguity subset is determined by using a probability lower than a PIF threshold in combination with a probability of incorrect fix, and float solutions of other ambiguities are reserved; then, a position estimated value is calculated by using partially fixed ambiguities, and a corresponding position domain protection level is calculated. Finally, influence of incorrect ambiguity fix is evaluated in the position domain, to calculate an integrity risk. 
     The present invention has the following beneficial effects: The present invention provides an integer ambiguity calculation algorithm for a kinematic-to-kinematic positioning system in the case of a long baseline, to calculate carrier phase integrity. The present invention proposes fix of integer ambiguities by using a partial ambiguity resolution method, without traversing all integer spaces, thus greatly improving the calculation efficiency. The present invention provides a feasible calculation algorithm for long-baseline kinematic-to-kinematic relative positioning, thus effectively solving the problem of difficulty in ambiguity fix in the case of medium to long baselines. The present invention helps motivate the research on carrier phase integrity, and can be effectively applied to practical kinematic-to-kinematic positioning application scenarios, to meet the integrity requirement while improving the positioning precision. The present invention provides an idea for subsequent calculation of carrier phase protection level. 
     With reference to the description and practice of the present invention disclosed herein, other embodiments of the present invention are easily conceivable and comprehensible for those skilled in the art. The description and embodiments are merely considered as examples. The real scope and subject of the present invention are both defined by the claims.