config

package
v0.38.1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Feb 23, 2026 License: Apache-2.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func BuildDefaultTDCP added in v0.34.0

BuildDefaultTDCP creates a TDCP pipeline with sensible defaults. This is a convenience function for simple use cases.

You only need to provide:

  • receiverPosition: Your receiver's ECEF coordinates
  • ephemerisStore: The ephemeris data source

Returns a complete TDCP pipeline ready to process observations.

Types

type CombinationConfig

type CombinationConfig struct {
	IonosphereFree   bool // ionosphere-free combination
	NarrowLane       bool // narrow-lane combination
	WideLane         bool // wide-lane combination
	GeometryFree     bool // geometry-free combination
	MelbourneWubbena bool // Melbourne-Wübbena combination
}

CombinationConfig enables/disables linear combinations.

type CorrectionConfig

type CorrectionConfig struct {
	Troposphere  bool // tropospheric delay
	Ionosphere   bool // ionospheric delay (if single-freq or testing)
	Sagnac       bool // Sagnac effect
	PhaseWindup  bool // carrier phase windup
	Relativity   bool // relativistic effects
	TidalLoading bool // solid earth tide
	OceanLoading bool // ocean loading
	PCV          bool // phase center variation
	PCO          bool // phase center offset
}

CorrectionConfig enables/disables individual corrections. This allows A/B testing of corrections to see their impact.

type ModelConfig

type ModelConfig struct {
	// Troposphere model: "niell", "sasstamoinen", "stanag"
	Troposphere string

	// Ionosphere model: "klobuchar", "nequickg", "bdgim", "dual-freq"
	Ionosphere string

	// Satellite position: "broadcast", "precise" (SP3)
	SatellitePosition string

	// Clock: "broadcast", "precise" (SP3 or CLK)
	Clock string
}

ModelConfig specifies which models to use for various corrections.

type PPPARConfig

type PPPARConfig struct {
	ProcessingConfig // Embed base processing configuration

	// Precise product settings
	SP3FilePath   string // Path to SP3 precise orbit file
	CLKFilePath   string // Path to clock (CLK) file
	BiasSINEXPath string // Path to Bias-SINEX file (CODE or IGS)
	VMFGridPath   string // Path to VMF troposphere grid files
	AntexFilePath string // Path to ANTEX antenna calibration file

	// Processing mode
	ProcessingMode string // "static" or "kinematic"

	// Ambiguity resolution settings
	AREnabled          bool    // Enable ambiguity resolution
	ARMinRatio         float64 // Ratio test threshold (default: 3.0)
	ARMinSatellites    int     // Minimum satellites required for AR (default: 5)
	ARValidationMethod string  // "ratio", "w-test", or "combined"

	// Troposphere estimation
	EstimateTroposphere bool   // Enable troposphere estimation
	TroposphereModel    string // "VMF1", "VMF3", or "Saastamoinen"
	EstimateGradients   bool   // Estimate troposphere gradients (North/East)

	// Process noise parameters (for Kalman filter)
	ProcessNoisePosition    float64 // m²/s - for kinematic mode
	ProcessNoiseClock       float64 // m²/s - receiver clock random walk
	ProcessNoiseTroposphere float64 // m²/s - troposphere ZWD random walk
	ProcessNoiseAmbiguity   float64 // cycles²/s - float ambiguity process noise (typically 0)

	// Measurement weighting
	CodeSigma  float64 // Code measurement std dev (meters), default: 1.0
	PhaseSigma float64 // Phase measurement std dev (meters), default: 0.01
}

PPPARConfig extends ProcessingConfig with PPP-AR specific settings

func NewDefaultPPPARConfig

func NewDefaultPPPARConfig() PPPARConfig

NewDefaultPPPARConfig returns a PPPARConfig with sensible defaults

func NewPPPARConfig

func NewPPPARConfig(initialPosition coordinates.Vector3D) PPPARConfig

NewPPPARConfig creates a PPPARConfig with the given initial position

type PPPARPipelineBuilder

type PPPARPipelineBuilder struct {
	// contains filtered or unexported fields
}

PPPARPipelineBuilder constructs PPP-AR processing pipelines

func NewPPPARPipelineBuilder

func NewPPPARPipelineBuilder(config PPPARConfig, store *ephemeris.EphemerisStore) *PPPARPipelineBuilder

NewPPPARPipelineBuilder creates a new PPP-AR pipeline builder

func (*PPPARPipelineBuilder) Build

Build constructs a complete PPP-AR processing pipeline

func (*PPPARPipelineBuilder) BuildFloatOnly

func (b *PPPARPipelineBuilder) BuildFloatOnly() (*pipeline.Pipeline, error)

BuildFloatOnly builds a PPP pipeline without ambiguity resolution

func (*PPPARPipelineBuilder) BuildWithAR

func (b *PPPARPipelineBuilder) BuildWithAR() (*pipeline.Pipeline, error)

BuildWithAR builds a PPP-AR pipeline with ambiguity resolution enabled

func (*PPPARPipelineBuilder) GetConfig

func (b *PPPARPipelineBuilder) GetConfig() PPPARConfig

GetConfig returns the current configuration

func (*PPPARPipelineBuilder) SetConfig

func (b *PPPARPipelineBuilder) SetConfig(config PPPARConfig)

SetConfig updates the configuration

type PipelineBuilder

type PipelineBuilder struct {
	// contains filtered or unexported fields
}

PipelineBuilder constructs processing pipelines based on configuration. This implements the builder pattern for creating configurable pipelines.

func NewPipelineBuilder

func NewPipelineBuilder(config ProcessingConfig, store *ephemeris.EphemerisStore) *PipelineBuilder

NewPipelineBuilder creates a new pipeline builder with the given configuration.

func (*PipelineBuilder) Build

func (b *PipelineBuilder) Build() (*pipeline.Pipeline, error)

Build constructs a complete processing pipeline based on the configuration. The pipeline is built in a specific order to ensure dependencies are met: 0. System filter (if systems are specified) 1. Ephemeris and position (required for all other processors) 2. Geometry (required for corrections and combinations) 3. Corrections (atmospheric, relativistic) 4. Linear combinations 5. Quality checks (elevation mask, etc.)

func (*PipelineBuilder) GetConfig

func (b *PipelineBuilder) GetConfig() ProcessingConfig

GetConfig returns the current configuration.

func (*PipelineBuilder) SetConfig

func (b *PipelineBuilder) SetConfig(config ProcessingConfig)

SetConfig updates the configuration. This allows dynamic reconfiguration of the builder.

func (*PipelineBuilder) Validate

func (b *PipelineBuilder) Validate() error

Validate checks if the configuration is valid.

type ProcessingConfig

type ProcessingConfig struct {
	// Receiver position in ECEF coordinates (meters)
	ReceiverPosition coordinates.Vector3D

	// Systems to process (e.g., GPS, GALILEO, GLONASS)
	Systems []gnss.System

	// Elevation masks per system (degrees)
	ElevationMasks map[gnss.System]float64

	// Model selections
	Models ModelConfig

	// Correction toggles
	Corrections CorrectionConfig

	// Linear combination toggles
	Combinations CombinationConfig

	// Signal type priority configuration for signal selection
	SignalTypePriorities SignalTypePriorityConfig

	// Processing mode
	Mode ProcessingMode
}

ProcessingConfig defines the configuration for GNSS processing pipelines. This replaces and extends the existing config.Config with more flexibility.

func DefaultConfig

func DefaultConfig() ProcessingConfig

DefaultConfig returns a reasonable default configuration.

func DefaultPPPConfig

func DefaultPPPConfig() ProcessingConfig

DefaultPPPConfig returns a configuration suitable for PPP processing.

func DefaultTDCPConfig

func DefaultTDCPConfig() ProcessingConfig

DefaultTDCPConfig returns a configuration suitable for TDCP velocity processing.

func DefaultTDCPProcessingConfig added in v0.34.0

func DefaultTDCPProcessingConfig() ProcessingConfig

DefaultTDCPProcessingConfig returns a ProcessingConfig suitable for TDCP. This enables the necessary combinations and corrections.

type ProcessingMode

type ProcessingMode string

ProcessingMode defines the type of positioning solution.

const (
	ModeSPP  ProcessingMode = "spp"  // Single Point Positioning
	ModeTDCP ProcessingMode = "tdcp" // Time-Differenced Carrier Phase (velocity)
	ModePPP  ProcessingMode = "ppp"  // Precise Point Positioning
	ModeRTK  ProcessingMode = "rtk"  // Real-Time Kinematic
)

type SignalTypePriorityConfig added in v0.33.0

type SignalTypePriorityConfig struct {
	// Default signal type priorities (applied when constellation-specific not found)
	// Lower number = higher priority
	DefaultPriorities map[observation.SignalType]int

	// Constellation-specific signal type priorities (per GNSS system)
	// Key: gnss.System (GPS, GALILEO, GLONASS, etc.), Value: SignalType -> priority mapping
	ConstellationPriorities map[gnss.System]map[observation.SignalType]int
}

SignalTypePriorityConfig defines signal type priorities for signal selection. Lower priority numbers indicate higher preference. If a constellation-specific priority is not found, falls back to default priorities.

Example usage:

config := ProcessingConfig{
  SignalTypePriorities: SignalTypePriorityConfig{
    DefaultPriorities: map[observation.SignalType]int{
      observation.C: 1, observation.W: 2, observation.P: 3,
      observation.L: 4, observation.I: 5, observation.Q: 6,
    },
    ConstellationPriorities: map[gnss.System]map[observation.SignalType]int{
      gnss.GPS: {
        observation.C: 1, observation.W: 2, observation.P: 3,  // GPS signal type priorities
      },
      gnss.GALILEO: {
        observation.C: 1, observation.X: 2, observation.I: 3,  // Galileo signal type priorities
      },
      gnss.GLONASS: {
        observation.C: 1, observation.P: 2,  // GLONASS signal type priorities
      },
    },
  },
}

func (*SignalTypePriorityConfig) GetSignalTypePriorities added in v0.33.0

func (c *SignalTypePriorityConfig) GetSignalTypePriorities(system gnss.System, satelliteID observation.SatelliteID) map[observation.SignalType]int

GetSignalTypePriorities implements the processors.CodePriorityProvider interface. Returns the signal type priority map for the given constellation/system, or nil if not configured.

type TDCPPipelineBuilder added in v0.34.0

type TDCPPipelineBuilder struct {
	// contains filtered or unexported fields
}

TDCPPipelineBuilder constructs processing pipelines for TDCP velocity estimation. It builds on top of the standard pipeline builder and adds TDCP-specific processors.

func NewTDCPPipelineBuilder added in v0.34.0

func NewTDCPPipelineBuilder(
	config ProcessingConfig,
	tdcpConfig velocity.TDCPConfig,
	store *ephemeris.EphemerisStore,
) (*TDCPPipelineBuilder, error)

NewTDCPPipelineBuilder creates a new TDCP pipeline builder.

Parameters:

  • config: Base processing configuration (ephemeris, corrections, etc.)
  • tdcpConfig: TDCP-specific configuration (solver type, combination, etc.)
  • store: Ephemeris data store

Returns a builder that can construct complete TDCP processing pipelines.

func (*TDCPPipelineBuilder) Build added in v0.34.0

Build constructs a complete TDCP processing pipeline.

Returns:

  • pipeline: The per-satellite processing pipeline (includes TDCP observable processor)
  • observableProc: Reference to the TDCP observable processor (for epoch updates)
  • solverProc: The TDCP solver processor (called separately after pipeline)
  • ephemerisProc: Reference to the TDCP ephemeris processor (for reference time updates)
  • error: Any errors encountered during pipeline construction

Usage:

pipe, obsProc, solverProc, ephProc, err := builder.Build()
if err != nil {
    return err
}

// Process all satellites through pipeline
epochProc := pipeline.NewEpochProcessor(pipe, true)
states, err := epochProc.Process(ctx, epoch)

// Aggregate velocity solution
velocity, err := solverProc.ProcessEpoch(ctx, states, epoch.Time)

// Update epoch buffer and ephemeris reference time for next iteration
obsProc.UpdateEpoch(states, epoch.Time)
ephProc.UpdateReferenceTime(epoch.Time)

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL