From 8457171bb19b9e3dd31f9f86e3c8b99f808f47c7 Mon Sep 17 00:00:00 2001 From: indy91 Date: Thu, 19 Sep 2024 20:38:33 +0200 Subject: [PATCH 1/5] Start of adding new TLI processor modes --- .../samples/ProjectApollo/src_launch/rtcc.cpp | 4 + .../samples/ProjectApollo/src_launch/rtcc.h | 4 +- .../src_rtccmfd/ApolloRTCCMFD.cpp | 9 +- .../src_rtccmfd/ApolloRTCCMFD_Display.cpp | 4 + .../ProjectApollo/src_rtccmfd/OrbMech.cpp | 26 + .../ProjectApollo/src_rtccmfd/OrbMech.h | 1 + .../src_rtccmfd/TLIProcessor.cpp | 801 +++++++++++++++++- .../ProjectApollo/src_rtccmfd/TLIProcessor.h | 106 ++- .../src_rtccmfd/TLTrajectoryComputers.cpp | 7 +- 9 files changed, 951 insertions(+), 11 deletions(-) diff --git a/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.cpp b/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.cpp index b672a6b2cf..e5c88919ec 100644 --- a/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.cpp @@ -6118,6 +6118,10 @@ void RTCC::TranslunarInjectionProcessor(EphemerisData sv, PLAWDTOutput WeightsTa medquant.WeightsTable = WeightsTable; medquant.h_ap = PZTLIPLN.h_ap*1852.0; medquant.GMT_TIG = GMTfromGET(PZTLIPLN.GET_TLI); + medquant.IPOA = PZTLIPLN.IsPacficWindow ? 1 : 2; + medquant.h_PC = 60.0*1852.0; //TBD + medquant.lat_PC = 0.0; //TBD + medquant.lng_node = PI; //TBD mccconst.delta = PZTLIPLN.DELTA; mccconst.sigma = PZTLIPLN.SIGMA; diff --git a/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.h b/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.h index 3dce69d8de..0b88f8e334 100644 --- a/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.h +++ b/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.h @@ -3772,10 +3772,12 @@ class RTCC { //INPUT //4 = E-type mission ellipse int Mode = 4; - //TLI ignition for mode 4 + //TLI ignition for mode 4, estimated TIG for mode 5 double GET_TLI = 0.0; //Apogee height for mode 4, nautical miles double h_ap = 5000.0; + //Launch window + bool IsPacficWindow = true; //CONSTANTS - THESE SHOULD BE SYSTEM PARAMETERS double DELTA = 0.0; diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.cpp index c65ca3c1bf..daf5859d4a 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.cpp @@ -7211,7 +7211,14 @@ void ApolloRTCCMFD::menuTLIProcessorCalc() void ApolloRTCCMFD::menuTLIProcessorMode() { - + if (GC->rtcc->PZTLIPLN.Mode == 4) + { + GC->rtcc->PZTLIPLN.Mode = 5; + } + else + { + GC->rtcc->PZTLIPLN.Mode = 4; + } } void ApolloRTCCMFD::menuTLIProcessorGET() diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD_Display.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD_Display.cpp index 6cc1dc2c33..17a22619f4 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD_Display.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD_Display.cpp @@ -7108,6 +7108,10 @@ bool ApolloRTCCMFD::Update(oapi::Sketchpad *skp) { skp->Text(1 * W / 16, 4 * H / 14, "Ellipse", 7); } + else if (GC->rtcc->PZTLIPLN.Mode == 5) + { + skp->Text(1 * W / 16, 4 * H / 14, "Non-Free Return", 7); + } else { skp->Text(1 * W / 16, 4 * H / 14, "TBD", 3); diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/OrbMech.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/OrbMech.cpp index 15bce39614..3ce5743982 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/OrbMech.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/OrbMech.cpp @@ -5408,6 +5408,32 @@ double EMXINGElevSlope(VECTOR3 R, VECTOR3 V, VECTOR3 R_S, int body) return (dotp(rho_dot, N) + dotp(rho_apo, N_dot))*length(rho); } +double LongitudeConversion(double lng, double T, double w_E, double lng_0, bool inertial_to_geographic) +{ + //For ECI to ECEF conversion + + //lng: inertial or ECEF longitude + //T: Current time + //w_E: Body rotation rate + //lng_0: hour angle at T = 0 + //inertial_to_geographic: conversion direction + + double K; + if (inertial_to_geographic) + { + K = -1.0; + } + else + { + K = 1.0; + } + + lng = lng + K*(lng_0 + w_E * T); + + normalizeAngle(lng, false); + return lng; +} + CELEMENTS KeplerToEquinoctial(CELEMENTS kep) { CELEMENTS aeq; diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/OrbMech.h b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/OrbMech.h index 44e446421b..38657d4e58 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/OrbMech.h +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/OrbMech.h @@ -395,6 +395,7 @@ namespace OrbMech { void EMXINGElev(VECTOR3 R, VECTOR3 R_S, VECTOR3 &N, VECTOR3 &rho, double &sinang); //RTCC EMXING support routine, calculates elevation slope function double EMXINGElevSlope(VECTOR3 R, VECTOR3 V, VECTOR3 R_S, int body); + double LongitudeConversion(double lng, double T, double w_E, double lng_0, bool inertial_to_geographic); //AEG CELEMENTS LyddaneMeanToOsculating(CELEMENTS arr, int body); diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.cpp index a271cc93e2..8ce173ad2d 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.cpp @@ -25,6 +25,653 @@ See http://nassp.sourceforge.net/license/ for more details. #include "rtcc.h" #include "TLIProcessor.h" +TLIFirstGuess::TLIFirstGuess(RTCC *r) : RTCCModule(r), +WE(0.262517142) +{ + +} + +void TLIFirstGuess::Calculate(const TLIFirstGuessInputs& in) +{ + inp = in; + + CIST(in.BHA + inp.Hour * WE); + if (CO1) return; + + double TOIDIS = -outp.T1; + UPDATE(TOIDIS); + outp.DEL = DEL; +} + +void TLIFirstGuess::CIST(double RAGBT) +{ + double ORBPER, B1, RNVBT, TOPCY, C4, W, RQDFT, A2M, PT1, CTIO, T1; + double AZ2M, B2M, C2, RA2, A2V, A3V, AZ2V, BETA, AFNTMH, CL, Z, ALFA, A4, AZ4, B4, RA4, CARC, WTT, WTTER; + double DUMCT, CTTPG, RTOPCY, DTOPCY, T4, T7, T8; + int NUMIT, IEX, IAI0, IOS, IOQ; + double BADA2M, DUM1, DUM2, PCARC, CCARC, TOLCOR; + + DUM1 = 0.0; + + WV = sqrt(19.9094165 / pow(inp.R1 / 3443.93359, 3)); + ORBPER = PI2 / WV; + //Angle from ascending node to longitude of launch along on the earth's equator, in radians + B1 = atan2(sin(inp.C1) * sin(inp.AZ1), cos(inp.AZ1)); + //Argument of the input parking orbit state vector past its ascending node on the earth's equator, in radians + A1 = atan2(sin(inp.C1), cos(inp.C1) * cos(inp.AZ1)); + //Calculate inclination of the earth parking orbit to the earth's equator, in radians + FIV = abs(atan(sin(inp.C1) / (cos(inp.C1) * sin(B1)))); + //Ascending node of the VOP for insertion at base time + RNVBT = RAGBT + inp.FLO1 - B1; + RNVBT = HELP(RNVBT); + + if (inp.debug) + { + + } + + TOPCY = ORBPER * (inp.ORBNUM - 1.0) + 40.0; + CO1 = 0; + PERCYN(TOPCY); + if (CO1) return; + + FIVTL = 0; + C4 = 0; + R4 = inp.R1 + 12; + W = ENERGY(inp.IPERT, C4); + RQDFT = FLYTYM(inp.IPERT); + + A2M = A6 + 1.33 / DEG; + A2M = HELP(A2M); + PT1 = 0; + NUMIT = 0; + IEX = 0; + IAI0 = 1; + IOS = 1; + + do + { + NUMIT = NUMIT + 1; + GEOARG(FIM, A2M, RNM, AZ2M, B2M, C2, RA2); + + if (abs(C2) >= FIV) + { + //Inaccessible node logic + if (IEX == 0) + { + IEX = 1; + } + C2 = FIV * OrbMech::sign(C2); + BADA2M = A2M; + IOQ = 1; + //fprintf("INACCESSIBLE NODE ON MOP CALLED FOR.\n"); + if (IEX == 3) + { + //fprintf("NECESSARY NODE ON MOP IS INACCESSIBLE. NO CONVERGENCE.\n"); + return; + } + else if (IEX == 1) + { + if (C2 < 0) + { + IOQ = 2; + } + + IEX = 2; + //fprintf("NODE PLACED AT BEGINNING OF INACESSIBLE REGION ON MOP.\n"); + } + else + { + if (C2 > 0) + { + IOQ = 2; + } + IEX = 3; + //fprintf("NODE PLACED AT END OF INACESSIBLE REGION ON MOP.\n"); + } + + GEOLAT(FIM, C2, DUM1, IOQ, A2M, B2M, AZ2M, DUM2); + GEOARG(FIM, A2M, RNM, AZ2M, B2M, DUM1, RA2); + double TCOR = A2M - BADA2M; + TCOR = HELP(TCOR); + TOPCY = TOPCY + TCOR / WM; + PERCYN(TOPCY); + FIVTL = AZ2M - PI05; + RQDFT = FLYTYM(inp.IPERT); + W = ENERGY(inp.IPERT, C2); + } + + GEOLAT(FIV, C2, RA2, inp.IPOA, A2V, A3V, AZ2V, RNV); + FIVTL = AZ2M - AZ2V; + + SUBB(inp.IPERT, BETA, AFNTMH); + CL = SUBCL(inp.IPERT); + TLIMP(W); + + Z = atan(sin(BETA) * cos(FIVTL) / cos(BETA)); + ALFA = pow(cos(BETA) / (cos(Z) * cos(CL)), 2) - 1.0; + if (ALFA < 0) + { + ALFA = 0; + } + ALFA = atan(sqrt(ALFA)) + Z; + A4 = A2V + ALFA; + A4 = HELP(A4); + GEOARG(FIV, A4, RNV, AZ4, B4, C4, RA4); + + CARC = A4 - A1 - APS; + CARC = HELP(CARC); + if (CARC < 0 && inp.ORBNUM != 0.0) + { + CARC = CARC + PI2; + } + if (NUMIT == 1) + { + PCARC = CARC; + } + + if (abs(CARC - PCARC) >= PI) + { + //Orbit coast time excursion logic + if (IAI0 == 1) + { + IAI0 = 2; + CCARC = CARC; + //fprintf("ORBIT COAST ARC EXCURSION. ARC WILL BE CONSTRAINED TO WITHIN PI OF NEXT VALUE.\n"); + } + else + { + double SDAIO = 1.0; + if (CARC > CCARC) + { + SDAIO = -1.0; + } + CARC = CARC + SDAIO * PI2; + } + } + PCARC = CARC; + if (inp.ORBNUM != 0.0) + { + CTIO = ORBPER * (CARC / (PI2)+inp.ORBNUM - 1.0); + } + else + { + CTIO = ORBPER * (CARC / (PI2)); + } + T1 = RNV - RNVBT; + T1 = HELP(T1); + T1 = T1 / WE; + if (NUMIT == 1) + { + PT1 = T1; + } + + if (abs(T1 - PT1) >= 12.0) + { + //Time of orbit state vector excursion logic + if (IOS == 1) + { + IOS = 2; + TOLCOR = PI2 / WE * OrbMech::sign(T1); + //fprintf("CHANGE IN INSERTION TIME EXCEEDS 12 HOURS. SIGN WILL BE CONSTRAINED TO THAT OF NEXT VALUE.\n"); + } + else + { + T1 = T1 + TOLCOR; + } + } + + PT1 = T1; + DUMCT = APS / WV; + CTTPG = CTIO + DUMCT; + RTOPCY = T1 + CTIO + DUMCT + RQDFT; + DTOPCY = RTOPCY - TOPCY; + + T8 = T1 + CTIO; + T4 = T8 + DUMCT; + T7 = T4 + FTOCO; + + if (abs(DTOPCY) >= inp.TOL && NUMIT < inp.MAXIT) + { + TOPCY = RTOPCY; + PERCYN(TOPCY); + if (CO1) return; + W = ENERGY(inp.IPERT, C4); + RQDFT = FLYTYM(inp.IPERT); + A2M = A6 - BETA; + A2M = HELP(A2M); + } + + } while (abs(DTOPCY) >= inp.TOL && NUMIT < inp.MAXIT); + + double A3, AZ3, B3, C3, RA3, S; + + A3 = A2V + AFNTMH; + A3 = HELP(A3); + GEOARG(FIV, A3, RNV, AZ3, B3, C3, RA3); + S = A4 - A3; + S = HELP(S); + MH.x = cos(C3) * cos(RA3); + MH.y = cos(C3) * sin(RA3); + MH.z = sin(C3); + + WTT = W * 2.0; + WTTER = WTT * pow(3600.0 / (6076.11549 * 3443.93359), 2); + + outp.T1 = T1; + outp.CTIO = CTIO; + outp.C3 = WTTER; + outp.S = S; + outp.TOPCY = TOPCY; +} + +void TLIFirstGuess::UPDATE(double TOIDIS) +{ + VECTOR3 VEC1, UMH, HV, POV, DUM; + double PSI, DOT, HOMSQ, HOM, DISRNV, AZ1, B1, C1, RA1, ARC; + + PSI = WM * TOIDIS * ((WV - WE * cos(FIV)) / (WV - WM * cos(FIVTL))); + DOT = dotp(MH, HM); + HOMSQ = dotp(HM, HM); + HOM = sqrt(HOMSQ); + VEC1 = crossp(HM, MH); + + UMH = HM * DOT / HOMSQ + VEC1 * sin(PSI) / HOM + crossp(VEC1, HM) * cos(PSI) / HOMSQ; + + DISRNV = RNV + WE * TOIDIS; + HV = _V(sin(FIV) * sin(DISRNV), -sin(FIV) * cos(DISRNV), cos(FIV)); + + DUM = crossp(HV, UMH); + DEL = ANGLE(HV, UMH, DUM); + DEL = PI05 - DEL; + + GEOARG(FIV, A1, DISRNV, AZ1, B1, C1, RA1); + POV = _V(cos(C1) * cos(RA1), cos(C1) * sin(RA1), sin(C1)); + ARC = ANGLE(POV, DUM, HV); + ARC = ARC - PI05; + ARC = HELP(ARC); +} + +void TLIFirstGuess::GetOutput(TLIFirstGuessOutputs& out) +{ + out = outp; +} + +void TLIFirstGuess::TLIMP(double W) +{ + double U, UE, FKMPNM, FPKM, RORB, C3, CDIF, ETA, DV; + double VPGSQ, VPG, HSQ, H, P, A, E, B, R7, G7D, COEF; + + U = 0.23167004e13; + //Gravitational constant of the earth, in km^3/sec^2 + UE = 398603.2; + //Conversion factor km/NM + FKMPNM = 1.852; + //Conversion factor, ft/km + FPKM = 3280.8399; + //Radius of circular earth parking orbit, in kilometers + RORB = inp.R1 * FKMPNM; + //Trajectory energy, in (km/sec)^2 + C3 = 2.0 * W / (FPKM * FPKM); + //Difference between the energies of the circular parking orbit and the trajectory, in (km/sec)^2 + CDIF = UE / RORB + C3; + //Empirical equations + //True anomaly of TLI cutoff, in radians + ETA = atan((2.1397405 - RORB / 5750.0) * (1.0143460 / inp.TTW - 0.02) / (260.73592 / CDIF + 1.6338479)); + //Angle from beginning of coplanar TLI to perigee, in radians (equals alpha plus sigma) + APS = atan((2.4185082 - RORB / 4620.0) * (1.0365969 / inp.TTW - 0.051020408) / (254.80898 / CDIF + 2.1846192)); + //Perigee radius + R4 = inp.R1 + (-0.15664127 * pow(CDIF, 3) + 34.56894 * pow(CDIF, 2) - 253.71417 * CDIF) / (RORB * pow(inp.TTW, 2) * FKMPNM); + //Characteristic velocity of coplanar TLI maneuver, in ft/sec + DV = (sqrt(CDIF + UE / RORB) - sqrt(UE / RORB) + (pow(CDIF - 11.61, 2) * (2.7022098 - RORB / 3850.0) * (2.0264543e-6 / inp.TTW + 3.632748e-8)) / inp.TTW) * FPKM; + + VPGSQ = 2.0 * (W + U / R4); + VPG = sqrt(VPGSQ); + HSQ = pow(R4, 2) * VPGSQ; + H = R4 * VPG; + P = HSQ / U; + A = -U / (2.0 * W); + E = 1.0 - R4 / A; + B = sqrt(abs(A * P)); + R7 = P / (1.0 + E * cos(ETA)); + G7D = atan(E * R7 / P * sin(ETA)) * DEG; + COEF = 6076.11549 / 3600.0 * A / H; + //Flight time on trajectory of TLI cutoff past perigee, in hours + FTOCO = COEF * (2.0 * B * atan(R4 / B * tan(ETA / 2.0)) - E * R7 * sin(ETA)); +} + +double TLIFirstGuess::SUBCL(int IPERT) const +{ + double SECL, OBCL, CL; + + if (IPERT <= 1) + { + SECL = 0; + } + else + { + SECL = (0.11 - 8e-7 * EMR) * sin(2.0 * SMOPL + 0.611) - 0.01; + } + if (IPERT == 0 || IPERT == 2) + { + OBCL = 0; + } + else + { + OBCL = 1.6457056e-2 * sin(2.0 * AM + 0.166); + } + CL = 6.3814106 - (1.1030239e-5) * EMR + (5.3567533e-3) * EMRDOT + 6950.0 / (inp.RPC + 652.0) + 0.0114 * abs(inp.YPC) + 0.01892 * inp.YPC * FIVTL - cos(FIVTL) * (0.055 * inp.XPC - 1.35) - + pow(0.2457 - 4.5e-7 * EMR, 2) * (888.88889 + 1.0 / (5.0625 * inp.XPC / (9.828e5 - 1.8 * EMR) - 0.001125)) + 0.055 * inp.XPC + SECL + OBCL; + CL = CL / DEG; + return CL; +} + +void TLIFirstGuess::SUBB(int IPERT, double& BETA, double& AFNTMH) const +{ + double XC, YC, PLUS, YT, S, Z, COTH, SITH; + + XC = (1.93 - 0.037 * inp.XPC) / DEG; + YC = (-OrbMech::sign(FIVTL) * (0.6 - 0.02 * inp.XPC) - 0.035 * inp.YPC) / DEG; + if (IPERT == 0) + { + PLUS = 0; + } + else if (IPERT == 1) + { + PLUS = 0.0317 * cos(AM - 18.0 / DEG); + } + else + { + PLUS = (0.0285 + 0.0115 * cos(3.85 * DS)) * cos(AM - (10.0 + 5.0 * cos(3.85 * DS)) / DEG); + } + YT = (PLUS - inp.YPC * (0.015165 - 0.000201 * inp.XPC)) / DEG; + if (abs(YT) < abs(FIVTL)) + { + S = (-sin(YT - YC) - cos(FIVTL) * sin(YC)) / (sin(FIVTL) * cos(YC)); + Z = -OrbMech::sign(S) * atan(1 / sqrt(1 / (S * S) - 1)); + } + else + { + YT = OrbMech::sign(YT) * abs(FIVTL); + S = -1.0; + if (FIVTL * YT < 0) + { + S = 1.0; + } + Z = -OrbMech::sign(S) * 90.0 / DEG; + //fprintf("WARNING, TANGENCY SUEFACE PROBLEM. YT REDEFINED AS SIGN(ABS(FIVTL),YT)\n"); + } + BETA = Z - XC; + COTH = sin(FIVTL) * cos(Z); + SITH = sqrt(1.0 - COTH * COTH); + AFNTMH = Z / cos(FIVTL) + (YC - YT) / (SITH / COTH); +} + +void TLIFirstGuess::GEOLAT(double FI, double C, double RA, int I, double& A, double& B, double& AZ, double& RN) const +{ + if (C == FI) + { + A = PI05; + B = PI05; + AZ = PI05; + } + else if (C == -FI) + { + A = -PI05; + B = -PI05; + AZ = PI05; + } + else if (C == 0.0) + { + if (I == 1) + { + A = 0; + B = 0; + AZ = PI05 - FI; + } + else + { + A = PI; + B = PI; + AZ = PI05 + FI; + } + } + else + { + double CSCA = sin(FI) / sin(C); + A = atan(1 / sqrt(CSCA * CSCA - 1.0)); + if (I == 2) + { + A = PI - A; + } + if (C < 0) + { + A = -A; + } + B = atan2(sin(A) * cos(FI), cos(A)); + AZ = atan2(cos(FI), sin(FI) * cos(A)); + } + + RN = RA - B; + RN = HELP(RN); +} + +void TLIFirstGuess::GEOARG(double FI, double A, double RN, double &AZ, double &B, double &C, double &RA) const +{ + if (FI == 0.0) + { + AZ = PI05; + B = A; + C = 0; + } + else if (FI == PI) + { + AZ = -PI05; + B = -A; + C = 0; + } + else if (FI == PI05) + { + if (abs(A) < PI05) + { + AZ = 0; + B = 0; + C = A; + } + else if (A >= PI05) + { + AZ = PI; + B = PI; + C = PI - A; + } + else + { + AZ = PI; + B = PI; + C = -A - PI; + } + } + else if (A == PI05) + { + AZ = PI05; + B = PI05; + C = FI; + } + else if (A == -PI05) + { + AZ = PI05; + B = -PI05; + C = -FI; + } + else if (A == 0.0) + { + AZ = PI05 - FI; + B = 0; + C = 0; + } + else if (A == PI) + { + AZ = PI05 + FI; + B = PI; + C = 0; + } + else + { + AZ = atan2(cos(FI), sin(FI) * cos(A)); + B = atan2(sin(A) * cos(FI), cos(A)); + C = atan(sin(FI) * sin(B) / cos(FI)); + } + RA = RN + B; + RA = HELP(RA); +} + +double TLIFirstGuess::ENERGY(int IPERT, double C4) const +{ + double SEW, EOBW, PHI, FI, XGN, YGN, COA, A, COB, B, F, W; + + //SEW = Effect of solar gravitation + if (IPERT <= 1) + { + SEW = 0; + } + else + { + SEW = 3.9e4 * sin(2.0 * SMOPL - 1.657) - 1.3e4; + } + + //EOBW = Effect of Earth oblateness + if (IPERT == 0 || IPERT == 2) + { + EOBW = 0; + } + else + { + EOBW = (5.97 - 2.67 * cos(C4)) * cos(2.55 * C4) * 1e5; + } + PHI = (30.0 + inp.XPC * 2.0 / 3.0) / DEG; + PHI = sin(PHI) / cos(PHI); + FI = 1.0 / (EMR - 29000.0); + XGN = -68.0 + EMR / 10000.0 + 0.625 * inp.XPC; + YGN = -sin(FIVTL) * (9.6 - 0.16 * (XGN + 48.0)) / DEG; + XGN = XGN / DEG; + COA = cos(XGN) * cos(YGN); + A = atan(sqrt(1 / (COA * COA) - 1.0)); + COB = sin(YGN) * sin(inp.YPC / DEG) + cos(YGN) * cos(inp.YPC / DEG) * cos(inp.XPC / DEG - XGN); + B = atan(sqrt(1 / (COB * COB) - 1)); + F = (B - A) * DEG; + W = -2714728.4 - 1.4002127e12 * FI + EMRDOT * (3070.6244 + FI * 2.1470226e6 + EMRDOT * 1.1495569) + 750.0 * R4 + (1.0 - cos(FIVTL)) * (2.2 * EMR - 6.8e4) + + F * (-75150.0 - 0.05 * EMR - 8.75 * EMRDOT) - (4050.0 + 364500.0 / (F - 90.0)) * (2.25 * EMRDOT - 0.01 * EMR + 7070.0) + + (8.6016e6) * (PHI*PHI) * (1.0 / ((inp.RPC - 1015.0) / (2217.025 * PHI) + 1.0) - 1.0) + SEW + EOBW; + return W; +} + +double TLIFirstGuess::FLYTYM(int IPERT) const +{ + double SGFT, XGN, YGN, COA, A, COB, B, F, RQDFT; + + if (IPERT <= 1) + { + SGFT = 0; + } + else + { + SGFT = 2e-7 * EMR + cos(0.1745 - 2.0 * SMOPL) * (EMR * 9.6e-7 - EMRDOT * 7.5e-5 - 0.01554) - 0.028; + } + XGN = -68.0 + EMR / 10000.0 + 0.625 * inp.XPC; + YGN = -sin(FIVTL) * (9.6 - 0.16 * (XGN + 48)) / DEG; + XGN = XGN / DEG; + COA = cos(XGN) * cos(YGN); + A = atan(sqrt(1 / (COA * COA) - 1)); + COB = sin(YGN) * sin(inp.YPC / DEG) + cos(YGN) * cos(inp.YPC / DEG) * cos(inp.XPC / DEG - XGN); + B = atan(sqrt(1 / (COB * COB) - 1)); + F = (B - A) * DEG; + RQDFT = (-23.480035 + EMR * 4.455251e-4 - EMRDOT * (EMR * 1.6723713e-7 - 1.5007662e-2) + (cos(FIVTL) - 1.0) * (EMR * 2.4e-5 - 3.96) - + pow(0.012 - 3.3e-6 * EMR + 5e-4 * EMRDOT, 2) * (425.53191 + 1.0 / (F * 2.209e-5 / (0.048 - EMR * 1.32e-5 + EMRDOT * 0.002) + - 0.00235)) + SGFT) * pow(inp.RPC / 1015, 0.17); + return RQDFT; +} + +void TLIFirstGuess::PERCYN(double T) +{ + VECTOR3 RM, VM, RS, SCHM, IV; + double RAM, RA6, DECM, C6, XHM, YHM, ZHM, B6, AZ6; + double RAS, AS, SMOPD; + + const double C = 3443.93358; + + bool IERR = pRTCC->PLEFEM(1, T + inp.Hour, 0, &RM, &VM, &RS, NULL); + if (IERR) + { + CO1 = 2; + return; + } + //Convert from m and m/s to Er and Er/hr + RM /= 6378165.0; + VM /= 6378165.0 / 3600.0; + RS /= 6378165.0; + + EMR = length(RM) * C; + EMRDOT = dotp(RM, VM) / length(RM) * C; + + RAM = atan2(RM.y, RM.x); + RA6 = RAM + PI; + RA6 = HELP(RA6); + DECM = atan2(RM.z, sqrt(RM.x * RM.x + RM.y * RM.y)); + C6 = -DECM; + HM = crossp(RM, VM); + XHM = HM.x; + YHM = HM.y; + ZHM = HM.z; + WM = length(HM) / (pow(length(RM), 2)); + FIM = atan(sqrt(XHM * XHM + YHM * YHM) / ZHM); + RNM = atan2(XHM, -YHM); + B6 = RA6 - RNM; + B6 = HELP(B6); + A6 = atan2(sin(B6), cos(B6) * cos(FIM)); + AM = A6 + PI; + AM = HELP(AM); + AZ6 = atan2(abs(sin(B6)), cos(B6) * abs(sin(C6))); + RAS = atan2(RS.y, RS.x); + DS = atan2(RS.z, sqrt(RS.x * RS.x + RS.y * RS.y)); + AS = atan(sqrt(pow(length(RS), 2) / (RS.x * RS.x) - 1.0)); + if (RS.x < 0) AS = PI - AS; + if (RS.z < 0) AS = -AS; + SCHM = crossp(RS, HM); + IV = crossp(RM, SCHM); + SMOPL = atan2(length(IV), dotp(RM, SCHM)); + if (dotp(IV, HM) < 0) + { + SMOPL = -SMOPL; + } + SMOPL += PI05; + SMOPL = HELP(SMOPL); + SMOPD = PI05 - atan2(length(SCHM), dotp(RS, HM)); +} + +double TLIFirstGuess::HELP(double X) const +{ + while (X > PI) X -= PI2; + while (X <= -PI)X += PI2; + return X; +} + +double TLIFirstGuess::ANGLE(VECTOR3 VEC1, VECTOR3 VEC2, VECTOR3 VEC3) const +{ + VECTOR3 H; + double DUM, XR, H4; + + H = crossp(VEC1, VEC2); + H4 = length(H); + DUM = dotp(VEC1, VEC2); + XR = atan2(H4, DUM); + DUM = dotp(H, VEC3); + if (DUM < 0) + { + XR = -XR; + } + return XR; +} + TLIProcessor::TLIProcessor(RTCC *r) : TLTrajectoryComputers(r) { @@ -41,9 +688,17 @@ void TLIProcessor::Main(TLIOutputData &out) { ErrorIndicator = 0; - if (MEDQuantities.Mode == 4) + switch (MEDQuantities.Mode) { - Option1(); + case 4: + Option4(); + break; + case 5: + Option5(); + break; + default: + out.ErrorIndicator = 1; + return; } out.ErrorIndicator = ErrorIndicator; @@ -85,7 +740,7 @@ void TLIProcessor::Main(TLIOutputData &out) out.dv_TLI = outarray.dv_TLI; } -void TLIProcessor::Option1() +void TLIProcessor::Option4() { //Propagate state to TIG EMSMISSInputTable in; @@ -134,6 +789,73 @@ void TLIProcessor::Option1() } } +void TLIProcessor::Option5() +{ + //Initial guess + TLIFirstGuessInputs fgin; + TLIFirstGuessOutputs fgout; + TLIFirstGuess cist(pRTCC); + + //Step 1: propagate state to estimated TIG + EMSMISSInputTable in; + + in.AnchorVector = MEDQuantities.state; + in.MaxIntegTime = MEDQuantities.GMT_TIG - MEDQuantities.state.GMT; + if (in.MaxIntegTime < 0) + { + in.MaxIntegTime = abs(in.MaxIntegTime); + in.IsForwardIntegration = false; + } + in.VehicleCode = RTCC_MPT_CSM; + in.useInputWeights = true; + in.WeightsTable = &MEDQuantities.WeightsTable; + + pRTCC->EMSMISS(&in); + + if (in.NIAuxOutputTable.ErrorCode) + { + ErrorIndicator = 1; + return; + } + + outarray.sv0 = in.NIAuxOutputTable.sv_cutoff; + outarray.M_i = in.NIAuxOutputTable.CutoffWeight; + + double rmag, vmag, rtasc, decl, fpav, az; + OrbMech::rv_from_adbar(outarray.sv0.R, outarray.sv0.V, rmag, vmag, rtasc, decl, fpav, az); + + //Step 2: First guess logic + fgin.BHA = pRTCC->SystemParameters.MCLAMD; + fgin.Hour = outarray.sv0.GMT / 3600.0; + fgin.C1 = decl; + fgin.FLO1 = OrbMech::LongitudeConversion(rtasc, outarray.sv0.GMT, OrbMech::w_Earth, pRTCC->SystemParameters.MCLAMD, true); + fgin.AZ1 = az; + fgin.R1 = rmag / 1852.0; + fgin.ORBNUM = 0.0; + fgin.IPOA = MEDQuantities.IPOA; + fgin.IPERT = 3; + fgin.XPC = 0.0; + fgin.YPC = 0.0; + fgin.RPC = (OrbMech::R_Moon + MEDQuantities.h_PC) / 1852.0; + + cist.Calculate(fgin); + int err = cist.GetError(); + if (err) + { + return; + } + cist.GetOutput(fgout); + + + //Step 3: Converge trajectory + err = IntegratedTLIToNode(fgout.C3, fgout.CTIO, fgout.DEL, false); + if (err) + { + ErrorIndicator = 2; + return; + } +} + bool TLIProcessor::ConicTLIIEllipse(double C3_guess, double h_ap) { void *constPtr; @@ -201,6 +923,79 @@ bool TLIProcessor::IntegratedTLIIEllipse(double C3_guess_ER, double h_ap) return GenIterator::GeneralizedIterator(fptr, block, constPtr, (void*)this, result, y_vals); } +bool TLIProcessor::IntegratedTLIToNode(double C3_guess_ER, double T_c_hrs, double delta, bool free_return) +{ + void *constPtr; + outarray.TLIIndicator = true; + outarray.EllipticalCaseIndicator = false; + outarray.sigma_TLI = MissionConstants.sigma; + + if (free_return) + { + outarray.NodeStopIndicator = false; + } + else + { + outarray.NodeStopIndicator = true; + outarray.GMT_nd = 0.0; //TBD + } + + constPtr = &outarray; + + bool IntegratedTrajectoryComputerPointer(void *data, std::vector &var, void *varPtr, std::vector& arr, bool mode); + bool(*fptr)(void *, std::vector&, void*, std::vector&, bool) = &IntegratedTrajectoryComputerPointer; + + GenIterator::GeneralizedIteratorBlock block; + + block.IndVarSwitch[4] = true; //C3 + block.IndVarSwitch[5] = true; //DT EPO + block.IndVarSwitch[6] = true; //TLI plane change + + block.IndVarGuess[4] = C3_guess_ER; + block.IndVarGuess[5] = T_c_hrs; + block.IndVarGuess[6] = delta; + + block.IndVarStep[4] = pow(2, -21); + block.IndVarStep[5] = pow(2, -22); + block.IndVarStep[6] = pow(2, -21); + + block.IndVarWeight[4] = 1.0; + block.IndVarWeight[5] = 1.0; + block.IndVarWeight[6] = 1.0; + + double R_nd; + R_nd = OrbMech::R_Moon + MEDQuantities.h_PC; + + if (free_return) + { + + } + else + { + block.DepVarSwitch[0] = true; + block.DepVarSwitch[1] = true; + block.DepVarSwitch[2] = true; + block.DepVarSwitch[3] = true; + block.DepVarLowerLimit[0] = (R_nd - 0.5*1852.0) / R_E; + block.DepVarLowerLimit[1] = MEDQuantities.lat_PC - 0.01*RAD; + block.DepVarLowerLimit[2] = MEDQuantities.lng_node - 0.01*RAD; + block.DepVarLowerLimit[3] = 90.0*RAD; + block.DepVarUpperLimit[0] = (R_nd + 0.5*1852.0) / R_E; + block.DepVarUpperLimit[1] = MEDQuantities.lat_PC + 0.01*RAD; + block.DepVarUpperLimit[2] = MEDQuantities.lng_node + 0.01*RAD; + block.DepVarUpperLimit[3] = 182.0*RAD; + block.DepVarWeight[3] = 64.0; + block.DepVarClass[0] = 1; + block.DepVarClass[1] = 1; + block.DepVarClass[2] = 1; + block.DepVarClass[3] = 2; + } + + std::vector result; + std::vector y_vals; + return GenIterator::GeneralizedIterator(fptr, block, constPtr, (void*)this, result, y_vals); +} + OELEMENTS TLIProcessor::LVTAR(OELEMENTS coe, double lng_PAD, double RAGL) const { //lng_PAD: longitude of the launch pad diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.h b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.h index 20d8f3d45d..3069bfc62b 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.h +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.h @@ -25,16 +25,111 @@ See http://nassp.sourceforge.net/license/ for more details. #include "TLTrajectoryComputers.h" +struct TLIFirstGuessInputs +{ + double BHA; //Hour angle at midnight, radians + double Hour; //Hour at which to start the search, hours + + double C1; //Declination of the input state vector, radians + double FLO1; //Geographic longitude of the input orbit state vector, radians + double AZ1; //Inertial azimuth of the input orbit state vector, radians + double R1; //Radius of the input orbit state vector, nautical miles + double ORBNUM; //Number of the inertial orbit revolution + int IPOA; //1 = Pacific window (AZ2V <= 90°), 2 = Atlantic window (AZ2V > 90°) + int IPERT; //0 = no perturbations, 1 = Earth oblateness, 2 = solar gravitation, 3 = both + double XPC; //Longitude of pericynthion of the simulated trajectory, measured in a moon-centered MOP coordinate system + //from the extension of the earth-moon axis on the back side of the moon, degrees + double YPC; //Declination of pericynthion of the simulated trajectory, in a moon-centered MOP coordinate system + double RPC; //Radius of pericynthion of the simulation trajectory, nautical miles + int MAXIT = 50; + double TOL = 0.001; + double TTW = 0.7; //Valid for 0.63 to 0.8 + bool debug = true; +}; + +struct TLIFirstGuessOutputs +{ + double T1; //Time of launch from base time + double CTIO; //Time in Earth orbit + double C3; //Energy of TLI + double S; //Angle sigma + double TOPCY; //Time of PC from base time + double DEL; //Latitude of the updated unit M TLI targeting vector relative to the dispersed orbit plane +}; + +class TLIFirstGuess : public RTCCModule +{ +public: + TLIFirstGuess(RTCC *r); + + void Calculate(const TLIFirstGuessInputs& in); + + void GetOutput(TLIFirstGuessOutputs& out); + int GetError() { return CO1; } +private: + void CIST(double RAGBT); + void UPDATE(double TOIDIS); + + void PERCYN(double T); + double ENERGY(int IPERT, double C4) const; + double FLYTYM(int IPERT) const; + void GEOLAT(double FI, double C, double RA, int I, double& A, double& B, double& AZ, double& RN) const; + void GEOARG(double FI, double A, double RN, double& AZ, double& B, double& C, double& RA) const; + void SUBB(int IPERT, double &BETA, double &AFNTMH) const; + double SUBCL(int IPERT) const; + void TLIMP(double W); + double HELP(double X) const; + double ANGLE(VECTOR3 VEC1, VECTOR3 VEC2, VECTOR3 VEC3) const; + + TLIFirstGuessInputs inp; + TLIFirstGuessOutputs outp; + + VECTOR3 MH; //Hypersurface + double WV; + double FIV; + double RNV; + double A1; + + double FIVTL; + double R4; + double APS; + double FTOCO; + + VECTOR3 HM; //Angular momentum vector of the Moon + double EMR; + double EMRDOT; + double SMOPL; + double A6; + double FIM; + double RNM; + double WM; + double AM; + double DS; + double DEL; //Latitude of the updated unit M TLI targeting vector relative to the dispersed orbit plane + + //Error indicator + int CO1; + + //Earth rotational rate + const double WE; +}; + struct TLIMEDQuantities { - //1 = S-IVB hypersurface solution, 2 = integrated free-return, 3 = hybrid ellipse, 4 = E-type mission ellipse + //1 = S-IVB hypersurface solution, 2 = integrated free-return, 3 = hybrid ellipse, 4 = E-type mission ellipse, 5 = non-free return int Mode; EphemerisData state; PLAWDTOutput WeightsTable; - //Mode1 + //Mode 4 double GMT_TIG; double h_ap; + + //Mode 5 + int IPOA; //1 = Pacific window (AZ2V <= 90°), 2 = Atlantic window (AZ2V > 90°) + double h_PC; //Pericynthion flyby altitude, meters + double lat_PC; //Latitude of pericynthion, or of node + double lng_node; //Longitude of node }; struct SevenParameterUpdate @@ -65,11 +160,14 @@ class TLIProcessor : public TLTrajectoryComputers void Main(TLIOutputData &out); void Init(TLIMEDQuantities med, TLMCCMissionConstants constants, double GMTBase); protected: - - void Option1(); + //Desired apogee + void Option4(); + //Non-free return + void Option5(); bool ConicTLIIEllipse(double C3_guess, double h_ap); bool IntegratedTLIIEllipse(double C3_guess_ER, double h_ap); + bool IntegratedTLIToNode(double C3_guess_ER, double T_c_hrs, double delta, bool free_return); OELEMENTS LVTAR(OELEMENTS coe, double lng_PAD, double RAGL) const; diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLTrajectoryComputers.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLTrajectoryComputers.cpp index 7ee910ddc6..87084162be 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLTrajectoryComputers.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLTrajectoryComputers.cpp @@ -571,8 +571,6 @@ bool TLTrajectoryComputers::IntegratedTrajectoryComputer(std::vector &va vars->dt_EPO = var[5] * 3600.0; vars->delta_TLI = var[6]; - dt_node = 0.0; //Not needed? - sv0 = vars->sv0; //Propagate to TLI ignition @@ -604,6 +602,11 @@ bool TLTrajectoryComputers::IntegratedTrajectoryComputer(std::vector &va arr[8] = (length(sv_ap.R) - R_E) / R_E; return false; } + + if (vars->NodeStopIndicator) + { + dt_node = vars->GMT_nd - vars->sv_tli_cut.GMT; + } } else { From 40d1980d1a3e9551f36eb2558546e2be9f9ffd07 Mon Sep 17 00:00:00 2001 From: indy91 Date: Sat, 21 Sep 2024 16:29:52 +0200 Subject: [PATCH 2/5] Add rest of the TLI processor modes --- .../samples/ProjectApollo/src_launch/rtcc.cpp | 20 +- .../samples/ProjectApollo/src_launch/rtcc.h | 4 +- .../src_rtccmfd/ApolloRTCCMFD.cpp | 19 +- .../src_rtccmfd/ApolloRTCCMFD_Display.cpp | 102 +++++++- .../src_rtccmfd/ApollomfdButtons.cpp | 4 +- .../src_rtccmfd/TLIProcessor.cpp | 244 +++++++++++++++--- .../ProjectApollo/src_rtccmfd/TLIProcessor.h | 30 ++- .../src_rtccmfd/TLTrajectoryComputers.cpp | 17 +- .../src_rtccmfd/TLTrajectoryComputers.h | 5 +- 9 files changed, 367 insertions(+), 78 deletions(-) diff --git a/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.cpp b/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.cpp index e5c88919ec..4ba6ea0e9a 100644 --- a/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.cpp @@ -6117,11 +6117,24 @@ void RTCC::TranslunarInjectionProcessor(EphemerisData sv, PLAWDTOutput WeightsTa medquant.state = sv; medquant.WeightsTable = WeightsTable; medquant.h_ap = PZTLIPLN.h_ap*1852.0; + medquant.dv_available = PZTLIPLN.dv_available*0.3048; medquant.GMT_TIG = GMTfromGET(PZTLIPLN.GET_TLI); medquant.IPOA = PZTLIPLN.IsPacficWindow ? 1 : 2; - medquant.h_PC = 60.0*1852.0; //TBD - medquant.lat_PC = 0.0; //TBD - medquant.lng_node = PI; //TBD + + if (PZTLIPLN.Mode == 2) + { + //Free return + medquant.h_PC = PZSFPTAB.blocks[PZMCCPLN.SFPBlockNum - 1].h_pc1; + medquant.lat_PC = PZSFPTAB.blocks[PZMCCPLN.SFPBlockNum - 1].lat_pc1; + } + else if (PZTLIPLN.Mode == 5) + { + //Non-free return + medquant.h_PC = PZSFPTAB.blocks[PZMCCPLN.SFPBlockNum - 1].h_nd; + medquant.lat_PC = PZSFPTAB.blocks[PZMCCPLN.SFPBlockNum - 1].lat_nd; + medquant.lng_node = PZSFPTAB.blocks[PZMCCPLN.SFPBlockNum - 1].lng_nd; + medquant.GMT_node = PZSFPTAB.blocks[PZMCCPLN.SFPBlockNum - 1].GMT_nd; + } mccconst.delta = PZTLIPLN.DELTA; mccconst.sigma = PZTLIPLN.SIGMA; @@ -6140,6 +6153,7 @@ void RTCC::TranslunarInjectionProcessor(EphemerisData sv, PLAWDTOutput WeightsTa PZTPDDIS.GET_TIG = GETfromGMT(out.uplink_data.GMT_TIG); PZTPDDIS.GET_TB6 = PZTPDDIS.GET_TIG - SystemParameters.MDVSTP.DTIG; PZTPDDIS.dv_TLI = out.dv_TLI / 0.3048; + PZTPDDIS.T_b = out.sv_TLI_cut.GMT - out.sv_TLI_ign.GMT; } void RTCC::TranslunarMidcourseCorrectionProcessor(EphemerisData sv0, double CSMmass, double LMmass) diff --git a/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.h b/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.h index 0b88f8e334..294e3aea9f 100644 --- a/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.h +++ b/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.h @@ -3770,7 +3770,7 @@ class RTCC { struct TLIPlanningTable { //INPUT - //4 = E-type mission ellipse + //2 = free-return, 3 = hybrid ellipse, 4 = E-type mission ellipse, 5 = non-free return int Mode = 4; //TLI ignition for mode 4, estimated TIG for mode 5 double GET_TLI = 0.0; @@ -3778,6 +3778,8 @@ class RTCC { double h_ap = 5000.0; //Launch window bool IsPacficWindow = true; + //Available DV, for mode 3, feet per second + double dv_available = 5000.0; //CONSTANTS - THESE SHOULD BE SYSTEM PARAMETERS double DELTA = 0.0; diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.cpp index daf5859d4a..25d3874f9d 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.cpp @@ -7211,13 +7211,13 @@ void ApolloRTCCMFD::menuTLIProcessorCalc() void ApolloRTCCMFD::menuTLIProcessorMode() { - if (GC->rtcc->PZTLIPLN.Mode == 4) + if (GC->rtcc->PZTLIPLN.Mode < 5) { - GC->rtcc->PZTLIPLN.Mode = 5; + GC->rtcc->PZTLIPLN.Mode++; } else { - GC->rtcc->PZTLIPLN.Mode = 4; + GC->rtcc->PZTLIPLN.Mode = 2; } } @@ -7228,7 +7228,18 @@ void ApolloRTCCMFD::menuTLIProcessorGET() void ApolloRTCCMFD::menuTLIEllipseApogee() { - GenericDoubleInput(&GC->rtcc->PZTLIPLN.h_ap, "Input height of apogee (2700 to 7000 NM):"); + if (GC->rtcc->PZTLIPLN.Mode == 3) + { + GenericDoubleInput(&GC->rtcc->PZTLIPLN.dv_available, "Available Delta V for TLI (0 to 10000 ft/s):"); + } + else if (GC->rtcc->PZTLIPLN.Mode == 4) + { + GenericDoubleInput(&GC->rtcc->PZTLIPLN.h_ap, "Input height of apogee (2700 to 7000 NM):"); + } + else + { + GC->rtcc->PZTLIPLN.IsPacficWindow = !GC->rtcc->PZTLIPLN.IsPacficWindow; + } } void ApolloRTCCMFD::menuLunarLiftoffCalc() diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD_Display.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD_Display.cpp index 17a22619f4..16af9a6c1d 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD_Display.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD_Display.cpp @@ -7104,24 +7104,93 @@ bool ApolloRTCCMFD::Update(oapi::Sketchpad *skp) } skp->Text(1 * W / 16, 2 * H / 14, Buffer, strlen(Buffer)); - if (GC->rtcc->PZTLIPLN.Mode == 4) - { - skp->Text(1 * W / 16, 4 * H / 14, "Ellipse", 7); - } - else if (GC->rtcc->PZTLIPLN.Mode == 5) - { - skp->Text(1 * W / 16, 4 * H / 14, "Non-Free Return", 7); - } - else + switch (GC->rtcc->PZTLIPLN.Mode) { + case 2: + skp->Text(1 * W / 16, 4 * H / 14, "Free Return", 11); + break; + case 3: + skp->Text(1 * W / 16, 4 * H / 14, "Hybrid Ellipse", 14); + break; + case 4: + skp->Text(1 * W / 16, 4 * H / 14, "Specified Apogee", 16); + break; + case 5: + skp->Text(1 * W / 16, 4 * H / 14, "Non-Free Return", 15); + break; + default: skp->Text(1 * W / 16, 4 * H / 14, "TBD", 3); + break; } GET_Display(Buffer, GC->rtcc->PZTLIPLN.GET_TLI, false); skp->Text(1 * W / 16, 6 * H / 14, Buffer, strlen(Buffer)); - sprintf_s(Buffer, "%.0lf NM", GC->rtcc->PZTLIPLN.h_ap); - skp->Text(1 * W / 16, 8 * H / 14, Buffer, strlen(Buffer)); + if (GC->rtcc->PZTLIPLN.Mode == 3) + { + sprintf_s(Buffer, "%.0lf ft/s", GC->rtcc->PZTLIPLN.dv_available); + skp->Text(1 * W / 16, 8 * H / 14, Buffer, strlen(Buffer)); + } + else if (GC->rtcc->PZTLIPLN.Mode == 4) + { + sprintf_s(Buffer, "%.0lf NM", GC->rtcc->PZTLIPLN.h_ap); + skp->Text(1 * W / 16, 8 * H / 14, Buffer, strlen(Buffer)); + } + else + { + if (GC->rtcc->PZTLIPLN.IsPacficWindow) + { + skp->Text(1 * W / 16, 8 * H / 14, "Pacific Window", 14); + } + else + { + skp->Text(1 * W / 16, 8 * H / 14, "Atlantic Window", 15); + } + + if (GC->rtcc->PZMCCPLN.SFPBlockNum == 1) + { + sprintf(Buffer, "1 (Preflight)"); + } + else + { + sprintf(Buffer, "2 (Nominal Targets)"); + } + skp->Text(1 * W / 16, 10 * H / 14, Buffer, strlen(Buffer)); + + /* + if (GC->rtcc->PZTLIPLN.Mode == 2) + { + skp->Text(1 * W / 16, 11 * H / 14, "Pericynthion:", 13); + + sprintf_s(Buffer, "Lat %.3lf", GC->rtcc->PZSFPTAB.blocks[GC->rtcc->PZMCCPLN.SFPBlockNum - 1].lat_pc1 * DEG); + skp->Text(1 * W / 16, 24 * H / 28, Buffer, strlen(Buffer)); + + sprintf_s(Buffer, "Height %.3lf", GC->rtcc->PZSFPTAB.blocks[GC->rtcc->PZMCCPLN.SFPBlockNum - 1].h_pc1 / 1852.0); + skp->Text(1 * W / 16, 25 * H / 28, Buffer, strlen(Buffer)); + } + else + { + skp->Text(1 * W / 16, 11 * H / 14, "Node:", 5); + + GET_Display2(Buffer, GC->rtcc->PZSFPTAB.blocks[GC->rtcc->PZMCCPLN.SFPBlockNum - 1].GMT_nd); + skp->Text(1 * W / 16, 24 * H / 28, Buffer, strlen(Buffer)); + + sprintf_s(Buffer, "Lat %.3lf", GC->rtcc->PZSFPTAB.blocks[GC->rtcc->PZMCCPLN.SFPBlockNum - 1].lat_nd * DEG); + skp->Text(1 * W / 16, 25 * H / 28, Buffer, strlen(Buffer)); + + sprintf_s(Buffer, "Lng %.3lf", GC->rtcc->PZSFPTAB.blocks[GC->rtcc->PZMCCPLN.SFPBlockNum - 1].lng_nd * DEG); + skp->Text(1 * W / 16, 26 * H / 28, Buffer, strlen(Buffer)); + + sprintf_s(Buffer, "Height %.3lf", GC->rtcc->PZSFPTAB.blocks[GC->rtcc->PZMCCPLN.SFPBlockNum - 1].h_nd / 1852.0); + skp->Text(1 * W / 16, 27 * H / 28, Buffer, strlen(Buffer)); + + + GC->rtcc->PZSFPTAB.blocks[GC->rtcc->PZMCCPLN.SFPBlockNum - 1].GMT_nd; + GC->rtcc->PZSFPTAB.blocks[GC->rtcc->PZMCCPLN.SFPBlockNum - 1].lat_nd; + GC->rtcc->PZSFPTAB.blocks[GC->rtcc->PZMCCPLN.SFPBlockNum - 1].lng_nd; + GC->rtcc->PZSFPTAB.blocks[GC->rtcc->PZMCCPLN.SFPBlockNum - 1].h_nd; + }*/ + } skp->Text(9 * W / 16, 4 * H / 14, "GET RP", 6); skp->Text(9 * W / 16, 5 * H / 14, "GET TIG", 7); @@ -7132,6 +7201,7 @@ bool ApolloRTCCMFD::Update(oapi::Sketchpad *skp) skp->Text(9 * W / 16, 10 * H / 14, "ALPHA", 5); skp->Text(9 * W / 16, 11 * H / 14, "TA", 2); skp->Text(9 * W / 16, 12 * H / 14, "DV", 2); + skp->Text(9 * W / 16, 13 * H / 14, "BT", 2); if (GC->rtcc->PZTTLIPL.DataIndicator == 1) { @@ -7155,8 +7225,16 @@ bool ApolloRTCCMFD::Update(oapi::Sketchpad *skp) skp->Text(15 * W / 16, 11 * H / 14, Buffer, strlen(Buffer)); sprintf(Buffer, "%.1lf", GC->rtcc->PZTPDDIS.dv_TLI); skp->Text(15 * W / 16, 12 * H / 14, Buffer, strlen(Buffer)); + + double secs; + int hh, mm; + OrbMech::SStoHHMMSS(GC->rtcc->PZTPDDIS.T_b, hh, mm, secs); + sprintf(Buffer, "%d:%02.0f", mm, secs); + skp->Text(15 * W / 16, 13 * H / 14, Buffer, strlen(Buffer)); } + skp->SetTextAlign(oapi::Sketchpad::LEFT); + switch (G->iuUplinkResult) { case 1: @@ -7175,7 +7253,7 @@ bool ApolloRTCCMFD::Update(oapi::Sketchpad *skp) sprintf(Buffer, "No Uplink"); break; } - skp->Text(13 * W / 32, 30 * H / 32, Buffer, strlen(Buffer)); + skp->Text(5 * W / 32, 30 * H / 32, Buffer, strlen(Buffer)); } else if (screen == 80) { diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApollomfdButtons.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApollomfdButtons.cpp index b2c676ffec..2062b0e7ac 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApollomfdButtons.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApollomfdButtons.cpp @@ -2696,7 +2696,7 @@ ApolloRTCCMFDButtons::ApolloRTCCMFDButtons() { "Mode", 0, 'G' }, { "Time of ignition", 0, 'Q' }, { "Apogee height", 0, 'V' }, - { "", 0, ' ' }, + { "Cycle SFP table", 0, 'H' }, { "", 0, ' ' }, { "Calculate solution", 0, 'C' }, @@ -2713,7 +2713,7 @@ ApolloRTCCMFDButtons::ApolloRTCCMFDButtons() RegisterFunction("MOD", OAPI_KEY_G, &ApolloRTCCMFD::menuTLIProcessorMode); RegisterFunction("TIG", OAPI_KEY_Q, &ApolloRTCCMFD::menuTLIProcessorGET); RegisterFunction("APO", OAPI_KEY_V, &ApolloRTCCMFD::menuTLIEllipseApogee); - RegisterFunction("", OAPI_KEY_H, &ApolloRTCCMFD::menuVoid); + RegisterFunction("SFP", OAPI_KEY_H, &ApolloRTCCMFD::menuCycleTLCCCSFPBlockNumber); RegisterFunction("", OAPI_KEY_Q, &ApolloRTCCMFD::menuVoid); RegisterFunction("CLC", OAPI_KEY_C, &ApolloRTCCMFD::menuTLIProcessorCalc); diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.cpp index 8ce173ad2d..8f2395820c 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.cpp @@ -690,11 +690,17 @@ void TLIProcessor::Main(TLIOutputData &out) switch (MEDQuantities.Mode) { + case 2: + Option2_5(true); + break; + case 3: + Option3(); + break; case 4: Option4(); break; case 5: - Option5(); + Option2_5(false); break; default: out.ErrorIndicator = 1; @@ -705,11 +711,10 @@ void TLIProcessor::Main(TLIOutputData &out) if (out.ErrorIndicator) return; //Convert to LVDC parameters - if (MEDQuantities.Mode == 4) + if (MEDQuantities.Mode != 1) { //7 parameters - //Convert to ECT at GRR EphemerisData2 sv, sv_ECT; @@ -738,6 +743,50 @@ void TLIProcessor::Main(TLIOutputData &out) } out.dv_TLI = outarray.dv_TLI; + out.sv_TLI_ign = outarray.sv_tli_ign; + out.sv_TLI_cut = outarray.sv_tli_cut; +} + +//Hybrid ellipse +void TLIProcessor::Option3() +{ + //Propagate state to TIG + EMSMISSInputTable in; + + in.AnchorVector = MEDQuantities.state; + in.MaxIntegTime = MEDQuantities.GMT_TIG - MEDQuantities.state.GMT; + if (in.MaxIntegTime < 0) + { + in.MaxIntegTime = abs(in.MaxIntegTime); + in.IsForwardIntegration = false; + } + in.VehicleCode = RTCC_MPT_CSM; + in.useInputWeights = true; + in.WeightsTable = &MEDQuantities.WeightsTable; + + pRTCC->EMSMISS(&in); + + if (in.NIAuxOutputTable.ErrorCode) + { + ErrorIndicator = 1; + return; + } + + outarray.sv0 = in.NIAuxOutputTable.sv_cutoff; + outarray.M_i = in.NIAuxOutputTable.CutoffWeight; + + //Calculate initial guess for C3 + double C3_guess, R_I; + + R_I = length(outarray.sv0.R); + C3_guess = pow(MEDQuantities.dv_available, 2) - OrbMech::mu_Earth / R_I + 2.0*MEDQuantities.dv_available*sqrt(OrbMech::mu_Earth / R_I); + + bool err = HybridMission(C3_guess, MEDQuantities.dv_available); + if (err) + { + ErrorIndicator = 2; + return; + } } void TLIProcessor::Option4() @@ -789,7 +838,7 @@ void TLIProcessor::Option4() } } -void TLIProcessor::Option5() +void TLIProcessor::Option2_5(bool freereturn) { //Initial guess TLIFirstGuessInputs fgin; @@ -820,6 +869,7 @@ void TLIProcessor::Option5() outarray.sv0 = in.NIAuxOutputTable.sv_cutoff; outarray.M_i = in.NIAuxOutputTable.CutoffWeight; + outarray.rad_lls = OrbMech::R_Moon; double rmag, vmag, rtasc, decl, fpav, az; OrbMech::rv_from_adbar(outarray.sv0.R, outarray.sv0.V, rmag, vmag, rtasc, decl, fpav, az); @@ -846,14 +896,79 @@ void TLIProcessor::Option5() } cist.GetOutput(fgout); - //Step 3: Converge trajectory - err = IntegratedTLIToNode(fgout.C3, fgout.CTIO, fgout.DEL, false); + double GMT_node, lat_nd, lng_nd; + if (freereturn) + { + GMT_node = outarray.sv0.GMT + fgout.TOPCY*3600.0; + lat_nd = MEDQuantities.lat_PC; + lng_nd = PI; + } + else + { + GMT_node = MEDQuantities.GMT_node; + lat_nd = MEDQuantities.lat_PC; + lng_nd = MEDQuantities.lng_node; + } + err = IntegratedTLIToNode(fgout.C3, fgout.CTIO, fgout.DEL / 4.0, fgout.S, GMT_node, lat_nd, lng_nd); if (err) { ErrorIndicator = 2; return; } + + if (freereturn) + { + err = IntegratedTLIFlyby(outarray.C3_TLI, outarray.dt_EPO / 3600.0, outarray.delta_TLI, fgout.S, MEDQuantities.lat_PC); + if (err) + { + ErrorIndicator = 2; + return; + } + } +} + +bool TLIProcessor::HybridMission(double C3_guess, double dv_TLI) +{ + double C3_guess_ER = C3_guess / pow(R_E / 3600.0, 2); + + void *constPtr; + outarray.TLIIndicator = true; + outarray.TLIOnlyIndicator = true; + //EllipticalCaseIndicator is used to decide between the nominal vs. alternate mission TLI polynomials + if (C3_guess_ER < -5.0) + { + outarray.EllipticalCaseIndicator = true; + } + else + { + outarray.EllipticalCaseIndicator = false; + } + outarray.sigma_TLI = MissionConstants.sigma; + constPtr = &outarray; + + bool IntegratedTrajectoryComputerPointer(void *data, std::vector &var, void *varPtr, std::vector& arr, bool mode); + bool(*fptr)(void *, std::vector&, void*, std::vector&, bool) = &IntegratedTrajectoryComputerPointer; + + GenIterator::GeneralizedIteratorBlock block; + + block.IndVarSwitch[4] = true; + + block.IndVarGuess[4] = C3_guess_ER; + block.IndVarGuess[5] = 0.0; //dt_EPO + block.IndVarGuess[6] = MissionConstants.delta; + + block.IndVarStep[4] = pow(2, -23); + block.IndVarWeight[4] = 4.0; + + block.DepVarSwitch[9] = true; + block.DepVarLowerLimit[9] = dv_TLI - 1.0*0.3048; + block.DepVarUpperLimit[9] = dv_TLI + 1.0*0.3048; + block.DepVarClass[9] = 1; + + std::vector result; + std::vector y_vals; + return GenIterator::GeneralizedIterator(fptr, block, constPtr, (void*)this, result, y_vals); } bool TLIProcessor::ConicTLIIEllipse(double C3_guess, double h_ap) @@ -923,22 +1038,14 @@ bool TLIProcessor::IntegratedTLIIEllipse(double C3_guess_ER, double h_ap) return GenIterator::GeneralizedIterator(fptr, block, constPtr, (void*)this, result, y_vals); } -bool TLIProcessor::IntegratedTLIToNode(double C3_guess_ER, double T_c_hrs, double delta, bool free_return) +bool TLIProcessor::IntegratedTLIToNode(double C3_guess_ER, double T_c_hrs, double delta, double sigma, double GMT_nd, double lat_nd, double lng_nd) { void *constPtr; outarray.TLIIndicator = true; outarray.EllipticalCaseIndicator = false; - outarray.sigma_TLI = MissionConstants.sigma; - - if (free_return) - { - outarray.NodeStopIndicator = false; - } - else - { - outarray.NodeStopIndicator = true; - outarray.GMT_nd = 0.0; //TBD - } + outarray.sigma_TLI = sigma; + outarray.NodeStopIndicator = true; + outarray.GMT_nd = GMT_nd; constPtr = &outarray; @@ -966,30 +1073,83 @@ bool TLIProcessor::IntegratedTLIToNode(double C3_guess_ER, double T_c_hrs, doubl double R_nd; R_nd = OrbMech::R_Moon + MEDQuantities.h_PC; - if (free_return) - { - - } - else - { - block.DepVarSwitch[0] = true; - block.DepVarSwitch[1] = true; - block.DepVarSwitch[2] = true; - block.DepVarSwitch[3] = true; - block.DepVarLowerLimit[0] = (R_nd - 0.5*1852.0) / R_E; - block.DepVarLowerLimit[1] = MEDQuantities.lat_PC - 0.01*RAD; - block.DepVarLowerLimit[2] = MEDQuantities.lng_node - 0.01*RAD; - block.DepVarLowerLimit[3] = 90.0*RAD; - block.DepVarUpperLimit[0] = (R_nd + 0.5*1852.0) / R_E; - block.DepVarUpperLimit[1] = MEDQuantities.lat_PC + 0.01*RAD; - block.DepVarUpperLimit[2] = MEDQuantities.lng_node + 0.01*RAD; - block.DepVarUpperLimit[3] = 182.0*RAD; - block.DepVarWeight[3] = 64.0; - block.DepVarClass[0] = 1; - block.DepVarClass[1] = 1; - block.DepVarClass[2] = 1; - block.DepVarClass[3] = 2; - } + block.DepVarSwitch[0] = true; + block.DepVarSwitch[1] = true; + block.DepVarSwitch[2] = true; + block.DepVarSwitch[3] = true; + block.DepVarLowerLimit[0] = (R_nd - 0.5*1852.0) / R_E; + block.DepVarLowerLimit[1] = lat_nd - 0.01*RAD; + block.DepVarLowerLimit[2] = lng_nd - 0.01*RAD; + block.DepVarLowerLimit[3] = 90.0*RAD; + block.DepVarUpperLimit[0] = (R_nd + 0.5*1852.0) / R_E; + block.DepVarUpperLimit[1] = lat_nd + 0.01*RAD; + block.DepVarUpperLimit[2] = lng_nd + 0.01*RAD; + block.DepVarUpperLimit[3] = 182.0*RAD; + block.DepVarWeight[3] = 64.0; + block.DepVarClass[0] = 1; + block.DepVarClass[1] = 1; + block.DepVarClass[2] = 1; + block.DepVarClass[3] = 2; + + std::vector result; + std::vector y_vals; + return GenIterator::GeneralizedIterator(fptr, block, constPtr, (void*)this, result, y_vals); +} + +bool TLIProcessor::IntegratedTLIFlyby(double C3_guess_ER, double T_c_hrs, double delta, double sigma, double lat_pc) +{ + void *constPtr; + outarray.TLIIndicator = true; + outarray.EllipticalCaseIndicator = false; + outarray.sigma_TLI = sigma; + outarray.NodeStopIndicator = false; + outarray.LunarFlybyIndicator = false; + + constPtr = &outarray; + + bool IntegratedTrajectoryComputerPointer(void *data, std::vector &var, void *varPtr, std::vector& arr, bool mode); + bool(*fptr)(void *, std::vector&, void*, std::vector&, bool) = &IntegratedTrajectoryComputerPointer; + + GenIterator::GeneralizedIteratorBlock block; + + block.IndVarSwitch[4] = true; //C3 + block.IndVarSwitch[5] = true; //DT EPO + block.IndVarSwitch[6] = true; //TLI plane change + + block.IndVarGuess[4] = C3_guess_ER; + block.IndVarGuess[5] = T_c_hrs; + block.IndVarGuess[6] = delta; + + block.IndVarStep[4] = pow(2, -21); + block.IndVarStep[5] = pow(2, -22); + block.IndVarStep[6] = pow(2, -21); + + block.IndVarWeight[4] = 1.0; + block.IndVarWeight[5] = 1.0; + block.IndVarWeight[6] = 1.0; + + block.DepVarSwitch[3] = true; + block.DepVarSwitch[4] = true; + block.DepVarSwitch[5] = true; + block.DepVarSwitch[6] = true; + block.DepVarSwitch[7] = true; + block.DepVarLowerLimit[3] = 90.0*RAD; + block.DepVarLowerLimit[4] = (MEDQuantities.h_PC - 0.5*1852.0) / R_E; + block.DepVarLowerLimit[5] = lat_pc - 0.01*RAD; + block.DepVarLowerLimit[6] = 0.0; + block.DepVarLowerLimit[7] = (60.85*1852.0) / R_E; + block.DepVarUpperLimit[3] = 182.0*RAD; + block.DepVarUpperLimit[4] = (MEDQuantities.h_PC + 0.5*1852.0) / R_E; + block.DepVarUpperLimit[5] = lat_pc + 0.01*RAD; + block.DepVarUpperLimit[6] = 90.0*RAD; + block.DepVarUpperLimit[7] = (70.85*1852.0) / R_E; + block.DepVarWeight[3] = 64.0; + block.DepVarWeight[6] = 8.0; + block.DepVarClass[3] = 2; + block.DepVarClass[4] = 1; + block.DepVarClass[5] = 1; + block.DepVarClass[6] = 2; + block.DepVarClass[7] = 1; std::vector result; std::vector y_vals; diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.h b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.h index 3069bfc62b..e59e7607d0 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.h +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.h @@ -120,16 +120,20 @@ struct TLIMEDQuantities int Mode; EphemerisData state; PLAWDTOutput WeightsTable; + double GMT_TIG; //TIG or estimated TIG - //Mode 4 - double GMT_TIG; - double h_ap; - - //Mode 5 - int IPOA; //1 = Pacific window (AZ2V <= 90°), 2 = Atlantic window (AZ2V > 90°) + //Mode 2/5 + int IPOA; //1 = Pacific window (AZ2V <= 90°), 2 = Atlantic window (AZ2V > 90°), for first guess logic double h_PC; //Pericynthion flyby altitude, meters - double lat_PC; //Latitude of pericynthion, or of node - double lng_node; //Longitude of node + double lat_PC; //Latitude of pericynthion (mode 2) or of node (mode 5) + double lng_node; //Longitude of node (mode 5) + double GMT_node; //Time at node (mode 5) + + //Mode 3 + double dv_available; //DV available for TLI + + //Mode 4 + double h_ap; //Desired apogee altitude at TLI cutoff }; struct SevenParameterUpdate @@ -160,14 +164,18 @@ class TLIProcessor : public TLTrajectoryComputers void Main(TLIOutputData &out); void Init(TLIMEDQuantities med, TLMCCMissionConstants constants, double GMTBase); protected: + //Free return or non-free return + void Option2_5(bool freereturn); + //Hybrid ellipse + void Option3(); //Desired apogee void Option4(); - //Non-free return - void Option5(); + bool HybridMission(double C3_guess, double dv_TLI); bool ConicTLIIEllipse(double C3_guess, double h_ap); bool IntegratedTLIIEllipse(double C3_guess_ER, double h_ap); - bool IntegratedTLIToNode(double C3_guess_ER, double T_c_hrs, double delta, bool free_return); + bool IntegratedTLIToNode(double C3_guess_ER, double T_c_hrs, double delta, double sigma, double GMT_nd, double lat_nd, double lng_nd); + bool IntegratedTLIFlyby(double C3_guess_ER, double T_c_hrs, double delta, double sigma, double lat_pc); OELEMENTS LVTAR(OELEMENTS coe, double lng_PAD, double RAGL) const; diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLTrajectoryComputers.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLTrajectoryComputers.cpp index 87084162be..a5f5333c54 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLTrajectoryComputers.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLTrajectoryComputers.cpp @@ -37,7 +37,7 @@ TLTrajectoryComputers::TLTrajectoryComputers(RTCC *r) : RTCCModule(r) F_I_SIVB = 179847.1544797684; //LBF, 800000.0 Newton F_SIVB = 202328.0487897395; //LBF, 900000.0 Newton - WDOT_SIVB = 1677750.443641722;; //LBS per hours, 211.393 kg/s + WDOT_SIVB = 1677750.443641722; //LBS per hours, 211.393 kg/s T_MRS_SIVB = 50.0 / 3600.0; //Hours gamma_reentry = -6.52*RAD; @@ -553,6 +553,7 @@ bool TLTrajectoryComputers::IntegratedTrajectoryComputer(std::vector &va //6: Inclination of return in rad //7: Height of return in Er //8: Apogee height in Er + //9: TLI Delta V in m/s TLMCCGeneralizedIteratorArray *vars; vars = static_cast(varPtr); @@ -591,17 +592,31 @@ bool TLTrajectoryComputers::IntegratedTrajectoryComputer(std::vector &va state_TLI2.sv.R *= R_E; state_TLI2.sv.V *= R_E / 3600.0; state_TLI2.sv.GMT *= 3600.0; + state_TLI2.Mass *= 0.45359237; vars->dv_TLI *= R_E / 3600.0; vars->sv_tli_cut = state_TLI2.sv; + arr[9] = vars->dv_TLI; + //Simulate only TLI? + if (vars->TLIOnlyIndicator) return false; + //Simulate through apogee? if (vars->EllipticalCaseIndicator) { //Propagate state vector to apogee pRTCC->PMMCEN(state_TLI2.sv, 0.0, 100.0*3600.0, 2, 0.0, 1.0, sv_ap, ITS); + + //Error: Did not find apogee or reached lunar SOI + if (ITS != 2 || sv_ap.RBI != BODY_EARTH) + { + return true; + } + arr[8] = (length(sv_ap.R) - R_E) / R_E; return false; } + + sv0_apo = vars->sv_tli_cut; if (vars->NodeStopIndicator) { diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLTrajectoryComputers.h b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLTrajectoryComputers.h index 093323165a..e08fa8f751 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLTrajectoryComputers.h +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLTrajectoryComputers.h @@ -53,6 +53,7 @@ struct TLMCCGeneralizedIteratorArray //For integrating trajectory computer bool NodeStopIndicator; bool EllipticalCaseIndicator; + bool TLIOnlyIndicator = false; //For conic trajectory computer bool FreeReturnIndicator; bool FreeReturnOnlyIndicator; @@ -148,8 +149,8 @@ struct TLMCCGeneralizedIteratorArray //TLI only double dv_TLI; - double C3_TLI; - double dt_EPO; + double C3_TLI; //Er^2/hr^2 + double dt_EPO; //sec double delta_TLI; double sigma_TLI; }; From fbe92b053a4243106f8ed5846b74c4184f904fc2 Mon Sep 17 00:00:00 2001 From: indy91 Date: Sun, 22 Sep 2024 18:08:22 +0200 Subject: [PATCH 3/5] Lots of progress with the TLI processor --- .../samples/ProjectApollo/src_launch/rtcc.cpp | 316 ++++++++++++++---- .../samples/ProjectApollo/src_launch/rtcc.h | 59 +++- .../ProjectApollo/src_rtccmfd/ARCore.cpp | 21 +- .../ProjectApollo/src_rtccmfd/ARCore.h | 1 + .../src_rtccmfd/ApolloRTCCMFD.cpp | 95 ++++-- .../ProjectApollo/src_rtccmfd/ApolloRTCCMFD.h | 5 +- .../src_rtccmfd/ApolloRTCCMFD_Display.cpp | 65 +++- .../src_rtccmfd/ApollomfdButtons.cpp | 28 +- .../src_rtccmfd/TLIGuidanceSim.cpp | 2 + .../src_rtccmfd/TLIProcessor.cpp | 101 ++++++ .../ProjectApollo/src_rtccmfd/TLIProcessor.h | 6 + .../src_rtccmfd/TLTrajectoryComputers.h | 2 +- .../src_rtccmfd/rtcc_library_programs.cpp | 8 + 13 files changed, 579 insertions(+), 130 deletions(-) diff --git a/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.cpp b/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.cpp index 4ba6ea0e9a..c55276cd16 100644 --- a/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.cpp @@ -6107,19 +6107,61 @@ void RTCC::PMDLDPP(const LDPPOptions &opt, const LDPPResults &res, LunarDescentP table.PD_ThetaIgn = opt.theta_D*DEG; } -void RTCC::TranslunarInjectionProcessor(EphemerisData sv, PLAWDTOutput WeightsTable) +void RTCC::TranslunarInjectionProcessor(bool mpt, EphemerisData *sv, PLAWDTOutput *WeightsTable) { TLIMEDQuantities medquant; TLMCCMissionConstants mccconst; TLIOutputData out; + if (mpt) + { + //Get state vector + if (PZTLIPLN.VectorType == "ANC") + { + if (PZTLIPLN.mpt == RTCC_MPT_CSM) + { + medquant.state = EZANCHR1.AnchorVectors[9].Vector; + } + else + { + medquant.state = EZANCHR3.AnchorVectors[9].Vector; + } + } + else + { + int val = GetStateVectorTableEntry(PZTLIPLN.VectorType, PZTLIPLN.mpt); + if (val < 0) return; + + medquant.state = BZUSEVEC.data[val].Vector; + } + + if (medquant.state.GMT == 0.0) return; + + //Get weight + PLAWDTInput inp; + PLAWDTOutput outp; + + inp.T_UP = medquant.state.GMT; + inp.TableCode = PZTLIPLN.mpt; + inp.VentingOpt = true; + + PLAWDT(inp, outp); + + medquant.WeightsTable = outp; + } + else + { + medquant.state = *sv; + medquant.WeightsTable = *WeightsTable; + } + + medquant.mpt = PZTLIPLN.mpt; medquant.Mode = PZTLIPLN.Mode; - medquant.state = sv; - medquant.WeightsTable = WeightsTable; medquant.h_ap = PZTLIPLN.h_ap*1852.0; medquant.dv_available = PZTLIPLN.dv_available*0.3048; medquant.GMT_TIG = GMTfromGET(PZTLIPLN.GET_TLI); medquant.IPOA = PZTLIPLN.IsPacficWindow ? 1 : 2; + medquant.Opportunity = PZTLIPLN.Opportunity; if (PZTLIPLN.Mode == 2) { @@ -6146,9 +6188,21 @@ void RTCC::TranslunarInjectionProcessor(EphemerisData sv, PLAWDTOutput WeightsTa if (out.ErrorIndicator) return; + //Output table PZTTLIPL.DataIndicator = 1; PZTTLIPL.elem = out.uplink_data; + //MPT interface table + PZTPDXFR.DataIndicator = true; + PZTPDXFR.T_RP = out.uplink_data.GMT_TIG - SystemParameters.MDVSTP.DTIG; + PZTPDXFR.i = out.uplink_data.Inclination; + PZTPDXFR.theta_N = out.uplink_data.theta_N; + PZTPDXFR.e = out.uplink_data.e; + PZTPDXFR.C3 = out.uplink_data.C3; + PZTPDXFR.alpha_D = out.uplink_data.alpha_D; + PZTPDXFR.f = out.uplink_data.f; + PZTPDXFR.Opportunity = PZTLIPLN.Opportunity; + //Display data PZTPDDIS.GET_TIG = GETfromGMT(out.uplink_data.GMT_TIG); PZTPDDIS.GET_TB6 = PZTPDDIS.GET_TIG - SystemParameters.MDVSTP.DTIG; @@ -6296,14 +6350,36 @@ void RTCC::TLI_PAD(const TLIPADOpt &opt, TLIPAD &pad) in.mpt = &mpt; in.PresentGMT = 0.0; //Is this ok? in.PrevMan = NULL; - in.QUEID = 37; //Direct input S-IVB TLI maneuver + if (opt.StudyAid) + { + in.QUEID = 36; //Transfer from TLI planning study aid + + if (PZTPDXFR.DataIndicator == false) + { + //Error + return; + } + in.T_RP = PZTPDXFR.T_RP; + in.i = PZTPDXFR.i; + in.theta_N = PZTPDXFR.theta_N; + in.e = PZTPDXFR.e; + in.C3 = PZTPDXFR.C3; + in.alpha_D = PZTPDXFR.alpha_D; + in.f = PZTPDXFR.f; + in.InjOpp = PZTPDXFR.Opportunity; + } + else + { + in.QUEID = 37; //Direct input S-IVB TLI maneuver + in.T_RP = -1.0; + } + in.R = opt.sv0.R; in.ReplaceCode = 0; in.StartTimeLimit = 0.0; in.Table = RTCC_MPT_CSM; in.ThrusterCode = RTCC_ENGINETYPE_SIVB_MAIN; in.TVC = RTCC_MPT_CSM; - in.T_RP = -1.0; in.V = opt.sv0.V; int err = PMMSPT(in); @@ -6331,32 +6407,40 @@ void RTCC::TLI_PAD(const TLIPADOpt &opt, TLIPAD &pad) EMMENI(emmeniin); sv_TH = emmeniin.sv_cutoff; - //Continue processing, when the MPT uses PMMSPT with QUEID = 37 then it returns the threshold time first, before it continues processing with QUEID = 39 - in.QUEID = 39; - //Input state vector at threshold, MPT would input a state vector from the ephemeris at the threshold time - in.R = sv_TH.R; - in.V = sv_TH.V; - in.GMT = sv_TH.GMT; - //T_RP reset to zero so that the actual time of restart preparations is calculated - in.T_RP = 0.0; - err = PMMSPT(in); + EphemerisData sv_TB6; + if (opt.StudyAid == false) + { + //Continue processing, when the MPT uses PMMSPT with QUEID = 37 then it returns the threshold time first, before it continues processing with QUEID = 39 + in.QUEID = 39; + //Input state vector at threshold, MPT would input a state vector from the ephemeris at the threshold time + in.R = sv_TH.R; + in.V = sv_TH.V; + in.GMT = sv_TH.GMT; + //T_RP reset to zero so that the actual time of restart preparations is calculated + in.T_RP = 0.0; + err = PMMSPT(in); - if (err) return; + if (err) return; - //Take SV to TB6 - dt = man.GMTMAN - opt.sv0.GMT; - if (dt >= 0) - { - emmeniin.IsForwardIntegration = 1.0; + //Take SV to TB6 + dt = man.GMTMAN - opt.sv0.GMT; + if (dt >= 0) + { + emmeniin.IsForwardIntegration = 1.0; + } + else + { + emmeniin.IsForwardIntegration = -1.0; + } + emmeniin.MaxIntegTime = abs(dt); + emmeniin.AnchorVector = opt.sv0; + EMMENI(emmeniin); + sv_TB6 = emmeniin.sv_cutoff; } else { - emmeniin.IsForwardIntegration = -1.0; + sv_TB6 = sv_TH; } - emmeniin.MaxIntegTime = abs(dt); - emmeniin.AnchorVector = opt.sv0; - EMMENI(emmeniin); - EphemerisData sv_TB6 = emmeniin.sv_cutoff; //Update mass plain.CSMArea = 0.0; @@ -8373,7 +8457,7 @@ int RTCC::PMMSPT(PMMSPTInput &in) VECTOR3 TargetVector, T_P, R, V, P, S, P_dot, S_dot, Hbar, H_apo, W, Sbar_1, Cbar_1, Omega_X, Omega_Y, Omega_Z; double T_TH, alpha_TSS, alpha_TS, beta, T_RP, f, R_N, KP0, KY0, T3_apo, T_ST, tau3R, T2, Vex2, Mdot2, DV_BR, tau2N, lambda, dt_ig, T, dt4, dt4_apo; double t_D, cos_sigma, C3, e_N, RA, DEC, theta_E, RR, SINB, COSB, COSATS, t, p, r, vv, C1, C2, p_dot, h, w, du_apo, c, theta, du, cos_psi, sin_psi; - double i, X1, X2, theta_N, P_N, T_M, alpha_D_apo, P_RP, Y_RP, T3, tau3, A_Z, Azo, Azs, i_P, theta_N_P; + double i, X1, X2, theta_N, P_N, T_M, alpha_D_apo, P_RP, Y_RP, T3, tau3, A_Z, Azo, Azs, i_P, theta_N_P, K5, R_T, V_T, gamma_T, G_T; int J, OrigTLIInd, CurTLIInd, LD, counter, GRP15, KX, err, n; unsigned ORER_out; @@ -8436,20 +8520,27 @@ int RTCC::PMMSPT(PMMSPTInput &in) } if (in.QUEID == 34) { - //TBD: load data from study aid. Or not? + //Study Aid goto RTCC_PMMSPT_3_2; } T_RP = in.T_RP; - if (T_RP > 0) + //Were target parameters input? + if (in.e >= 0.0) { - OrigTLIInd = -in.InjOpp; + OrigTLIInd = 0; } else { - RTCC_PMMSPT_3_2: - OrigTLIInd = in.InjOpp; + if (T_RP > 0) + { + OrigTLIInd = -in.InjOpp; + } + else + { + RTCC_PMMSPT_3_2: + OrigTLIInd = in.InjOpp; + } } - CurTLIInd = OrigTLIInd; J = in.InjOpp; RTCC_PMMSPT_4_1: @@ -8485,10 +8576,12 @@ int RTCC::PMMSPT(PMMSPTInput &in) if (OrigTLIInd > 0) { + //Opportunity only input goto RTCC_PMMSPT_6_3; } else if (OrigTLIInd == 0) { + //Opportunity, T_RP and target params input goto RTCC_PMMSPT_8_2; } @@ -8581,6 +8674,15 @@ int RTCC::PMMSPT(PMMSPTInput &in) } t_D = GetGMTLO()*3600.0 - tlitab->T_LO; + if (OrigTLIInd == 0) + { + goto RTCC_PMMSPT_15_1; + } + else if (OrigTLIInd > 0) + { + //TBD: Move R, V at T_TH into output table + } + GRP15 = PCMSP2(tlitab, J, t_D, cos_sigma, C3, e_N, RA, DEC); if (GRP15) { @@ -8679,16 +8781,37 @@ int RTCC::PMMSPT(PMMSPTInput &in) P_N = (OrbMech::mu_Earth / C3)*(e_N*e_N - 1.0); T_M = P_N / (1.0 - e_N * cos_sigma); alpha_D_apo = acos(cos_psi) + atan2(dotp(Sbar_1, crossp(Cbar_1, Omega_Y)), dotp(S, crossp(Cbar_1, Omega_Y))); - in.CurMan->dV_inertial.x = i; - in.CurMan->dV_inertial.y = theta_N; - in.CurMan->dV_inertial.z = e_N; - in.CurMan->dV_LVLH.x = C3; - in.CurMan->dV_LVLH.y = alpha_D_apo; - in.CurMan->dV_LVLH.z = f; + //Store i, theta_N, alpha_D_apo, f, R_N, T_M in MPT block + in.CurMan->Inclination = i; + in.CurMan->theta_N = theta_N; + in.CurMan->Eccentricity = e_N; + in.CurMan->C3 = C3; + in.CurMan->alpha_D = alpha_D_apo; + in.CurMan->f = f; in.CurMan->Word67d = R_N; in.CurMan->Word69 = T_M; goto RTCC_PMMSPT_15_2; -//RTCC_PMMSPT_15_1: +RTCC_PMMSPT_15_1: + //Store input i, theta_N, e, C3, alpha_D, f in MPT block + in.CurMan->Inclination = in.i; + in.CurMan->theta_N = in.theta_N; + in.CurMan->Eccentricity = in.e; + in.CurMan->C3 = in.C3; + in.CurMan->alpha_D = in.alpha_D; + in.CurMan->f = in.f; + P_N = (OrbMech::mu_Earth / in.C3)*(in.e*in.e - 1.0); + K5 = sqrt(OrbMech::mu_Earth / P_N); + R_T = P_N / (1.0 + in.e*cos(in.f)); + V_T = K5 * sqrt(1.0 + 2.0*in.e*cos(in.f) + in.e*in.e); + gamma_T = atan(in.e*sin(in.f) / (1.0 + in.e*cos(in.f))); + G_T = -OrbMech::mu_Earth / pow(R_T, 2); + //Store P, K5, R_T, V_T, gamma_T, G_T in MPT block + in.CurMan->Word67d = P_N; + in.CurMan->Word68 = K5; + in.CurMan->Word69 = R_T; + in.CurMan->Word70 = V_T; + in.CurMan->Word71 = gamma_T; + in.CurMan->Word72 = G_T; RTCC_PMMSPT_15_2: P_RP = KP0 + SystemParameters.MDVSTP.KP1 * dt4_apo + SystemParameters.MDVSTP.KP2 * dt4_apo*dt4_apo; Y_RP = KP0 + SystemParameters.MDVSTP.KY1 * dt4_apo + SystemParameters.MDVSTP.KY2 * dt4_apo*dt4_apo; @@ -8747,7 +8870,9 @@ int RTCC::PMMSPT(PMMSPTInput &in) EPH = mul(OrbMech::tmat(A), M); BB = _M(cos(theta_N_P), 0, sin(theta_N_P), sin(theta_N_P)*sin(i_P), cos(i_P), -cos(theta_N_P)*sin(i_P), -sin(theta_N_P)*cos(i_P), sin(i_P), cos(theta_N_P)*cos(i_P)); GG = mul(BB, A); - B = _M(cos(theta_N), 0, sin(theta_N), sin(theta_N)*sin(i), cos(i), -cos(theta_N)*sin(i), -sin(theta_N)*cos(i), sin(i), cos(theta_N)*cos(i)); + B = _M(cos(in.CurMan->theta_N), 0, sin(in.CurMan->theta_N), + sin(in.CurMan->theta_N)*sin(in.CurMan->Inclination), cos(in.CurMan->Inclination), -cos(in.CurMan->theta_N)*sin(in.CurMan->Inclination), + -sin(in.CurMan->theta_N)*cos(in.CurMan->Inclination), sin(in.CurMan->Inclination), cos(in.CurMan->theta_N)*cos(in.CurMan->Inclination)); G = mul(B, A); in.CurMan->GMTI = T_RP + SystemParameters.MDVSTP.DTIG; @@ -22311,7 +22436,7 @@ int RTCC::PMMXFR(int id, void *data) //Initialize flags working_man = 1; //Direct inputs (RTE, MPT, TLI) - if (id == 32 || id == 33 || id == 37) + if (id == 32 || id == 33 || id == 36 || id == 37) { PMMXFRDirectInput *inp = static_cast(data); std::string purpose; @@ -22417,24 +22542,42 @@ int RTCC::PMMXFR(int id, void *data) BPIND = inp->BurnParameterNumber; } //TLI - else if (id == 37) + else if (id == 36 || id == 37) { purpose = "TL"; - PMMSPTInput tliin; - - tliin.QUEID = id; - tliin.PresentGMT = RTCCPresentTimeGMT(); - tliin.ReplaceCode = 0; - tliin.InjOpp = inp->BurnParameterNumber; - tliin.Table = inp->TableCode; + if (id == 36) + { + //TLI study aid - if (err = PMMSPT(tliin)) + //Does it exist? + if (PZTPDXFR.DataIndicator == false) + { + //No + PMXSPT("PMMSPT", 38); + return 38; + } + inp->GMTI = PZTPDXFR.T_RP; + } + else { - PMXSPT("PMMSPT", err); - return 1; + PMMSPTInput tliin; + + tliin.QUEID = id; + tliin.PresentGMT = RTCCPresentTimeGMT(); + tliin.ReplaceCode = 0; + tliin.InjOpp = inp->BurnParameterNumber; + tliin.Table = inp->TableCode; + + if (err = PMMSPT(tliin)) + { + PMXSPT("PMMSPT", err); + return 1; + } + + inp->GMTI = tliin.T_RP; } - inp->GMTI = tliin.T_RP; + inp->ThrusterCode = RTCC_ENGINETYPE_SIVB_MAIN; inp->AttitudeCode = RTCC_ATTITUDE_SIVB_IGM; inp->ConfigurationChangeIndicator = RTCC_CONFIGCHANGE_NONE; @@ -22517,7 +22660,6 @@ int RTCC::PMMXFR(int id, void *data) in.CurMan = &man; in.EndTimeLimit = UpperLimit; in.GMT = sv.GMT; - in.InjOpp = inp->BurnParameterNumber; in.mpt = mpt; in.PresentGMT = RTCCPresentTimeGMT(); if (mpt->mantable.size() == 0) @@ -22528,14 +22670,34 @@ int RTCC::PMMXFR(int id, void *data) { in.PrevMan = &mpt->mantable.back(); } - in.QUEID = 39; + if (id == 36) + { + //Study aid + in.QUEID = 36; + in.T_RP = PZTPDXFR.T_RP; + in.i = PZTPDXFR.i; + in.theta_N = PZTPDXFR.theta_N; + in.e = PZTPDXFR.e; + in.C3 = PZTPDXFR.C3; + in.alpha_D = PZTPDXFR.alpha_D; + in.f = PZTPDXFR.f; + in.InjOpp = PZTPDXFR.Opportunity; + } + else + { + //Direct transfer + in.QUEID = 39; + in.T_RP = 0.0; + in.InjOpp = inp->BurnParameterNumber; + } + in.R = sv.R; in.ReplaceCode = inp->ReplaceCode; in.StartTimeLimit = LowerLimit; in.Table = inp->TableCode; in.ThrusterCode = RTCC_ENGINETYPE_SIVB_MAIN; in.TVC = RTCC_MANVEHICLE_SIVB; - in.T_RP = 0.0; + in.V = sv.V; err = PMMSPT(in); @@ -30801,6 +30963,29 @@ int RTCC::PMMMED(std::string med, std::vector data) void *vPtr = &inp; return PMMXFR(32, vPtr); } + //TLI Study Aid Transfer + else if (med == "75") + { + //Item 1: Vehicle + rtcc::AddTextMEDItem(opt, 1, MHGVNM.tab); + //Item 2: Replace option + rtcc::AddIntegerMEDItem(opt, 2, true, true, 0, 15, 0); + + int err = rtcc::GenericMEDProcessing(opt, data, out); + if (err) + { + //param = out.errorItem; + return 0; + } + + PMMXFRDirectInput inp; + + inp.TableCode = out.Values[0].i == 0 ? RTCC_MPT_CSM : RTCC_MPT_LM; + inp.ReplaceCode = out.Values[1].i; + + void *vPtr = &inp; + return PMMXFR(36, vPtr); + } //LOI and MCC Transfer else if (med == "78") { @@ -36058,6 +36243,25 @@ int RTCC::BMSVPSVectorFetch(const std::string &vecid, EphemerisData &sv_out) return 1; } +int RTCC::GetStateVectorTableEntry(std::string VectorType, int mpt) +{ + int val; + + if (VectorType == "CMC") val = 0; + else if (VectorType == "LGC") val = 1; + else if (VectorType == "AGS") val = 2; + else if (VectorType == "IU") val = 3; + else if (VectorType == "HSR") val = 4; + else if (VectorType == "DC") val = 5; + else return -1; + + if (mpt == RTCC_MPT_LM) + { + val += 6; + } + return val; +} + void RTCC::BMSVPS(int queid, int PBIID) { //0 = Vector control queue diff --git a/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.h b/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.h index 294e3aea9f..53bea48a4f 100644 --- a/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.h +++ b/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.h @@ -572,6 +572,7 @@ struct TLIPADOpt VECTOR3 SeparationAttitude; //LVLH IMU angles double ConfigMass; int InjOpp; //Injection opportunity (1 or 2) + bool StudyAid = false; //false = Planned TLI, true = from TLI processor }; struct P27Opt @@ -1363,11 +1364,20 @@ struct MPTManeuver //Word 59, DPS scale factor (0 to 1) double DPSScaleFactor; //Word 61-63 - //For ascent maneuver this is: R_D, Y_D - VECTOR3 dV_inertial; //In RTCC coordinates - //Word 64-66, In P30 coordinates - //For ascent maneuver this is: R_D_dot, Y_D_dot, Z_D_dot - VECTOR3 dV_LVLH; + union + { + VECTOR3 dV_inertial; //In RTCC coordinates + struct { double R_D, Y_D; }; //Ascent + struct { double Inclination, theta_N, Eccentricity; }; //TLI + }; + //Word 64-66 + union + { + VECTOR3 dV_LVLH; //In P30 coordinates + struct { double R_D_dot, Y_D_dot, Z_D_dot; }; //Ascent + struct { double C3, alpha_D, f; }; //TLI + }; + //Word 67 union { //ExtDVCoordInd and @@ -1702,13 +1712,23 @@ struct PMMSPTInput unsigned ReplaceCode; int InjOpp; //Word 12 (Time of ignition for TLI confirmation, negative if not input) - double T_RP = -1; + double T_RP = -1.; //Word 13 int ThrusterCode; int AttitudeMode; - //Word 14-19 + //Word 14 std::string StationID; - //Targeting Parameters + double i; //Inclination of target orbit + //Word 15, Longitude of descending node of target orbit + double theta_N; + //Word 16, Eccentricity of target conic (negative of targeting parameters not input) + double e = -1.; + //Word 17, equals (-mu/a), where a is semi-major axis of target conic + double C3; + //Word 18, true anomaly of the descending node of the target conic + double alpha_D; + //Word 19, estimated true anomaly at cutoff + double f; //Word 20 (DT of burn for maneuver confirmation, negative if not input) double dt; //Word 29, configuration change indicator @@ -2470,7 +2490,7 @@ class RTCC { MATRIX3 REFSMMATCalc(REFSMMATOpt *opt); void EntryTargeting(EntryOpt *opt, EntryResults *res);//VECTOR3 &dV_LVLH, double &P30TIG, double &latitude, double &longitude, double &GET05G, double &RTGO, double &VIO, double &ReA, int &precision); void BlockDataProcessor(EarthEntryOpt *opt, EntryResults *res); - void TranslunarInjectionProcessor(EphemerisData sv, PLAWDTOutput WeightsTable); + void TranslunarInjectionProcessor(bool mpt, EphemerisData *sv = NULL, PLAWDTOutput *WeightsTable = NULL); void TranslunarMidcourseCorrectionProcessor(EphemerisData sv0, double CSMmass, double LMmass); int LunarDescentPlanningProcessor(EphemerisData sv, double W_LM); bool GeneralManeuverProcessor(GMPOpt *opt, VECTOR3 &dV_i, double &P30TIG); @@ -2794,6 +2814,7 @@ class RTCC { //Vector Panel Summary Control void BMSVPS(int queid, int PBIID); int BMSVPSVectorFetch(const std::string &vecid, EphemerisData &sv_out); + int GetStateVectorTableEntry(std::string VectorType, int mpt); // DIGITAL COMMAND SYSTEM (C) @@ -3770,8 +3791,14 @@ class RTCC { struct TLIPlanningTable { //INPUT + // + int mpt = 1; + //Vector type. CMC, LGC, AGS, IU, HSR, DC or ANC + std::string VectorType = "ANC"; //2 = free-return, 3 = hybrid ellipse, 4 = E-type mission ellipse, 5 = non-free return int Mode = 4; + //TLI opportunity (1-2) + int Opportunity = 1; //TLI ignition for mode 4, estimated TIG for mode 5 double GET_TLI = 0.0; //Apogee height for mode 4, nautical miles @@ -3798,6 +3825,20 @@ class RTCC { double lng_ign = 0.0; } PZTPDDIS; + struct TLIPlanningMPTInterfaceDataTable + { + bool DataIndicator = false; //false = nothing here, true = good data + + double T_RP; + double i; + double theta_N; + double e; + double C3; + double alpha_D; + double f; + int Opportunity; //1-2 + } PZTPDXFR; + struct TLIPlanningOutputTable { int DataIndicator = 0; //0 = None, 1 = 7 parameters, 2 = 10 parameters diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ARCore.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ARCore.cpp index 4a22799f35..55f6f92376 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ARCore.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ARCore.cpp @@ -677,6 +677,7 @@ ARCore::ARCore(VESSEL* v, AR_GCore* gcin) manpad_ullage_opt = true; ManPADMPT = 1; ManPADMPTManeuver = 1; + TLIPAD_StudyAid = false; mapupdate.LOSGET = 0.0; mapupdate.AOSGET = 0.0; @@ -3252,6 +3253,7 @@ int ARCore::subThread() opt.REFSMMAT= GC->rtcc->EZJGMTX1.data[0].REFSMMAT; opt.SeparationAttitude = lvdc->XLunarAttitude; opt.sv0 = GC->rtcc->StateVectorCalcEphem(GC->rtcc->pCSM); + opt.StudyAid = TLIPAD_StudyAid; GC->rtcc->TLI_PAD(opt, GC->tlipad); @@ -3515,16 +3517,23 @@ int ARCore::subThread() EphemerisData state; PLAWDTOutput WeightsTable; - if (iuvessel == NULL) + if (GC->MissionPlanningActive) { - Result = DONE; - break; + GC->rtcc->TranslunarInjectionProcessor(true); } + else + { + if (iuvessel == NULL) + { + Result = DONE; + break; + } - state = GC->rtcc->StateVectorCalcEphem(iuvessel); - WeightsTable = GC->rtcc->GetWeightsTable(iuvessel, true, false); + state = GC->rtcc->StateVectorCalcEphem(iuvessel); + WeightsTable = GC->rtcc->GetWeightsTable(iuvessel, true, false); - GC->rtcc->TranslunarInjectionProcessor(state, WeightsTable); + GC->rtcc->TranslunarInjectionProcessor(false, &state, &WeightsTable); + } Result = DONE; } diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ARCore.h b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ARCore.h index 9f8ae2a0f8..229866c3e0 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ARCore.h +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ARCore.h @@ -305,6 +305,7 @@ class ARCore { bool manpad_ullage_opt; //true = 4 jets, false = 2 jets int ManPADMPT; //1 = CSM, 3 = LEM int ManPADMPTManeuver; //1-15 + bool TLIPAD_StudyAid; //False = nominal TLI, true = study aid //MAP UPDATE PAGE AP10MAPUPDATE mapupdate; diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.cpp index 25d3874f9d..06812fef71 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.cpp @@ -1129,6 +1129,8 @@ void ApolloRTCCMFD::menuMidcourseTradeoffPage() void ApolloRTCCMFD::menuTLIPlanningPage() { + marker = 0; + markermax = 7; SelectPage(79); } @@ -6005,7 +6007,14 @@ void ApolloRTCCMFD::menuCycleTwoImpulseOption() void ApolloRTCCMFD::menuSwitchHeadsUp() { - G->HeadsUp = !G->HeadsUp; + if (G->manpadopt == 3) + { + G->TLIPAD_StudyAid = !G->TLIPAD_StudyAid; + } + else + { + G->HeadsUp = !G->HeadsUp; + } } void ApolloRTCCMFD::menuCalcManPAD() @@ -7209,36 +7218,52 @@ void ApolloRTCCMFD::menuTLIProcessorCalc() G->TLIProcessorCalc(); } -void ApolloRTCCMFD::menuTLIProcessorMode() -{ - if (GC->rtcc->PZTLIPLN.Mode < 5) - { - GC->rtcc->PZTLIPLN.Mode++; - } - else - { - GC->rtcc->PZTLIPLN.Mode = 2; - } -} - -void ApolloRTCCMFD::menuTLIProcessorGET() +void ApolloRTCCMFD::menuSetTLIProcessorInput() { - GenericGETInput(&GC->rtcc->PZTLIPLN.GET_TLI, "Input time of ignition or threshold time. Format HH:MM:SS:"); -} - -void ApolloRTCCMFD::menuTLIEllipseApogee() -{ - if (GC->rtcc->PZTLIPLN.Mode == 3) - { - GenericDoubleInput(&GC->rtcc->PZTLIPLN.dv_available, "Available Delta V for TLI (0 to 10000 ft/s):"); - } - else if (GC->rtcc->PZTLIPLN.Mode == 4) - { - GenericDoubleInput(&GC->rtcc->PZTLIPLN.h_ap, "Input height of apogee (2700 to 7000 NM):"); - } - else + switch (marker) { - GC->rtcc->PZTLIPLN.IsPacficWindow = !GC->rtcc->PZTLIPLN.IsPacficWindow; + case 0: + set_IUVessel(); + break; + case 1: + GC->rtcc->PZTLIPLN.mpt = 4 - GC->rtcc->PZTLIPLN.mpt; + break; + case 2: + GenericStringInput(&GC->rtcc->PZTLIPLN.VectorType, "Vector type (CMC, LGC, AGS, IU, HSR, DC, ANC):"); + break; + case 3: + GC->rtcc->PZTLIPLN.Opportunity = 3 - GC->rtcc->PZTLIPLN.Opportunity; + break; + case 4: + if (GC->rtcc->PZTLIPLN.Mode < 5) + { + GC->rtcc->PZTLIPLN.Mode++; + } + else + { + GC->rtcc->PZTLIPLN.Mode = 2; + } + break; + case 5: + GenericGETInput(&GC->rtcc->PZTLIPLN.GET_TLI, "Input time of ignition or threshold time. Format HH:MM:SS:"); + break; + case 6: + if (GC->rtcc->PZTLIPLN.Mode == 3) + { + GenericDoubleInput(&GC->rtcc->PZTLIPLN.dv_available, "Available Delta V for TLI (0 to 10000 ft/s):"); + } + else if (GC->rtcc->PZTLIPLN.Mode == 4) + { + GenericDoubleInput(&GC->rtcc->PZTLIPLN.h_ap, "Input height of apogee (2700 to 7000 NM):"); + } + else + { + GC->rtcc->PZTLIPLN.IsPacficWindow = !GC->rtcc->PZTLIPLN.IsPacficWindow; + } + break; + case 7: + menuCycleTLCCCSFPBlockNumber(); + break; } } @@ -9835,6 +9860,11 @@ void ApolloRTCCMFD::CycleEnableCalculation() EnableCalculation = !EnableCalculation; } +void ApolloRTCCMFD::SetMEDInputPageM75() +{ + SetMEDInputPage("M75"); +} + void ApolloRTCCMFD::SetMEDInputPageP13() { SetMEDInputPage("P13"); @@ -9933,6 +9963,13 @@ void ApolloRTCCMFD::SetMEDInputPage(std::string med) MEDInputData.display = 100; } + else if (med == "M75") + { + AddMEDInputTitle(MEDInputData, "M75", "Transfer of TLI maneuver from study aid"); + + AddMEDInput(MEDInputData.table, "VEH:", "Vehicle (CSM or LEM):", "CSM", ""); + AddMEDInput(MEDInputData.table, "REP:", "Replace code (1-15 or 0 if no replacement):", "0", ""); + } else if (med == "P13") { AddMEDInputTitle(MEDInputData, "P13", "Enter Vector in Spherical Coordinates"); diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.h b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.h index 39c6336faf..980e8e28c4 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.h +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.h @@ -416,10 +416,8 @@ class ApolloRTCCMFD: public MFD2 { void menuTerrainModelCalc(); void set_TLand(double time); void menuTLCCCalc(); + void menuSetTLIProcessorInput(); void menuTLIProcessorCalc(); - void menuTLIProcessorMode(); - void menuTLIProcessorGET(); - void menuTLIEllipseApogee(); void menuNavCheckPADCalc(); void menuSetNavCheckGET(); void menuLAPCalc(); @@ -864,6 +862,7 @@ class ApolloRTCCMFD: public MFD2 { void CycleCSMOrLMSelection(); void CycleEnableCalculation(); + void SetMEDInputPageM75(); void SetMEDInputPageP13(); void SetMEDInputPageP14(); void SetMEDInputPage(std::string med); diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD_Display.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD_Display.cpp index 16af9a6c1d..71f70f5c05 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD_Display.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD_Display.cpp @@ -1255,6 +1255,15 @@ bool ApolloRTCCMFD::Update(oapi::Sketchpad *skp) { skp->Text(4 * W / 8, (int)(0.5 * H / 14), "TLI PAD", 7); + if (G->TLIPAD_StudyAid) + { + skp->Text(1 * W / 16, 6 * H / 14, "TLI Processor", 13); + } + else + { + skp->Text(1 * W / 16, 6 * H / 14, "Nominal", 7); + } + GET_Display(Buffer, GC->tlipad.TB6P); sprintf(Buffer, "%s TB6p", Buffer); skp->Text(3 * W / 8, 3 * H / 20, Buffer, strlen(Buffer)); @@ -7094,6 +7103,9 @@ bool ApolloRTCCMFD::Update(oapi::Sketchpad *skp) { skp->Text(2 * W / 8, 1 * H / 14, "TLI PLANNING DISPLAY (MSK 0080)", 31); + skp->Text(1 * W / 44, (marker + 3) * H / 22, "*", 1); + + skp->Text(1 * W / 22, 3 * H / 22, "IU:", 3); if (G->iuvessel == NULL) { sprintf_s(Buffer, 127, "No IU!"); @@ -7102,51 +7114,80 @@ bool ApolloRTCCMFD::Update(oapi::Sketchpad *skp) { sprintf_s(Buffer, 127, G->iuvessel->GetName()); } - skp->Text(1 * W / 16, 2 * H / 14, Buffer, strlen(Buffer)); + skp->Text(5 * W / 22, 3 * H / 22, Buffer, strlen(Buffer)); + + if (GC->MissionPlanningActive) + { + skp->Text(1 * W / 22, 4 * H / 22, "MPT:", 4); + if (GC->rtcc->PZTLIPLN.mpt == RTCC_MPT_CSM) + { + sprintf(Buffer, "CSM"); + } + else + { + sprintf(Buffer, "LEM"); + } + skp->Text(5 * W / 22, 4 * H / 22, Buffer, strlen(Buffer)); + + skp->Text(1 * W / 22, 5 * H / 22, "Vec:", 4); + skp->Text(5 * W / 22, 5 * H / 22, GC->rtcc->PZTLIPLN.VectorType.c_str(), GC->rtcc->PZTLIPLN.VectorType.size()); + } + + skp->Text(1 * W / 22, 6 * H / 22, "Opp:", 4); + sprintf(Buffer, "%d", GC->rtcc->PZTLIPLN.Opportunity); + skp->Text(5 * W / 22, 6 * H / 22, Buffer, strlen(Buffer)); + skp->Text(1 * W / 22, 7 * H / 22, "Mode:", 5); switch (GC->rtcc->PZTLIPLN.Mode) { case 2: - skp->Text(1 * W / 16, 4 * H / 14, "Free Return", 11); + skp->Text(5 * W / 22, 7 * H / 22, "Free Return", 11); break; case 3: - skp->Text(1 * W / 16, 4 * H / 14, "Hybrid Ellipse", 14); + skp->Text(5 * W / 22, 7 * H / 22, "Hybrid Ellipse", 14); break; case 4: - skp->Text(1 * W / 16, 4 * H / 14, "Specified Apogee", 16); + skp->Text(5 * W / 22, 7 * H / 22, "Specified Apogee", 16); break; case 5: - skp->Text(1 * W / 16, 4 * H / 14, "Non-Free Return", 15); + skp->Text(5 * W / 22, 7 * H / 22, "Non-Free Return", 15); break; default: - skp->Text(1 * W / 16, 4 * H / 14, "TBD", 3); + skp->Text(5 * W / 22, 7 * H / 22, "Hypersurface", 12); break; } + skp->Text(1 * W / 22, 8 * H / 22, "TIG:", 4); GET_Display(Buffer, GC->rtcc->PZTLIPLN.GET_TLI, false); - skp->Text(1 * W / 16, 6 * H / 14, Buffer, strlen(Buffer)); + skp->Text(5 * W / 22, 8 * H / 22, Buffer, strlen(Buffer)); if (GC->rtcc->PZTLIPLN.Mode == 3) { + skp->Text(1 * W / 22, 9 * H / 22, "DV:", 3); sprintf_s(Buffer, "%.0lf ft/s", GC->rtcc->PZTLIPLN.dv_available); - skp->Text(1 * W / 16, 8 * H / 14, Buffer, strlen(Buffer)); + skp->Text(5 * W / 22, 9 * H / 22, Buffer, strlen(Buffer)); } else if (GC->rtcc->PZTLIPLN.Mode == 4) { + skp->Text(1 * W / 22, 9 * H / 22, "APO:", 4); + sprintf_s(Buffer, "%.0lf NM", GC->rtcc->PZTLIPLN.h_ap); - skp->Text(1 * W / 16, 8 * H / 14, Buffer, strlen(Buffer)); + skp->Text(5 * W / 22, 9 * H / 22, Buffer, strlen(Buffer)); } else { + skp->Text(1 * W / 22, 9 * H / 22, "Window:", 7); + if (GC->rtcc->PZTLIPLN.IsPacficWindow) { - skp->Text(1 * W / 16, 8 * H / 14, "Pacific Window", 14); + skp->Text(5 * W / 22, 9 * H / 22, "Pacific", 14); } else { - skp->Text(1 * W / 16, 8 * H / 14, "Atlantic Window", 15); + skp->Text(5 * W / 22, 9 * H / 22, "Atlantic", 15); } + skp->Text(1 * W / 22, 10 * H / 22, "SFP:", 4); if (GC->rtcc->PZMCCPLN.SFPBlockNum == 1) { sprintf(Buffer, "1 (Preflight)"); @@ -7155,7 +7196,7 @@ bool ApolloRTCCMFD::Update(oapi::Sketchpad *skp) { sprintf(Buffer, "2 (Nominal Targets)"); } - skp->Text(1 * W / 16, 10 * H / 14, Buffer, strlen(Buffer)); + skp->Text(5 * W / 22, 10 * H / 22, Buffer, strlen(Buffer)); /* if (GC->rtcc->PZTLIPLN.Mode == 2) diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApollomfdButtons.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApollomfdButtons.cpp index 2062b0e7ac..6ba95de605 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApollomfdButtons.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApollomfdButtons.cpp @@ -2692,34 +2692,34 @@ ApolloRTCCMFDButtons::ApolloRTCCMFDButtons() static const MFDBUTTONMENU mnu79[] = { - { "IU vessel", 0, 'L' }, - { "Mode", 0, 'G' }, - { "Time of ignition", 0, 'Q' }, - { "Apogee height", 0, 'V' }, - { "Cycle SFP table", 0, 'H' }, + { "Set input", 0, 'S' }, + { "Previous Item", 0, 'P' }, + { "Next Item", 0, 'N' }, { "", 0, ' ' }, - - { "Calculate solution", 0, 'C' }, { "", 0, ' ' }, { "", 0, ' ' }, + + { "Calculate solution", 0, 'C' }, { "", 0, ' ' }, { "", 0, ' ' }, + { "Transfer to MPT", 0, 'S' }, + { "Uplink to LVDC", 0, 'E' }, { "Back to menu", 0, 'B' }, }; RegisterPage(mnu79, sizeof(mnu79) / sizeof(MFDBUTTONMENU)); - RegisterFunction("IU", OAPI_KEY_L, &ApolloRTCCMFD::set_IUVessel); - RegisterFunction("MOD", OAPI_KEY_G, &ApolloRTCCMFD::menuTLIProcessorMode); - RegisterFunction("TIG", OAPI_KEY_Q, &ApolloRTCCMFD::menuTLIProcessorGET); - RegisterFunction("APO", OAPI_KEY_V, &ApolloRTCCMFD::menuTLIEllipseApogee); - RegisterFunction("SFP", OAPI_KEY_H, &ApolloRTCCMFD::menuCycleTLCCCSFPBlockNumber); - RegisterFunction("", OAPI_KEY_Q, &ApolloRTCCMFD::menuVoid); + RegisterFunction("SET", OAPI_KEY_S, &ApolloRTCCMFD::menuSetTLIProcessorInput); + RegisterFunction("<<", OAPI_KEY_P, &ApolloRTCCMFD::menuCycleMarkerDown); + RegisterFunction(">>", OAPI_KEY_N, &ApolloRTCCMFD::menuCycleMarkerUp); + RegisterFunction("", OAPI_KEY_R, &ApolloRTCCMFD::menuVoid); + RegisterFunction("", OAPI_KEY_D, &ApolloRTCCMFD::menuVoid); + RegisterFunction("", OAPI_KEY_A, &ApolloRTCCMFD::menuVoid); RegisterFunction("CLC", OAPI_KEY_C, &ApolloRTCCMFD::menuTLIProcessorCalc); RegisterFunction("", OAPI_KEY_A, &ApolloRTCCMFD::menuVoid); RegisterFunction("", OAPI_KEY_P, &ApolloRTCCMFD::menuVoid); - RegisterFunction("", OAPI_KEY_S, &ApolloRTCCMFD::menuVoid); + RegisterFunction("MPT", OAPI_KEY_S, &ApolloRTCCMFD::SetMEDInputPageM75); RegisterFunction("UPL", OAPI_KEY_E, &ApolloRTCCMFD::menuSLVTLITargetingUplink); RegisterFunction("BCK", OAPI_KEY_B, &ApolloRTCCMFD::menuTranslunarPage); diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIGuidanceSim.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIGuidanceSim.cpp index c0e9757a77..c94a5fd08a 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIGuidanceSim.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIGuidanceSim.cpp @@ -675,6 +675,7 @@ void TLIGuidanceSim::PCMGN() { goto PMMSIU_PCMGN_20; } + //Target update calculations RN = P; E = RMAG * (E - 1.0) / RN + 1.0; TEMP1 = E * E; @@ -701,6 +702,7 @@ void TLIGuidanceSim::PCMGN() DDLT = T - TLAST; goto PMMSIU_PCMGN_2A; PMMSIU_PCMGN_1B: + //Target update calculations ALPHD = ALPHD - acos(TEMP4); TEMP2 = E * cos(F); RT = P / (1.0 + TEMP2); diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.cpp index 8f2395820c..f0347fdabe 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.cpp @@ -688,8 +688,34 @@ void TLIProcessor::Main(TLIOutputData &out) { ErrorIndicator = 0; + //Get time of mixture ratio shift + TLITargetingParametersTable *tlitab = NULL; + int LD; + + LD = pRTCC->GZGENCSN.RefDayOfYear; + + for (int counter = 0; counter < 10; counter++) + { + if (LD == pRTCC->PZSTARGP.data[counter].Day) + { + tlitab = &pRTCC->PZSTARGP.data[counter]; + break; + } + } + + if (tlitab == NULL) + { + //Error + out.ErrorIndicator = 5; + return; + } + T_MRS_SIVB = tlitab->T2[MEDQuantities.Opportunity - 1] / 3600.0; + switch (MEDQuantities.Mode) { + case 1: + Option1(); + break; case 2: Option2_5(true); break; @@ -747,6 +773,81 @@ void TLIProcessor::Main(TLIOutputData &out) out.sv_TLI_cut = outarray.sv_tli_cut; } +void TLIProcessor::Option1() +{ + PMMSPTInput in; + + in.QUEID = 34; + in.GMT = MEDQuantities.state.GMT; + in.R = MEDQuantities.state.R; + in.V = MEDQuantities.state.V; + in.Table = MEDQuantities.mpt; + in.InjOpp = MEDQuantities.Opportunity; + in.mpt = NULL; + in.CurMan = NULL; + + int err = pRTCC->PMMSPT(in); + + if (err) + { + ErrorIndicator = 1; + return; + } + //Data is now in PZTTLIPL + + //Propagate state to TIG + EMSMISSInputTable emsin; + + emsin.AnchorVector.R = pRTCC->PZTTLIPL.R; + emsin.AnchorVector.V = pRTCC->PZTTLIPL.V; + emsin.AnchorVector.GMT = pRTCC->PZTTLIPL.TB6; + emsin.AnchorVector.RBI = BODY_EARTH; + + emsin.MaxIntegTime = pRTCC->PZTTLIPL.TIG - emsin.AnchorVector.GMT; + emsin.VehicleCode = MEDQuantities.mpt; + emsin.useInputWeights = true; + emsin.WeightsTable = &MEDQuantities.WeightsTable; + + pRTCC->EMSMISS(&emsin); + + if (emsin.NIAuxOutputTable.ErrorCode) + { + ErrorIndicator = 1; + return; + } + + + + std::vector var, arr; + var.resize(20); + arr.resize(20); + + var[4] = pRTCC->PZTTLIPL.C3 / pow(R_E / 3600.0, 2); + var[5] = 0.0; + + VECTOR3 N_I; + + N_I = unit(crossp(pRTCC->PZTTLIPL.R, pRTCC->PZTTLIPL.V)); + + var[6] = asin(dotp(pRTCC->PZTTLIPL.T, N_I)); + + void *constPtr; + + outarray.TLIIndicator = true; + outarray.EllipticalCaseIndicator = false; + outarray.TLIOnlyIndicator = true; + + outarray.sv0.R = pRTCC->PZTTLIPL.R; + outarray.sv0.V = pRTCC->PZTTLIPL.V; + outarray.sv0.GMT = pRTCC->PZTTLIPL.TIG; + outarray.sv0.RBI = BODY_EARTH; + outarray.M_i = MEDQuantities.WeightsTable.ConfigWeight; + outarray.sigma_TLI = pRTCC->PZTTLIPL.sigma; + constPtr = &outarray; + + IntegratedTrajectoryComputer(var, constPtr, arr, false); +} + //Hybrid ellipse void TLIProcessor::Option3() { diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.h b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.h index e59e7607d0..64fefadadf 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.h +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.h @@ -116,11 +116,15 @@ class TLIFirstGuess : public RTCCModule struct TLIMEDQuantities { + //1 = CSM, 3 = LEM + int mpt; + //1 = S-IVB hypersurface solution, 2 = integrated free-return, 3 = hybrid ellipse, 4 = E-type mission ellipse, 5 = non-free return int Mode; EphemerisData state; PLAWDTOutput WeightsTable; double GMT_TIG; //TIG or estimated TIG + int Opportunity; //1 or 2 //Mode 2/5 int IPOA; //1 = Pacific window (AZ2V <= 90°), 2 = Atlantic window (AZ2V > 90°), for first guess logic @@ -164,6 +168,8 @@ class TLIProcessor : public TLTrajectoryComputers void Main(TLIOutputData &out); void Init(TLIMEDQuantities med, TLMCCMissionConstants constants, double GMTBase); protected: + //Hypersurface + void Option1(); //Free return or non-free return void Option2_5(bool freereturn); //Hybrid ellipse diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLTrajectoryComputers.h b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLTrajectoryComputers.h index e08fa8f751..ec71a6ca30 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLTrajectoryComputers.h +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLTrajectoryComputers.h @@ -219,7 +219,7 @@ class TLTrajectoryComputers : public RTCCModule double F_I_SIVB; //S-IVB thrust magnitude from ignition to MRS double F_SIVB; //S-IVB thrust magnitude from MRS to cutoff double WDOT_SIVB; //Mass flow rate of S-IVB - double T_MRS_SIVB; //TEstimated time of MRS, measured from ignition + double T_MRS_SIVB; //Estimated time of MRS, measured from ignition double gamma_reentry; double Reentry_dt; }; \ No newline at end of file diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/rtcc_library_programs.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/rtcc_library_programs.cpp index 421abe0406..71da259d3d 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/rtcc_library_programs.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/rtcc_library_programs.cpp @@ -2037,6 +2037,14 @@ void RTCC::PLAWDT(const PLAWDTInput &in, PLAWDTOutput &out) RTCC_PLAWDT_9_T: out.Err = 3; //Move areas and weights to output + out.CSMArea = in.CSMArea; + out.SIVBArea = in.SIVBArea; + out.LMAscArea = in.LMAscArea; + out.LMDscArea = in.LMDscArea; + out.CSMWeight = in.CSMWeight; + out.SIVBWeight = in.SIVBWeight; + out.LMAscWeight = in.LMAscWeight; + out.LMDscWeight = in.LMDscWeight; goto RTCC_PLAWDT_M_5; } From 6cfccbe42c9037c49ee11851cb4758566ac4d5a9 Mon Sep 17 00:00:00 2001 From: indy91 Date: Mon, 23 Sep 2024 19:29:23 +0200 Subject: [PATCH 4/5] TLI processor option 1 working; transfer to MPT as well --- .../samples/ProjectApollo/src_launch/rtcc.cpp | 22 ++++++++- .../src_rtccmfd/ApolloRTCCMFD.cpp | 2 +- .../src_rtccmfd/ApolloRTCCMFD_Display.cpp | 13 +++-- .../src_rtccmfd/TLIProcessor.cpp | 49 +++++++------------ 4 files changed, 48 insertions(+), 38 deletions(-) diff --git a/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.cpp b/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.cpp index c55276cd16..8e67d97af9 100644 --- a/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_launch/rtcc.cpp @@ -8697,8 +8697,10 @@ int RTCC::PMMSPT(PMMSPTInput &in) RR = dotp(R, R); COSB = cos(beta); SINB = sin(beta); + //T_RP input? if (OrigTLIInd < 0) { + //Yes goto RTCC_PMMSPT_13_2; } alpha_TS = alpha_TSS + tlitab->K_a1*dt4_apo + tlitab->K_a2*dt4_apo*dt4_apo; @@ -19237,14 +19239,30 @@ void RTCC::PMSVCT(int QUEID, int L, StateVectorTableEntry sv0) //Page 7 //DTREAD MPT Header RTCC_PMSVCT_8: - bool tli = false; for (unsigned i = 0;i < mpt->mantable.size();i++) { if (mpt->mantable[i].AttitudeCode == RTCC_ATTITUDE_SIVB_IGM || mpt->mantable[i].AttitudeCode == RTCC_ATTITUDE_PGNS_DESCENT) { if (mpt->mantable[i].GMTMAN > sv0.Vector.GMT) { - if (mpt->mantable[i].FrozenManeuverInd == false) + //Iterable? + int temp; + if (mpt->mantable[i].FrozenManeuverInd) + { + temp = false; + } + else + { + if (mpt->mantable[i].AttitudeCode == RTCC_ATTITUDE_SIVB_IGM) + { + temp = mpt->mantable[i].Word78i[1] != 0; + } + else + { + temp = true; + } + } + if (temp) { //EMSMISS and PMMSPT for TLI/PDI EMSMISSInputTable intab; diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.cpp index 06812fef71..b510d89afb 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD.cpp @@ -7241,7 +7241,7 @@ void ApolloRTCCMFD::menuSetTLIProcessorInput() } else { - GC->rtcc->PZTLIPLN.Mode = 2; + GC->rtcc->PZTLIPLN.Mode = 1; } break; case 5: diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD_Display.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD_Display.cpp index 71f70f5c05..a0f8814554 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD_Display.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/ApolloRTCCMFD_Display.cpp @@ -7156,10 +7156,13 @@ bool ApolloRTCCMFD::Update(oapi::Sketchpad *skp) skp->Text(5 * W / 22, 7 * H / 22, "Hypersurface", 12); break; } - - skp->Text(1 * W / 22, 8 * H / 22, "TIG:", 4); - GET_Display(Buffer, GC->rtcc->PZTLIPLN.GET_TLI, false); - skp->Text(5 * W / 22, 8 * H / 22, Buffer, strlen(Buffer)); + + if (GC->rtcc->PZTLIPLN.Mode != 1) + { + skp->Text(1 * W / 22, 8 * H / 22, "TIG:", 4); + GET_Display(Buffer, GC->rtcc->PZTLIPLN.GET_TLI, false); + skp->Text(5 * W / 22, 8 * H / 22, Buffer, strlen(Buffer)); + } if (GC->rtcc->PZTLIPLN.Mode == 3) { @@ -7174,7 +7177,7 @@ bool ApolloRTCCMFD::Update(oapi::Sketchpad *skp) sprintf_s(Buffer, "%.0lf NM", GC->rtcc->PZTLIPLN.h_ap); skp->Text(5 * W / 22, 9 * H / 22, Buffer, strlen(Buffer)); } - else + else if (GC->rtcc->PZTLIPLN.Mode == 2 || GC->rtcc->PZTLIPLN.Mode == 5) { skp->Text(1 * W / 22, 9 * H / 22, "Window:", 7); diff --git a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.cpp b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.cpp index f0347fdabe..2b232e09fa 100644 --- a/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.cpp +++ b/Orbitersdk/samples/ProjectApollo/src_rtccmfd/TLIProcessor.cpp @@ -737,36 +737,28 @@ void TLIProcessor::Main(TLIOutputData &out) if (out.ErrorIndicator) return; //Convert to LVDC parameters - if (MEDQuantities.Mode != 1) - { - //7 parameters - //Convert to ECT at GRR + //Convert to ECT at GRR - EphemerisData2 sv, sv_ECT; + EphemerisData2 sv, sv_ECT; - sv.R = outarray.sv_tli_cut.R; - sv.V = outarray.sv_tli_cut.V; - sv.GMT = pRTCC->SystemParameters.MCGRIC*3600.0; - pRTCC->ELVCNV(sv, 0, 1, sv_ECT); + sv.R = outarray.sv_tli_cut.R; + sv.V = outarray.sv_tli_cut.V; + sv.GMT = pRTCC->SystemParameters.MCGRIC*3600.0; + pRTCC->ELVCNV(sv, 0, 1, sv_ECT); - OELEMENTS coe = OrbMech::coe_from_sv(sv_ECT.R, sv_ECT.V, mu_E); - coe.h = dotp(sv_ECT.V, sv_ECT.V) - 2.0*mu_E / length(sv_ECT.R); + OELEMENTS coe = OrbMech::coe_from_sv(sv_ECT.R, sv_ECT.V, mu_E); + coe.h = dotp(sv_ECT.V, sv_ECT.V) - 2.0*mu_E / length(sv_ECT.R); - OELEMENTS coe2 = LVTAR(coe, pRTCC->SystemParameters.MCLGRA, pRTCC->SystemParameters.MCERTS*pRTCC->SystemParameters.MCGRIC); + OELEMENTS coe2 = LVTAR(coe, pRTCC->SystemParameters.MCLGRA, pRTCC->SystemParameters.MCERTS*pRTCC->SystemParameters.MCGRIC); - out.uplink_data.Inclination = coe2.i; - out.uplink_data.theta_N = coe2.RA; - out.uplink_data.e = coe2.e; - out.uplink_data.C3 = coe2.h; - out.uplink_data.alpha_D = coe2.w; - out.uplink_data.f = coe2.TA; - out.uplink_data.GMT_TIG = outarray.sv_tli_ign.GMT; - } - else - { - //10 parameters - } + out.uplink_data.Inclination = coe2.i; + out.uplink_data.theta_N = coe2.RA; + out.uplink_data.e = coe2.e; + out.uplink_data.C3 = coe2.h; + out.uplink_data.alpha_D = coe2.w; + out.uplink_data.f = coe2.TA; + out.uplink_data.GMT_TIG = outarray.sv_tli_ign.GMT; out.dv_TLI = outarray.dv_TLI; out.sv_TLI_ign = outarray.sv_tli_ign; @@ -816,19 +808,16 @@ void TLIProcessor::Option1() return; } - - std::vector var, arr; var.resize(20); arr.resize(20); - var[4] = pRTCC->PZTTLIPL.C3 / pow(R_E / 3600.0, 2); - var[5] = 0.0; + var[4] = pRTCC->PZTTLIPL.C3 / pow(R_E / 3600.0, 2); //C3 in Er^2/hr^2 + var[5] = 0.0; //dt_EPO + //Calculate delta VECTOR3 N_I; - N_I = unit(crossp(pRTCC->PZTTLIPL.R, pRTCC->PZTTLIPL.V)); - var[6] = asin(dotp(pRTCC->PZTTLIPL.T, N_I)); void *constPtr; From e49445c5ef4d93e1e1ee29ac6952fd78b7464af9 Mon Sep 17 00:00:00 2001 From: indy91 Date: Tue, 24 Sep 2024 19:24:08 +0200 Subject: [PATCH 5/5] Update RTCC MFD manual for TLI processor; add error messages to the online monitor and check if the SFP is valid for the calculation --- .../RTCC/ApolloRTCCMFD.pdf | Bin 1068216 -> 1096199 bytes .../RTCC/ApolloRTCCMFD.tex | 48 ++++++++++- .../samples/ProjectApollo/src_launch/rtcc.cpp | 75 ++++++++++++++---- .../samples/ProjectApollo/src_launch/rtcc.h | 2 + .../src_rtccmfd/ApolloRTCCMFD_Display.cpp | 52 +++++------- 5 files changed, 130 insertions(+), 47 deletions(-) diff --git a/Doc/Project Apollo - NASSP/RTCC/ApolloRTCCMFD.pdf b/Doc/Project Apollo - NASSP/RTCC/ApolloRTCCMFD.pdf index eb0b689ab03688dea46a09e27fbca8f60ed1f7de..488062b065ffebea77509ddef2a281f6e546935a 100644 GIT binary patch delta 166951 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 z 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