jupiters 0.0.3

use jupiters::physics::collisions::{Impactor, asteroidimpactor, cometimpact};
use jupiters::physics::orbit::{
    ARGUMENTPERIHELIONDEG, ECCENTRICITY, INCLINATIONDEG, JupiterOrbit, LONGITUDEASCENDINGNODEDEG,
    SEMIMAJORAXIS,
};
use jupiters::physics::rotation::{
    AXIALTILTDEG, AXIALTILTRAD, JupiterRotation, PRECESSIONPERIODYEARS, SIDEREALDAYS,
};
use jupiters::physics::tides::{
    TidalForce, iotosolartideratio, neaptideamplitude, springtideamplitude,
};

#[test]
fn orbitalperiodabout4333days() {
    let orbit = JupiterOrbit::new();
    let days = orbit.orbitalperioddays();
    assert!((days - 4332.59).abs() < 10.0);
}

#[test]
fn perihelioncloserthanaphelion() {
    let orbit = JupiterOrbit::new();
    assert!(orbit.perihelionm() < orbit.aphelionm());
}

#[test]
fn velocityhigheratperihelion() {
    let orbit = JupiterOrbit::new();
    let vperi = orbit.velocityatdistance(orbit.perihelionm());
    let vaph = orbit.velocityatdistance(orbit.aphelionm());
    assert!(vperi > vaph);
}

#[test]
fn orbitalenergynegativebound() {
    let orbit = JupiterOrbit::new();
    let e = orbit.specific_orbital_energy();
    assert!(e < 0.0);
}

#[test]
fn angularmomentumpositive() {
    let orbit = JupiterOrbit::new();
    let l = orbit.specific_angular_momentum();
    assert!(l > 0.0);
}

#[test]
fn escapevelocityabout60kms() {
    let vesc = JupiterOrbit::escape_velocity_at_surface();
    let vkms = vesc / 1000.0;
    assert!((vkms - 59.5).abs() < 2.0);
}

#[test]
fn gravitationalforcesunpositive() {
    let orbit = JupiterOrbit::new();
    let f = orbit.gravitational_force_sun();
    assert!(f > 4e23);
}

#[test]
fn currentradiusatzeroanomaly() {
    let orbit = JupiterOrbit::new();
    let r = orbit.current_radius();
    let expected = orbit.perihelionm();
    assert!((r - expected).abs() / expected < 1e-10);
}

#[test]
fn meanorbitalvelocityabout13kms() {
    let orbit = JupiterOrbit::new();
    let v = orbit.mean_orbital_velocity() / 1000.0;
    assert!((v - 13.1).abs() < 1.0);
}

#[test]
fn orbitalconstantsvalid() {
    const { assert!(SEMIMAJORAXIS > 7.7e11) };
    const { assert!(ECCENTRICITY > 0.0 && ECCENTRICITY < 0.1) };
    const { assert!(INCLINATIONDEG > 0.0 && INCLINATIONDEG < 5.0) };
    const { assert!(LONGITUDEASCENDINGNODEDEG > 0.0 && LONGITUDEASCENDINGNODEDEG < 360.0) };
    const { assert!(ARGUMENTPERIHELIONDEG > 0.0 && ARGUMENTPERIHELIONDEG < 360.0) };
}

#[test]
fn surfacevelocitymaxatequator() {
    let rot = JupiterRotation::new();
    let veq = rot.surfacevelocityatlatitude(0.0);
    let v45 = rot.surfacevelocityatlatitude(45.0);
    let v90 = rot.surfacevelocityatlatitude(90.0);
    assert!(veq > v45);
    assert!(v45 > v90);
    assert!(veq > 12000.0);
}

#[test]
fn centripetalaccelerationmaxatequator() {
    let rot = JupiterRotation::new();
    let aeq = rot.centripetalaccelerationatlatitude(0.0);
    let a45 = rot.centripetalaccelerationatlatitude(45.0);
    assert!(aeq > a45);
    assert!(aeq > 2.0);
}

#[test]
fn coriolisparameterzeroatequator() {
    let rot = JupiterRotation::new();
    let f = rot.coriolisparameter(0.0);
    assert!(f.abs() < 1e-10);
}

#[test]
fn momentofinertiacorrectorder() {
    let rot = JupiterRotation::new();
    let i = rot.momentofinertia();
    assert!(i > 1e42);
}

#[test]
fn rotationalkineticenergyhuge() {
    let rot = JupiterRotation::new();
    let ke = rot.rotationalkineticenergy();
    assert!(ke > 1e34);
}

#[test]
fn angularmomentumconservedsign() {
    let rot = JupiterRotation::new();
    let l = rot.angular_momentum();
    assert!(l > 0.0);
}

#[test]
fn precessionratesmall() {
    let rot = JupiterRotation::new();
    let rate = rot.precession_rate_rad_per_year();
    assert!(rate > 0.0);
    assert!(rate < 0.001);
}

#[test]
fn rotationconstantsvalid() {
    const { assert!(SIDEREALDAYS > 35000.0 && SIDEREALDAYS < 36000.0) };
    assert!((AXIALTILTDEG - 3.13).abs() < 0.1);
    assert!((AXIALTILTRAD - AXIALTILTDEG.to_radians()).abs() < 0.01);
    const { assert!(PRECESSIONPERIODYEARS > 400000.0) };
}

#[test]
fn iotidelargerthansolar() {
    let io = TidalForce::fromio();
    let sun = TidalForce::fromsun();
    assert!(io.tidalacceleration() > sun.tidalacceleration());
}

#[test]
fn iotosolartideratiolarger() {
    let ratio = iotosolartideratio();
    assert!(ratio > 1.0);
}

#[test]
fn springtidelargerthanneap() {
    let spring = springtideamplitude();
    let neap = neaptideamplitude();
    assert!(spring > neap);
    assert!(spring > 0.0);
    assert!(neap > 0.0);
}

#[test]
fn tidalpotentialvarieswithangle() {
    let io = TidalForce::fromio();
    let pot0 = io.tidalpotential(0.0);
    let pot90 = io.tidalpotential(std::f64::consts::FRAC_PI_2);
    assert!(pot0 != pot90);
}

#[test]
fn tidalbulgeheightpositive() {
    let io = TidalForce::fromio();
    let h = io.tidalbulgeheight();
    assert!(h > 0.0);
}

#[test]
fn gravitationalattractioniopositive() {
    let io = TidalForce::fromio();
    let f = io.gravitationalattraction();
    assert!(f > 0.0);
}

#[test]
fn cometimpacthighenergy() {
    let comet = cometimpact();
    let emt = comet.kineticenergymt();
    assert!(emt > 0.0);
}

#[test]
fn asteroidsmallerthancomet() {
    let ast = asteroidimpactor();
    let comet = cometimpact();
    assert!(comet.kineticenergyj() > ast.kineticenergyj());
}

#[test]
fn impactvelocityhigherthanapproach() {
    let imp = Impactor::asteroid(1000.0, 15.0);
    let vimpact = imp.impactvelocity();
    assert!(vimpact > imp.velocityms);
}

#[test]
fn craterdiameterincreaseswithimpactorsize() {
    let small = Impactor::asteroid(100.0, 20.0);
    let large = Impactor::asteroid(10000.0, 20.0);
    let csmall = small.craterdiameterm(1000.0);
    let clarge = large.craterdiameterm(1000.0);
    assert!(clarge > csmall);
}

#[test]
fn fireballradiuspositive() {
    let imp = Impactor::asteroid(1000.0, 20.0);
    let r = imp.fireballradiusm();
    assert!(r > 0.0);
}

#[test]
fn ejectavolumescaleswithcrater() {
    let small = Impactor::asteroid(100.0, 15.0);
    let large = Impactor::asteroid(5000.0, 15.0);
    let esmall = small.ejectavolumem3(1000.0);
    let elarge = large.ejectavolumem3(1000.0);
    assert!(elarge > esmall);
}