Struct BallisticForces 

pub struct BallisticForces { /* private fields */ }

Gravity and aerodynamic drag delegated to ballistics-engine’s force kernel.

Implementations

impl BallisticForces

pub fn new( diameter_m: f64, cd_vs_mach: Vec<(f64, f64)>, atmosphere: Atmosphere, wind_mps: Vec3, ) -> Result<Self>

Build using the vehicle’s actual Cd curve, not a G-model reference curve or BC. At least two ascending, nonnegative Mach values and positive Cd values are required. Wind is a world-frame air velocity vector (positive X is a tailwind).

pub fn with_drag_scale(self, scale: f64) -> Result<Self>

Apply a positive multiplier to the entire Cd curve. Default is 1.0.

pub fn set_wind(&mut self, wind_mps: Vec3) -> Result<()>

Change uniform world-frame wind between public integration steps.

pub fn with_spin( self, twist_rate_in: f64, body_length_m: f64, right_hand: bool, ) -> Result<Self>

Modified point-mass spin: enable the kernel’s Magnus force and yaw of repose for a spinning body. twist_rate_in is the effective twist in inches per turn — rifling language upstream; for a fin-canted rocket it is the roll rate the cant produces per unit velocity. body_length_m is the full airframe length (the stability correlations need it; Self::new only knows the diameter). right_hand selects the roll direction.

The correlations are McCoy bullet shapes, so treat magnitudes as approximate for blunt or finned bodies; signs and scaling are physical.

pub fn with_coriolis( self, latitude_deg: f64, shot_azimuth_deg: f64, ) -> Result<Self>

Modified point-mass Coriolis deflection, for planet-scale arcs. latitude_deg is the launch latitude in [-90, 90]; shot_azimuth_deg is the compass bearing fired along, 0 = north, 90 = east. Do not combine with an inertial-frame crate::CentralGravity model: Coriolis is the rotating-frame term and would double-count Earth rotation.

pub fn with_tipoff_yaw( self, yaw_rad: f64, decay_distance_m: f64, ) -> Result<Self>

Launch tip-off: an initial yaw in radians that decays exponentially with downrange distance over decay_distance_m. Models the rail/launcher disturbance; it perturbs the effective angle of attack early in flight.

pub fn with_body_lift( self, cna_vs_mach: Vec<(f64, f64)>, induced_k_vs_mach: Vec<(f64, f64)>, ) -> Result<Self>

Angle-of-attack aerodynamics without attitude integration: a quasi-static normal force and induced drag from the commanded axis’s angle to the relative wind.

cna_vs_mach is the normal-force coefficient slope per radian of angle of attack (body + fins) versus Mach; induced_k_vs_mach adds Cd += k·α². Both need at least two strictly ascending Mach points and nonnegative, finite values. The angle of attack is measured each RK stage between the solver-resolved thrust axis and the wind-relative velocity, so a guided turn at angle of attack both turns harder (body lift) and pays drag for it. Reference area derives from the diameter passed to Self::new.

pub fn set_twist(&mut self, twist_rate_in: f64) -> Result<()>

Change the effective twist between public steps, for a caller-integrated roll model (see crate::RollDynamics). Pair with Self::with_spin for the body length and handedness; the rate must stay positive.

pub fn with_atmosphere_zones( self, zones: Vec<(f64, f64, f64, f64)>, ) -> Result<Self>

Downrange-segmented atmosphere (upstream AtmoSock): station-referenced zones, each (temperature_c, pressure_hpa, humidity_percent, until_downrange_m). The zone is selected by downrange distance position.x; the base atmosphere must be Atmosphere::Standard, and each zone’s humidity applies to its station density while this derivative path uses dry-air sound speed.

pub fn with_wind_segments( self, zones: Vec<(f64, f64, f64, f64)>, ) -> Result<Self>

Downrange-segmented wind (upstream WindSock). Each zone is (speed_mps, angle_deg, until_downrange_m, vertical_mps), with the angle following the upstream wind-FROM convention (0° = headwind, 90° = from the right). Vertical is positive updraft. Zones are evaluated statelessly at each stage’s position.x, so wind can change mid-integration. Overrides the uniform wind set in Self::new/Self::set_wind.

pub fn with_turbulence( self, sigma_mps: f64, tau_s: f64, seed: u64, ) -> Result<Self>

Add deterministic frozen-field turbulence: multisine gusts with a pink spectrum, RMS sigma_mps per axis and energy concentrated near the period tau_s. seed fixes the phases (dispersion reseeds per run), so runs are exactly reproducible.

pub fn with_wind_field( self, field: Arc<dyn WindField + Send + Sync>, ) -> Result<Self>

Sample an arbitrary winds-engine field instead of the uniform vector or zone ladder. Shared as an Arc so the weathercock and the recovery descent can sample the same air. Stateless and deterministic, so integration stays reproducible.

pub fn acceleration_with_axis_in_wind( &self, state: &FlightState, mass_kg: f64, wind_mps: Vec3, body_axis: Vec3, ) -> Result<Vec3>

Axis-aware counterpart to Self::acceleration_in_wind, for wrappers that sample their own wind but want the body-lift increment.

pub fn acceleration_in_wind( &self, state: &FlightState, mass_kg: f64, wind_mps: Vec3, ) -> Result<Vec3>

Evaluate using externally sampled wind, for a spatial or time-varying force wrapper.

Trait Implementations

impl Clone for BallisticForces

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BallisticForces

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

Formats the value using the given formatter.

impl ForceModel for BallisticForces

fn acceleration(&self, state: &FlightState, mass_kg: f64) -> Result<Vec3>

Acceleration in world-frame metres per second squared.

fn acceleration_with_axis( &self, state: &FlightState, mass_kg: f64, body_axis: Vec3, ) -> Result<Vec3>

Acceleration when the commanded body axis is known, for angle-of-attack-aware models (body lift, induced drag). body_axis is the solver-resolved unit thrust axis at this stage. The default ignores the axis, which keeps every orientation-blind model (gravity, plain drag) bit-identical.