Struct GravParam 

pub struct GravParam<P>
where
    P: Planet,
{
    pub value: f64,
    /* private fields */
}

Gravitational parameter μ = GM tagged with the source planet P.

GravParam<Earth> and GravParam<Sun> are distinct types so the compiler refuses to silently feed μ_Sun into a function expecting μ_Earth. The numeric value is stored in SI base units (m³/s²) and reachable via GravParam::value (also a public field for the kernel-level call sites that already do mu.value).

Construction

Mission code constructs a GravParam<P> through the inferred-planet factory f64::m3_per_s2() (planet <P> inferred from the expected-type context at the call site — see crate::ext::F64Ext::m3_per_s2 for the full story; a bare let mu = 1.0.m3_per_s2(); with no expected-type context fails to compile), the explicit-planet factory f64::m3_per_s2_for::<P>(), or one of the curated mu_*() constants in astrodyn::recipes::constants. Calling a typed consumer with a SelfPlanet-tagged μ in a planet-pinned slot is rejected at compile time, so a planet-erased μ only flows through SelfPlanet-typed surfaces (the registry-side boundary code, GravitySource, etc.).

use astrodyn_quantities::prelude::*;

// Planet-pinned construction (Earth):
let mu_earth: GravParam<Earth> = 3.986_004_415e14_f64.m3_per_s2_for::<Earth>();
// Type ascription supplies the inference context for `<P>`:
let mu_sun: GravParam<Sun> = 1.327_124_400_18e20_f64.m3_per_s2();
// The numeric SI value in m³/s² is reachable via `.value`:
assert!(mu_earth.value > 0.0);
assert!(mu_sun.value > 0.0);

Compile-fail: cross-planet construction is rejected

Building a planet-pinned GravParam<Earth> directly from a GravParam<Sun> is a type error — the compiler refuses the assignment.

use astrodyn_quantities::prelude::*;
let mu_sun: GravParam<Sun> = 1.327e20.m3_per_s2_for::<Sun>();
let _bad: GravParam<Earth> = mu_sun;   // planet phantom mismatch

A planet-erased GravParam<SelfPlanet> cannot be assigned to a planet-pinned slot either — SelfPlanet is not Earth:

use astrodyn_quantities::prelude::*;
let mu_any: GravParam<SelfPlanet> = 3.986e14.m3_per_s2();
let _bad: GravParam<Earth> = mu_any;   // SelfPlanet vs Earth mismatch

Compile-fail: there is no <P = SelfPlanet> default

GravParam<P> carries no default planet — every call site must commit to a planet via turbofish, type ascription, or argument inference. A bare GravParam::from_si(...) with no inference context is rejected. There is deliberately no <P = SelfPlanet> fallback: a default would silently relax to <SelfPlanet> whenever inference had no constraint, hiding missing planet-pinning decisions. The type system is meant to surface those at compile time, not satisfy them with a wildcard:

use astrodyn_quantities::prelude::*;
// No type context for `<P>`, no turbofish, no default — type
// annotations needed.
let _mu = GravParam::from_si(3.986_004_415e14);

The fix is to commit to a planet at the call site:

use astrodyn_quantities::prelude::*;
let _mu = GravParam::<Earth>::from_si(3.986_004_415e14);

Fields

value: f64

Numeric value in SI base units (m³/s²).

The field is public so internal physics kernels can read it via mu.value without going through an accessor — the typed planet phantom is the load-bearing part, not the wrapping ceremony.

Implementations

impl<P> GravParam<P>

where P: Planet,

pub const fn from_si(value: f64) -> GravParam<P>

Construct a GravParam<P> from its SI base value (m³/s²).

This is the witness-gated constructor: the planet phantom is fixed by the turbofish or by the surrounding type context. Mission code typically reaches this through crate::ext::F64Ext::m3_per_s2_for or the curated mu_*() constants rather than calling from_si directly.

pub const fn raw_si(&self) -> f64

Numeric value in SI base units (m³/s²).

impl GravParam<SelfPlanet>

pub fn relabel<Q>(self) -> GravParam<Q>

where Q: Planet,

Relabel a planet-erased (SelfPlanet) μ as belonging to a specific planet Q.

Restricted to impl GravParam<SelfPlanet> so it can only retag a μ that is already planet-erased — a planet-pinned GravParam<Sun> cannot accidentally be relabeled as GravParam<Earth> via this method. Provided only for the registry-side boundary code that stores μ values keyed by a runtime source ID — the gravity source registry, GravitySourceTyped, the dynamic mu carried on PlanetShape, and similar surfaces where the planet identity is determined at runtime. Mission code that knows the planet at compile time should construct a planet-tagged GravParam<Q> directly via m3_per_s2_for::<Q>() or one of the mu_*() constants.

A genuine <P> → <Q> retag for two distinct named planets is almost never the right operation (μ is per-body); if you need it for a different reason, add a separate, clearly-named escape hatch instead of widening this impl block.

Trait Implementations

impl<P> Clone for GravParam<P>

where P: Planet,

fn clone(&self) -> GravParam<P>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P> Debug for GravParam<P>

where P: Planet,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<P> Default for GravParam<P>

where P: Planet,

fn default() -> GravParam<P>

Returns the “default value” for a type.

impl<P> IntoGravParam<P> for GravParam<P>

where P: Planet,

fn into_grav_param(self) -> GravParam<P>

Lift self into a typed GravParam<P> (m³/s²).

impl<P> PartialEq for GravParam<P>

where P: Planet,

fn eq(&self, other: &GravParam<P>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P> Copy for GravParam<P>

where P: Planet,