Module cycle_slip 

Dual-frequency cycle-slip detection for PPP preprocessing.

use sidereon_core::carrier_phase::SlipReason;
use sidereon_core::constants::{C_M_S, F_L1_HZ, F_L2_HZ};
use sidereon_core::precise_positioning::{
    detect_cycle_slips, CycleSlipConfig, DualFrequencyEpoch, DualFrequencyObservation,
};

fn observation(epoch: usize, wide_lane_cycles: f64) -> DualFrequencyObservation {
    let geometric_m = 23_000_000.0 + epoch as f64 * 100.0;
    let lambda1 = C_M_S / F_L1_HZ;
    let lambda2 = C_M_S / F_L2_HZ;
    let lambda_wl = C_M_S / (F_L1_HZ - F_L2_HZ);
    let l2_m = geometric_m + lambda_wl * wide_lane_cycles;
    let l1_m = l2_m;
    DualFrequencyObservation {
        satellite_id: "G01".to_string(),
        ambiguity_id: "G01".to_string(),
        p1_m: geometric_m,
        p2_m: geometric_m,
        phi1_cyc: l1_m / lambda1,
        phi2_cyc: l2_m / lambda2,
        f1_hz: F_L1_HZ,
        f2_hz: F_L2_HZ,
        lli1: None,
        lli2: None,
    }
}

let epochs = (0..4)
    .map(|epoch| DualFrequencyEpoch {
        gap_time_s: Some(epoch as f64 * 30.0),
        observations: vec![observation(epoch, if epoch >= 2 { 9.0 } else { 5.0 })],
    })
    .collect::<Vec<_>>();
let config = CycleSlipConfig {
    melbourne_wubbena_threshold_cycles: 2.0,
    geometry_free_threshold_m: 0.05,
    maximum_gap_s: 120.0,
    ..CycleSlipConfig::default()
};

let flags = detect_cycle_slips(&epochs, config)?;
assert!(!flags[1].observations[0].slip);
assert_eq!(
    flags[2].observations[0].reasons,
    vec![SlipReason::MelbourneWubbena]
);

Structs

CycleSlipConfig

Configuration for dual-frequency PPP cycle-slip detection.

CycleSlipDetectorState

Stateful detector storage keyed by PPP satellite and ambiguity identifiers.

CycleSlipFlagEpoch

Cycle-slip flags for one input dual-frequency epoch.

CycleSlipFlagObservation

Cycle-slip flag for one satellite observation in an epoch.

GeometryFreeUpdate

Result from updating one satellite’s geometry-free detector state.

MelbourneWubbenaUpdate

Result from updating one satellite’s Melbourne-Wubbena detector state.

RunningMeanVariance

Running mean and variance for a scalar observable.

SatelliteCycleSlipState

Running cycle-slip detector state for one satellite/ambiguity arc.

Enums

CycleSlipConfigError

Validation error for CycleSlipConfig.

CycleSlipError

Error produced while evaluating a cycle-slip detector sample.

Constants

DEFAULT_MINIMUM_ARC_LENGTH

Default minimum number of usable samples required for a stable arc.

DEFAULT_RUNNING_STATISTIC_K_FACTOR

Default sigma multiplier applied to running Melbourne-Wubbena statistics.

Functions

detect_cycle_slips

Detect cycle slips across an ordered sequence of dual-frequency PPP epochs.

geometry_free_m

Compute the geometry-free phase combination L1 - L2, in meters.

melbourne_wubbena_cycles

Compute the Melbourne-Wubbena combination in wide-lane cycles.

update_geometry_free

Update one satellite state with a geometry-free sample and classify it.

update_melbourne_wubbena

Update one satellite state with a Melbourne-Wubbena sample and classify it.

Type Aliases

CycleSlipStateKey

Detector-state map key (satellite_id, ambiguity_id).