Orbital Track Calculation Test

// This is a proof-of-concept linear calculation of a single Lat/Lon point given an initial orbit and time
// altitude is currently also calculated since it is a simple calculation that derives from Lat/Lon calculations
<script>
    // craft icon, currently hard-coded to a probe
    var ship = L.icon({
        iconUrl: 'button_vessel_probe.png',
        iconSize: [16, 16],
    });

    // create the map with some custom options
    map = new L.KSP.Map('map', {
        layers: [L.KSP.CelestialBody.KERBIN],
        zoom: 1,
        center: [0,0],
        bodyControl: false,
        layersControl: false,
        scaleControl: true,
    });

    // let the user see the position of the cursor
    // leaflet.js was modified to remove the biome, slope and elevation data displays
    map.addControl(new L.KSP.Control.Info());

    // initial orbital data
    // degrees converted to radians - (angle / 180) * Math.PI
    var gmu = 3531.6;
    var sma = 1200.06110157543;
    var ecc = 0.00019551857301358601;
    var inc = 45.023889091763799 * .017453292519943295;
    var raan = 319.31870314879399 * .017453292519943295;
    var arg = 179.83990894581601 * .017453292519943295;
    var mean = 142.3534 * .017453292519943295;
    var eph = 38419302.517532699;
    var period = 4395.408;
    var UT = 39330000.0;

    //////////////////////
    // computeMeanMotion() <-- refers to function in KSPTOT code was expanded/extracted out of
    //////////////////////

    // movement since the eph of the initial orbit
    mean = mean +   Math.sqrt(gmu/Math.abs(sma)^3) * (UT - eph);

    ////////////////
    // solveKepler()
    ////////////////

    var EccA = -1;
    if (mean < 0 || mean > 2*Math.PI) {
        // expanded AngleZero2Pi() function
        // abs(mod(real(Angle),2*pi));
        // javascript has a modulo operator, not a function
        mean = Math.abs(mean % (2*Math.PI));
    }

    if (Math.abs(mean - 0) < 1E-8) {
        EccA = 0;
    } else if (Math.abs(mean - Math.PI) < 1E-8 ) {
        EccA = Math.PI;
    }

    /////////////
    // keplerEq()
    /////////////

    // since there is no function return to break ahead of this statement, test if variable was modified
    if (EccA = -1) {
        var En  = mean;
        var Ens = En - (En-ecc*Math.sin(En)- mean)/(1 - ecc*Math.cos(En));
        while ( Math.abs(Ens-En) > 1E-10 ) {
            En = Ens;
            Ens = En - (En - ecc*Math.sin(En) - mean)/(1 - ecc*Math.cos(En));
        }
        EccA = Ens;
    }

    ///////////////////////////////
    // computeTrueAnomFromEccAnom()
    ///////////////////////////////

    var upper = Math.sqrt(1+ecc) * Math.tan(EccA/2);
    var lower = Math.sqrt(1-ecc);

    // expanded AngleZero2Pi() function
    // abs(mod(real(Angle),2*pi));
    // javascript has a modulo operator, not a function
    var tru = Math.abs((Math.atan2(upper, lower) * 2) % (2*Math.PI));

    ///////////////////////////
    // getStatefromKepler_Alg()
    ///////////////////////////

    // Special Case: Circular Equitorial
    if(ecc < 1E-10 && (inc < 1E-10 || Math.abs(inc-Math.PI) < 1E-10)) {
        var l = raan + arg + tru;
        tru = l;
        raan = 0;
        arg = 0;
    }

    // Special Case: Circular Inclined
    if(ecc < 1E-10 && inc >= 1E-10 && Math.abs(inc-Math.PI) >= 1E-10) {
        var u = arg + tru;
        tru = u;
        arg = 0.0;
    }

    // Special Case: Elliptical Equitorial
    if(ecc >= 1E-10 && (inc < 1E-10 || Math.abs(inc-Math.PI) < 1E-10)) {
        raan = 0;
    }

    // vectors and matrices use the Slyvester library
    var p = sma*(1-ecc^2);
    var rPQW = $V([p*Math.cos(tru) / (1 + ecc*Math.cos(tru)),
                                 p*Math.sin(tru) / (1 + ecc*Math.cos(tru)),
                                 0]);

    var vPQW = $V([-Math.sqrt(gmu/p)*Math.sin(tru),
                                 Math.sqrt(gmu/p)*(ecc + Math.cos(tru)),
                                 0]);

    var TraansMatrix = $M([
        [Math.cos(raan)*Math.cos(arg)-Math.sin(raan)*Math.sin(arg)*Math.cos(inc), -Math.cos(raan)*Math.sin(arg)-Math.sin(raan)*Math.cos(arg)*Math.cos(inc), Math.sin(raan)*Math.sin(inc)],
        [Math.sin(raan)*Math.cos(arg)+Math.cos(raan)*Math.sin(arg)*Math.cos(inc), -Math.sin(raan)*Math.sin(arg)+Math.cos(raan)*Math.cos(arg)*Math.cos(inc), -Math.cos(raan)*Math.sin(inc)],
        [Math.sin(arg)*Math.sin(inc), Math.cos(arg)*Math.sin(inc), Math.cos(inc)]
    ]);

    var rVect = TraansMatrix.multiply(rPQW);
    var vVect = TraansMatrix.multiply(vPQW);

    /////////////////////
    // getBodySpinAngle()
    /////////////////////

    // hard-coded data for Kerbin
    var bodySpinRate = 2*Math.PI/21599.912014540;

    // converted to radians
    var rotInit = 90 * .017453292519943295;

    // expanded AngleZero2Pi() function
    // abs(mod(real(Angle),2*pi));
    // javascript has a modulo operator, not a function
    var angle = rotInit + bodySpinRate*UT;
    var spinAngle = Math.abs(angle % (2*Math.PI));

    //////////////////////////////////////
    // getFixedFrameVectFromInertialVect()
    //////////////////////////////////////

    var R = $M([
        [Math.cos(spinAngle), -Math.sin(spinAngle), 0],
        [Math.sin(spinAngle), Math.cos(spinAngle), 0],
        [0, 0, 1]
    ]);

    R = R.transpose();
    var rVectECEF = R.multiply(rVect);

    //////////////////////////////////
    // getLatLongAltFromInertialVect()
    //////////////////////////////////

    // 2-norm or Euclidean norm of vector
    var rNormECEF = Math.sqrt(rVectECEF.e(1) * rVectECEF.e(1) + rVectECEF.e(2) * rVectECEF.e(2) + rVectECEF.e(3) * rVectECEF.e(3));
    var rNormECI = Math.sqrt(rVect.e(1) * rVect.e(1) + rVect.e(2) * rVect.e(2) + rVect.e(3) * rVect.e(3));

    // convert to degrees from radians - angle / Math.PI * 180
    var lon = (Math.abs((Math.atan2(rVectECEF.e(2),rVectECEF.e(1))) % (2*Math.PI))) * 57.29577951308232;
    var lat = (Math.PI/2 - Math.acos(rVectECEF.e(3)/rNormECEF)) * 57.29577951308232;
    var alt = rNormECEF - 600;

    window.alert("UT: " + UT + "\ntru: " + tru * 57.29577951308232 + "\nlat: " + lat + "\nlon: " + lon + "\nalt: " + alt + "\nrNormECI: " + rNormECI + "\nrNormECEF: " + rNormECEF);

    // place the marker at the current Lat/Lon position for this UT
    L.marker([lat, lon], {icon: ship, clickable: false}).addTo(map);
</script>