SpacecraftPosition.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "SpacecraftPosition.h"
 
#include <cfloat>
#include <iomanip>
 
#include <QVector>
 
#include "Constants.h"
#include "Distance.h"
#include "EndianSwapper.h"
#include "FileName.h"
#include "IException.h"
#include "IString.h"
#include "iTime.h"
#include "Longitude.h"
#include "NaifStatus.h"
 
using namespace std;
 
namespace Isis {
 
  SpacecraftPosition::SpacecraftPosition(int targetCode, int observerCode,
                                         const LightTimeCorrectionState &ltState,
                                         const Distance &radius) : 
                                         SpicePosition(targetCode, observerCode,
                                                       ltState.isObserverTargetSwapped()) { 
    m_abcorr = ltState;
    m_radius = radius;
    return;
  }
 
 
 
  double SpacecraftPosition::getRadiusLightTime() const {
    return (m_radius.kilometers()/clight_c());
  }
 
  double SpacecraftPosition::getDistanceLightTime(const Distance &distance) {
    return (distance.kilometers()/clight_c());
  }
 
 
  void SpacecraftPosition::SetAberrationCorrection(const QString &correction) {
    SpicePosition::SetAberrationCorrection(correction);  // Checks for validity
    m_abcorr.setAberrationCorrection(correction);
  }
 
 
  QString SpacecraftPosition::GetAberrationCorrection() const {
    return (m_abcorr.getAberrationCorrection());
  }
 
  void SpacecraftPosition::SetEphemerisTimeSpice() {
 
    // Both light time correction and surface light time correction *must* be requested
    // in order to invoke the algorithm below, otherwise we can call the pre-existing
    // implementation as it handles swap and light time adjustments as requested. 
    // The algorithm below only additionally handles light time surface correction.
    if ( !(m_abcorr.isLightTimeCorrected() && m_abcorr.isLightTimeToSurfaceCorrected()) ) {
      SpicePosition::SetEphemerisTimeSpice();
      return;
    }
 
    //  Proceed with applying light time corrections to surface.  The
    //  steps to make this more accurate is as follows:
    // 
    //  1)  Compute vector from observer to target to acquire the light
    //      time correction (in seconds)
    // 
    //  2)  Acquire the vector from the solar system barycenter (SSB) to
    //      the spacecraft at the specified time.
    // 
    //  3)  Acquire the vector from the SSB to the target less the light
    //      time from 1) adding back in the time it takes for light to
    //      travel the radius of the target.
    // 
    //  4)  Compute the vector state of the target from the observer
    //      buy subtracting the result of 2) from 3).
 
    SpiceDouble state[6], lt;
    bool hasVelocity;
    const SpiceInt ssbCode(0);
 
    //  1)  get observer/target light time
    computeStateVector(getAdjustedEphemerisTime(), getTargetCode(), getObserverCode(),
                       "J2000", GetAberrationCorrection(), state, hasVelocity, lt);
 
    //  2)  get SSB to s/c
    SpiceDouble ssbObs[6], ssbObs_lt;
    bool dummy;
    computeStateVector(getAdjustedEphemerisTime(), getObserverCode(), ssbCode,
                       "J2000", "NONE", ssbObs, dummy, ssbObs_lt);
 
    // 3) get adjusted target position from SSB
    double ltAdj_et = getAdjustedEphemerisTime() - lt + getRadiusLightTime();
    SpiceDouble ssbTarg[6], ssbTarg_lt;
    computeStateVector(ltAdj_et, getTargetCode(), ssbCode,
                       "J2000", "NONE", ssbTarg, dummy, ssbTarg_lt);
 
    // 4) compute target to observer
    (void) vsubg_c(ssbTarg, ssbObs, 6, state);
 
    // Store vector and light time correction results
    setStateVector(state, hasVelocity);
    setLightTime(ltAdj_et);
    return;
  }
 
 
  const LightTimeCorrectionState &SpacecraftPosition::getLightTimeState() const {
    return (m_abcorr);
  }
 
 
}  // namespace Isis