VcstCmnGeo.h

Go to the documentation of this file.

/******************************************************************************
 *  NAME: VcstCmnGeo.h
 *
 *  DESCRIPTION: Object class that serves as the intermediary between the NASA
 *  L1A file format and the IDPS Common Geolocation interfaces. It reads L1A
 *  navigation data and stores it into lists of spacecraft diary records
 *  compatible with the VcstCmnGeo object class.  It initializes common
 *  geolocation for use by other functions.
 *
 *  Created on: December 15, 2014
 *      Author: Sam Anderson, VCST
 *
 ******************************************************************************/
 
#ifndef VcstCmnGeo_H_
#define VcstCmnGeo_H_
 
#include <cmath>
#include <novas.h>
#include <VcstTime.h>
#include <VcstCmnGeoStructs.h>
#include <VcstCmnLutInputItem.h>
 
#include <hdf5.h>
#include <netcdf>
 
using namespace std;
using namespace netCDF;
using namespace netCDF::exceptions;
 
struct viirsCmnLutPtrs {
    // Pointers to LUT data structures
    InstrumentLutType* scDataLut;
    CmnGeoPolarUT1Type* pwUT1Ptr;
    JPLEphemLutType* jplEphemPtr;
    SAALutType* saaCoeff;
    CmnGeoParamLutType* paramLut;
    proSdrViirsCalQALUT* QALUT;
};
 
// Structure of LUT pointers used by Common Geolocation
 
class VcstCmnGeo {
public:
 
    // numeric constants
    static constexpr double MSECPERDAY = 86400000000.0; //24*60*60=86400 million
    static constexpr double TAI93_TAI58_SEC = 1104537627.0;
    static constexpr double RAD_TO_DEG = 180.0 / M_PI;
 
    static const std::string SN_APID_0; // = "CRITICAL";
    static const std::string SN_APID_8; // = "ADCS_HKH";
    static constexpr int ADSTATE_BYTE = 169;
    static constexpr int ADSTATE_BITS = 3;
    static constexpr int ADSTATE_NUM_OF_BITS = 3;
    static constexpr int ADMANDONE_BYTE = 255;
    static constexpr int ADMANDONE_BIT = 7;
    static constexpr int ADFFTID_BYTE = 339;
    static constexpr int SCAN_ALL = -1;
 
    static constexpr bool MEAN_SID = true; // Flag for getting Mean Sidereal Time.
    static constexpr bool APP_SID = false; // Flag for getting Apparent Sidereal Time.
 
    std::string platform_;
 
    int act_scans_;
    int sc_diary_records_;
 
    int scan_number_[VIIRS_SCANS];
    unsigned char ham_side_[VIIRS_SCANS];
    unsigned char sensor_mode_[VIIRS_SCANS];
    unsigned char se_a_anlg_pwr_on_[VIIRS_SCANS];
    unsigned char se_b_anlg_pwr_on_[VIIRS_SCANS];
    unsigned char dp_servo_in_use_[VIIRS_SCANS];
    unsigned char se_a_tele_pos_known_[VIIRS_SCANS];
    unsigned char se_b_tele_pos_known_[VIIRS_SCANS];
    unsigned char se_a_mtrs_stopped_[VIIRS_SCANS];
    unsigned char se_b_mtrs_stopped_[VIIRS_SCANS];
    unsigned char encoderFlag_[VIIRS_SCANS];
    unsigned char es_se_a_teleham_scansyn_[VIIRS_SCANS];
    unsigned char es_se_b_teleham_scansyn_[VIIRS_SCANS];
    unsigned char cp_blk_pwr_sel_[VIIRS_SCANS];
    unsigned char dp_nonrdt_fpie_pwr_[VIIRS_SCANS];
    unsigned short ham_start_enc_[VIIRS_SCANS];
    unsigned short tel_start_enc_[VIIRS_SCANS];
 
    unsigned short ham_encoder_[VIIRS_SCANS][Encoder_Reading];
    unsigned short tel_encoder_[VIIRS_SCANS][Encoder_Reading];
 
    short electronics_side_[VIIRS_SCANS];
    bool scan_sync_failure_[VIIRS_SCANS];
    bool tel_start_not_nominal_[VIIRS_SCANS];
    bool sensor_not_nominal_[VIIRS_SCANS];
    bool scan_data_missing_[VIIRS_SCANS];
    short scan_sync_failure_cnt_;
    int scanSyncFailCt_;
 
    double start_TAI93sec_[VIIRS_SCANS];
    double end_TAI93sec_[VIIRS_SCANS];
    double ev_mid_TAI93sec_[VIIRS_SCANS];
    double sv_mid_TAI93sec_[VIIRS_SCANS];
    double bb_mid_TAI93sec_[VIIRS_SCANS];
    double sd_mid_TAI93sec_[VIIRS_SCANS];
 
    double start_TAI58sec_[VIIRS_SCANS];
    double end_TAI58sec_[VIIRS_SCANS];
    double mid_TAI58sec_[VIIRS_SCANS];
    double midGranTAI58sec_;
 
    float sc_solar_zenith_[VIIRS_SCANS];
    float sc_solar_azimuth_[VIIRS_SCANS];
 
    float solar_zenith_[VIIRS_SCANS];
    float solar_azimuth_[VIIRS_SCANS];
    float earth_sun_distance_[VIIRS_SCANS];
    float solar_j2000_[VIIRS_SCANS][VEC_SIZE];
    float solar_inst_[VIIRS_SCANS][VEC_SIZE];
 
    float att_quat_ev_[VIIRS_SCANS][QUAT_SIZE];
    float att_ang_[VIIRS_SCANS][VEC_SIZE];
    float orb_pos_ev_[VIIRS_SCANS][VEC_SIZE];
    float orb_vel_ev_[VIIRS_SCANS][VEC_SIZE];
 
    float att_quat_sd_[VIIRS_SCANS][QUAT_SIZE];
    float orb_pos_sd_[VIIRS_SCANS][VEC_SIZE];
    float orb_vel_sd_[VIIRS_SCANS][VEC_SIZE];
 
    float earth_moon_distance_[VIIRS_SCANS];
    float lunar_j2000_[VIIRS_SCANS][VEC_SIZE];
    float lunar_inst_[VIIRS_SCANS][VEC_SIZE];
    bool moon_in_sv_kob_[VCST_BANDS][VIIRS_SCANS];
 
    double earth_sun_distance_avg_;
 
    // Pointer to structure of LUT pointer
 
    viirsCmnLutPtrs pLut_;
    /*
     *  Constructor
     */
 
    VcstCmnGeo();
 
    /*
     *  Destructor
     */
 
    ~VcstCmnGeo();
 
    int initialize(GRAN_SEQ_ENUM gran_seq);
 
    static const std::string getManeuverStr(const BusCritTlmType * busCritTlm,
            const AdcsHskTlmType * adcsHskTlm);
 
    int satPosAtt(const double inTAI, CmnGeoEAPointType& outPt,
            bool performOrbitCheck = false);
 
    int vectorAtSat(const CmnGeoEAPointType& inPt, const int vecFlag,
            double vecSat[VEC_SIZE]);
 
    void calcSatAzmZen(const double inDLat, const double inLon,
            const double inSamp2Sat[VEC_SIZE], double& outSatAzm,
            double& outSatZen);
 
    int ellipIntersect(const CmnGeoEAPointType& inPt,
            const double inRotMat[VEC_SIZE][VEC_SIZE],
            const double viewVec[VEC_SIZE], double& dLat, double& lon,
            double& satAzm, double& satZen, double& range);
 
    int sunMoonAngles(const double inTAI, const double inLat,
            const double inLon, const int smFlag, double& sunAzm,
            double& sunZen, double& moonAzm, double& moonZen, double& moonPhase,
            double& moonIFrac);
 
    int sunAngles(const double inTAI, const float inLat, const float inLon,
            float& sunAzm, float& sunZen);
 
    int sunAngles(const double inTAI, const double inLat, const double inLon,
            double& sunAzm, double& sunZen);
 
    int moonAngles(const double inTAI, const float inLat, const float inLon,
            float& moonAzm, float& moonZen, float& moonPhase, float& moonIFrac);
 
    int getSAAIntensity(const float inLat, const float inLon,
            float& outIntensity);
 
    int checkSolarEclipse(const double inTAI, const double inLat,
            const double inLon, bool& outEclipseOccurring);
 
    int writeNavigation();
 
    int writeCmnGeo();
 
 
private:
 
    CmnGeoScEAType ephemAtt_;
    CmnGeoEAPointType sdPoint_[VIIRS_SCANS];
    CmnGeoEAPointType evPoint_[VIIRS_SCANS];
    CmnGeoEphAttType ephatt_;
 
    site_info locPixel_;
    body sun_;
    body earth_;
    body moon_;
 
    VcstTime* timeAPI_;
    polarWanderDataType *polarWanderDataPtr_;
 
    // Map to store LUT input item objects.
 
    std::map<std::string, VcstLutInputItem*> cmnGeoLutItems_;
 
    int dbgMsgThrottle_;
 
    int initialize_novas();
 
    int initialize_LUT_data();
 
    int initialize_L1A_data(GRAN_SEQ_ENUM gran_seq);
 
    int Check_Tel_Start_Not_Nominal();
 
    int check_scan_sync();
 
    int setPolarWander(const double a_tai);
 
    int setupEphAtt(const CmnGeoScEAType * const sceaPtr);
 
    int initPointsMap(const CmnGeoScEAType* inPtr);
 
    int fillEphAttPoint(CmnGeoEAPointType& pntNode);
 
    int quadraticInterpEph(const CmnGeoEAPointType* firstPt,
            const CmnGeoEAPointType* secondPt, const CmnGeoEAPointType* thirdPt,
            CmnGeoEAPointType* outputPt);
 
    int convCoordSys(const double inTAI, const double inPos[VEC_SIZE],
            const double inVel[VEC_SIZE], const int convFlag,
            double outPos[VEC_SIZE], double outVel[VEC_SIZE]);
 
    void convVec2LatLon(const double inVec[VEC_SIZE], double& dLat,
            double& cLat, double& lon);
 
    void calculateAccel(CmnGeoEAPointType& pntNode);
 
    void buildQuatMatrix(const double Qw, const double Qi, const double Qj,
            const double Qk, double qMat2eci[VEC_SIZE][VEC_SIZE]);
 
    int buildECIOrbFrame(const CmnGeoEAPointType& inPt,
            double outOrb[VEC_SIZE][VEC_SIZE]);
 
    int calcGDRollPitchYaw(CmnGeoEAPointType& pntNode);
 
    int getPolarUT1UTC(const double inTAI, double& outTDTmUT1,
            double& outUT1mUTC, double& outXWander, double& outYWander,
            double& outTJD, bool bForceCalc = false) const;
 
    int appSiderealTime(const double inTAI, const bool getmean, double& gast,
            double& xWander, double& yWander, double& tjd);
 
    double earth_radius_C(double rlat);
 
    double earth_radius_D(double rlat);
 
    void invPNSW(const double inTDT, const double gast, const double Xpole,
            const double Ypole, double eciVect[VEC_SIZE],
            double ecfVect[VEC_SIZE]);
 
    void invWobble(const double x, const double y, const double rotEq[VEC_SIZE],
            double geoEq[VEC_SIZE]);
 
    int computeSolarVectors();
 
    int computeLunarVectors();
 
    int computeEarthViewVectors();
 
    int check_moon_in_sv();
 
    inline bool validLat(const double inLat) {
        return ((inLat < -PIO2) || (inLat > PIO2) || std::isnan(inLat)) ?
                false : true;
    }
 
    inline bool validLon(const double inLon) {
        return ((inLon < (-PI)) || (inLon > PI) || std::isnan(inLon)) ? false : true;
    }
 
    short convert14To16bit(short value14bit);
 
    bool isPlatformLittleEndian();
 
};
 
#endif /* VcstCmnGeo_H_ */