Skip to content

StaticEOPProvider

Built-in Earth Orientation Parameters for testing and offline use.

StaticEOPProvider 

StaticEOPProvider()

Static Earth Orientation Parameter provider with constant values.

Provides EOP data using fixed values that don't change with time. Useful for testing or scenarios where time-varying EOP data is not needed.

Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import brahe as bh

# Create static EOP provider with default values
eop = bh.StaticEOPProvider()

# Create static EOP provider with zero values
eop_zero = bh.StaticEOPProvider.from_zero()

# Create with custom values
eop_custom = bh.StaticEOPProvider.from_values(0.1, 0.0, 0.0, 0.0, 0.0, 0.0)

# Set as global provider
bh.set_global_eop_provider_from_static_provider(eop_custom)

Initialize instance.

eop_type method descriptor 

eop_type() -> str

Get the EOP data type.

Returns:

Name Type Description
str str

EOP type string
Example 
1
2
3
4
import brahe as bh

eop = bh.StaticEOPProvider.from_zero()
print(f"EOP type: {eop.eop_type()}")

extrapolation method descriptor 

extrapolation() -> str

Get the extrapolation method.

Returns:

Name Type Description
str str

Extrapolation method string
Example 
1
2
3
4
import brahe as bh

eop = bh.StaticEOPProvider.from_zero()
print(f"Extrapolation method: {eop.extrapolation()}")

from_values builtin 

from_values(ut1_utc: float, pm_x: float, pm_y: float, dx: float, dy: float, lod: float) -> StaticEOPProvider

Create a static EOP provider with specified values.

Parameters:

Name Type Description Default
ut1_utc float

UT1-UTC time difference in seconds

 required
pm_x float

Polar motion x-component in radians

 required
pm_y float

Polar motion y-component in radians

 required
dx float

Celestial pole offset dx in radians

 required
dy float

Celestial pole offset dy in radians

 required
lod float

Length of day offset in seconds

 required

Returns:

Name Type Description
StaticEOPProvider StaticEOPProvider

Provider with specified EOP values
Example 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
import brahe as bh

# Create EOP provider with custom values
eop = bh.StaticEOPProvider.from_values(
    ut1_utc=0.1,
    pm_x=1e-6,
    pm_y=2e-6,
    dx=1e-7,
    dy=1e-7,
    lod=0.001
)
bh.set_global_eop_provider_from_static_provider(eop)

from_zero builtin 

from_zero() -> StaticEOPProvider

Create a static EOP provider with all values set to zero.

Returns:

Name Type Description
StaticEOPProvider StaticEOPProvider

Provider with all EOP values set to zero
Example 
1
2
3
4
5
import brahe as bh

# Create EOP provider with all zeros (no corrections)
eop = bh.StaticEOPProvider.from_zero()
bh.set_global_eop_provider_from_static_provider(eop)

get_dxdy method descriptor 

get_dxdy(mjd: float) -> tuple[float, float]

Get celestial pole offsets for a given MJD.

Parameters:

Name Type Description Default
mjd float

Modified Julian Date

 required

Returns:

Type Description
tuple[float, float]

tuple[float, float]: Celestial pole offsets dx and dy in radians
Example 
1
2
3
4
5
import brahe as bh

eop = bh.StaticEOPProvider.from_zero()
dx, dy = eop.get_dxdy(58849.0)
print(f"Celestial pole offsets: dx={dx} rad, dy={dy} rad")

get_eop method descriptor 

get_eop(mjd: float) -> tuple[float, float, float, float, float, float]

Get all EOP parameters for a given MJD.

Parameters:

Name Type Description Default
mjd float

Modified Julian Date

 required

Returns:

Type Description
tuple[float, float, float, float, float, float]

tuple[float, float, float, float, float, float]: UT1-UTC, pm_x, pm_y, dx, dy, lod
Example 
1
2
3
4
5
import brahe as bh

eop = bh.StaticEOPProvider()
ut1_utc, pm_x, pm_y, dx, dy, lod = eop.get_eop(58849.0)
print(f"EOP: UT1-UTC={ut1_utc}s, PM=({pm_x},{pm_y})rad")

get_lod method descriptor 

get_lod(mjd: float) -> float

Get length of day offset for a given MJD.

Parameters:

Name Type Description Default
mjd float

Modified Julian Date

 required

Returns:

Name Type Description
float float

Length of day offset in seconds
Example 
1
2
3
4
5
import brahe as bh

eop = bh.StaticEOPProvider.from_zero()
lod = eop.get_lod(58849.0)
print(f"Length of day offset: {lod} seconds")

get_pm method descriptor 

get_pm(mjd: float) -> tuple[float, float]

Get polar motion components for a given MJD.

Parameters:

Name Type Description Default
mjd float

Modified Julian Date

 required

Returns:

Type Description
tuple[float, float]

tuple[float, float]: Polar motion x and y components in radians
Example 
1
2
3
4
5
import brahe as bh

eop = bh.StaticEOPProvider.from_zero()
pm_x, pm_y = eop.get_pm(58849.0)
print(f"Polar motion: x={pm_x} rad, y={pm_y} rad")

get_ut1_utc method descriptor 

get_ut1_utc(mjd: float) -> float

Get UT1-UTC time difference for a given MJD.

Parameters:

Name Type Description Default
mjd float

Modified Julian Date

 required

Returns:

Name Type Description
float float

UT1-UTC time difference in seconds
Example 
1
2
3
4
5
import brahe as bh

eop = bh.StaticEOPProvider.from_zero()
ut1_utc = eop.get_ut1_utc(58849.0)
print(f"UT1-UTC: {ut1_utc} seconds")

interpolation method descriptor 

interpolation() -> bool

Check if interpolation is enabled.

Returns:

Name Type Description
bool bool

True if interpolation is enabled
Example 
1
2
3
4
import brahe as bh

eop = bh.StaticEOPProvider.from_zero()
print(f"Interpolation enabled: {eop.interpolation()}")

is_initialized method descriptor 

is_initialized() -> bool

Check if the provider is initialized.

Returns:

Name Type Description
bool bool

True if initialized
Example 
1
2
3
4
import brahe as bh

eop = bh.StaticEOPProvider.from_zero()
print(f"Is initialized: {eop.is_initialized()}")

len method descriptor 

len() -> int

Get the number of EOP data points.

Returns:

Name Type Description
int int

Number of EOP data points
Example 
1
2
3
4
import brahe as bh

eop = bh.StaticEOPProvider.from_zero()
print(f"EOP data points: {eop.len()}")

mjd_last_dxdy method descriptor 

mjd_last_dxdy() -> float

Get the last Modified Julian Date with dx/dy data.

Returns:

Name Type Description
float float

Last MJD with dx/dy data
Example 
1
2
3
4
import brahe as bh

eop = bh.StaticEOPProvider.from_zero()
print(f"Last MJD with dx/dy: {eop.mjd_last_dxdy()}")

mjd_last_lod method descriptor 

mjd_last_lod() -> float

Get the last Modified Julian Date with LOD data.

Returns:

Name Type Description
float float

Last MJD with LOD data
Example 
1
2
3
4
import brahe as bh

eop = bh.StaticEOPProvider.from_zero()
print(f"Last MJD with LOD: {eop.mjd_last_lod()}")

mjd_max method descriptor 

mjd_max() -> float

Get the maximum Modified Julian Date in the dataset.

Returns:

Name Type Description
float float

Maximum MJD
Example 
1
2
3
4
import brahe as bh

eop = bh.StaticEOPProvider.from_zero()
print(f"Maximum MJD: {eop.mjd_max()}")

mjd_min method descriptor 

mjd_min() -> float

Get the minimum Modified Julian Date in the dataset.

Returns:

Name Type Description
float float

Minimum MJD
Example 
1
2
3
4
import brahe as bh

eop = bh.StaticEOPProvider.from_zero()
print(f"Minimum MJD: {eop.mjd_min()}")

Overview

StaticEOPProvider provides built-in historical EOP data that doesn't require external files. Useful for testing, examples, or when internet access is unavailable.

Module: brahe.eop

Use Cases: - Unit testing - Examples and tutorials - Offline applications - Quick prototyping

Limitations: - Fixed historical data (not updated) - Less accurate than file-based providers - Not suitable for production applications requiring current data

Creating a Provider

Zero Values

1
2
3
4
5
6
7
import brahe as bh

# All EOP values set to zero
provider = bh.StaticEOPProvider.from_zero()

# Set as global provider
bh.set_global_eop_provider(provider)

Custom Values

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
import brahe as bh

# Specify custom EOP values
provider = bh.StaticEOPProvider.from_values(
    ut1_utc=0.1,      # UT1-UTC offset (seconds)
    pm_x=0.0001,      # Polar motion X (radians)
    pm_y=0.0001,      # Polar motion Y (radians)
    dx=0.00001,       # Celestial pole offset dX (radians)
    dy=0.00001,       # Celestial pole offset dY (radians)
    lod=0.001         # Length of day offset (seconds)
)

Default Values

1
2
3
4
import brahe as bh

# Use built-in default values
provider = bh.StaticEOPProvider()

Usage Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import brahe as bh

# Set up static EOP for testing
bh.set_global_eop_provider(
    bh.StaticEOPProvider.from_zero()
)

# Perform frame transformations
epoch = bh.Epoch.from_datetime(2024, 1, 1, 0, 0, 0.0, 0.0, bh.TimeSystem.UTC)

# ECI to ECEF transformation
pos_eci = [7000000.0, 0.0, 0.0]  # meters in ECI
pos_ecef = bh.position_eci_to_ecef(epoch, pos_eci)

# ECEF to ECI transformation
vel_ecef = [0.0, 7500.0, 0.0]  # m/s in ECEF
vel_eci = bh.position_ecef_to_eci(epoch, vel_ecef)

When to Use

✅ Use StaticEOPProvider for: - Unit tests - Documentation examples - Learning and prototyping - Applications where high accuracy isn't critical

❌ Don't use StaticEOPProvider for: - Production orbit determination - Precise tracking applications - Applications requiring current EOP data - High-accuracy simulations

See Also