/disk01/web/ocssw/build/src/geogen_modis/GEO_validate_orbit_data.c (r8218/r3)

Go to the documentation of this file.

/* file: GEO_validate_orbit_data.c */

#include "PGS_MODIS_35251.h"
#include "GEO_util.h"
#include "GEO_validation.h"
#include "smfio.h"

int GEO_validate_orbit_data(
    int const number_of_scans, 
    double sc_position[MAX_SCAN_NUMBER*2][3],
    double sc_velocity[MAX_SCAN_NUMBER*2][3], 
    double time_stamp[MAX_SCAN_NUMBER*2],
    int ancil_flags[MAX_SCAN_NUMBER*2]
    )
{
/*
!C*****************************************************************************
!Description:   
        Routine in Validation group of the Level-1A geolocation
                software to validate the orbit data.  Validation is performed
        using the algorithms described in the white paper by F. Patt, 
        June 15, 1995.  Checks performed consist of:  absolute limit
        check on individual position and velocity components; limit 
        check on magnitudes of position and velocity vectors; sanity
        check on angular momentum magnitude and Z component; and 
        consistency check of successive position and velocity values
        for each component.

!Input Parameters:
                int number_of_scans - the number of scans
        double sc_position[MAX_SCAN_NUMBER*2][3] - position data
        double sc_velocity[MAX_SCAN_NUMBER*2][3] - velocity data
        double time_stamp[MAX_SCAN_NUMBER*2] - ancillary time stamp
        int ancil_flags[MAX_SCAN_NUMBER*2] - ancillary data flags
            
!Output Parameters:
        int ancil_flags[MAX_SCAN_NUMBER*2] - ancillary data flags

Return parameter:
                int err_stat - error status

Global variables:
        double position_abs_limit[2] - position absolute limits
        double velocity_abs_limit[2] - velocity absolute limits
        double position_mag_limit[2] - position magnitude limits
        double velocity_mag_limit[2] - velocity magnitude limits
        double ang_mom_limit[2] - angular momentum magnitude limits
        double ang_mom_z_limit[2] - angular momentum Z component limits
        double orbit_consistency - orbit position/velocity consistency
          limit

Call functions:
        int GEO_abs_limit_check(double, int, double, int)
        int GEO_find_next_flag(int, int, int)
        int GEO_vec_mul3(double, double, double)
        GEO_vec_length3(double, double, double)
                modsmf(MODIS_X_MNEMONIC_STRING, "user message string", "function,
                GEO_validate_orbit_data.c") - writes error status messages to log

!Revision History:
        $Log: GEO_validate_orbit_data.c,v $
        Revision 1.8  1997/07/21 16:24:34  kuyper
        Baselined Version 1

 * Revision 1.8  1997/03/26  18:16:22  fhliang
 * Initial revision of SDST delivery of GEO_validate_orbit_data.c.
 *
        Revision 1.7  1997/01/19 23:52:52  kuyper
        Merged seed files.

        Revision 1.6  1996/12/16 22:03:24  kuyper
        Initialized lflags twice, to satisfy pr:qa.

        Revision 1.5  1996/08/29 20:22:14  kuyper
        Corrected initialization of lflags.

        Revision 1.4  1996/07/29 15:41:57  kuyper
        Use GOOD_DATA/BAD_DATA for flags, rather than SUCCESS/FAIL-values unchanged.

        Revision 1.3  1996/07/24  21:44:29  kuyper
        Standardized order of #include files.
        Declared arguments const.
        Inserted required '!'s in comments.
        Removed ret_val.
        Change j1,j2 to f1,f2, to avoid shadowing.
        Converted constants to double, to skip implied conversion.
        Corrected final check on num_valid.

        Revision 1.2  1996/07/18 21:23:04  kuyper
        Included self-checking header file.
        Replaced extern declarations with corresponding header files.
        Quick fix to GEO_abs_limit_check parameter mismatch; proper fix requires
        re-write of that function.


        6/19/95
        Frederick S. Patt (patt@modis-xl.gsfc.nasa.gov)
        Finished coding.

        7/3/95
        Tracey W. Holmes (holmes@modis-xl.gsfc.nasa.gov)
        Added SDP error messages.

        10/10/95
        Tracey W. Holmes
        Added DEBUG option.

!Team-unique Header:
                This software is developed by the MODIS Science Data Support
                Team for the National Aeronautics and Space Administration,
                Goddard Space Flight Center, under contract NAS5-32373.

!END*************************************************************************
*/

/* Local variable declarations */

  int i = 0; /* loop index */
  int j = 0; /* loop index */
  int f1 = 0; /* valid data index */
  int f2 = 0; /* valid data index */
  int num_samples = 0; /* number of samples */
  int num_valid = 0; /* number of valid samples */
  int valid = FALSE; /* valid pair found flag */
  double del = 0.0; /* orbit consistency measurement */
  int lflags[MAX_SCAN_NUMBER*2][3]={0}; /* local flag array */ 
  double pos_mag[MAX_SCAN_NUMBER*2]; /* position magnitude array */
  double vel_mag[MAX_SCAN_NUMBER*2]; /* velocity magnitude array */
  double ang_mom[3]; /* angular momentum vector */
  double ang_mom_mag[MAX_SCAN_NUMBER*2];/* angular momentum magnitude */
  double ang_mom_z[MAX_SCAN_NUMBER*2];/* angular momentum Z component */

  for(i=0; i<MAX_SCAN_NUMBER*2; i++)
  {
    for(j=0; j<3; j++)
      lflags[i][j] = GOOD_DATA;
  }

  /* Begin program logic */
  num_samples = number_of_scans * 2;

  /* Position absolute limit check */
  if (GEO_abs_limit_check(sc_position[0], num_samples*3, position_abs_limit,
      lflags[0]) == FAIL) {
    /* call SDP function to report error */
    modsmf(MODIS_E_NO_VAL_POS_SAMP, "",
    "GEO_abs_limit_check, GEO_validate_orbit_data.c");

    return FAIL;
  }

  /* Velocity absolute limit check */
  if (GEO_abs_limit_check(sc_velocity[0], num_samples*3, velocity_abs_limit,
      lflags[0]) == FAIL) {
    /* call SDP function to report error */
    modsmf(MODIS_E_NO_VAL_VEL_SAMP, "",
    "GEO_abs_limit_check, GEO_validate_orbit_data.c");

    return FAIL;
  }

  /* Transfer flags to output array */
  for (i = 0; i < num_samples; i++)
    if ((lflags[i][0] == BAD_DATA) || (lflags[i][1] == BAD_DATA) ||  
      (lflags[i][2] == BAD_DATA))
    ancil_flags[i] = BAD_DATA;


  /* Vector magnitude limit checks */
  for (i = 0; i < num_samples; i++) {
    GEO_vec_length3(sc_position[i], &pos_mag[i]);
    GEO_vec_length3(sc_velocity[i], &vel_mag[i]);
  }
  
  /* Position magnitude */
  if (GEO_abs_limit_check(pos_mag, num_samples, position_mag_limit, ancil_flags)
      == FAIL) {
    /* call SDP function to report error */
    modsmf(MODIS_E_NO_VAL_POS_SAMP, "",
    "GEO_abs_limit_check, GEO_validate_orbit_data.c");

    return FAIL;
  }

  /* Velocity magnitude */
  if (GEO_abs_limit_check(vel_mag, num_samples, velocity_mag_limit, ancil_flags)
      == FAIL) {
    /* call SDP function to report error */
    modsmf(MODIS_E_NO_VAL_VEL_SAMP, "",
    "GEO_abs_limit_check, GEO_validate_orbit_data.c");

    return FAIL;
  }

  /* Angular momentum sanity check */
  for (i = 0; i < num_samples; i++) {
    GEO_vec_mul3(sc_position[i], sc_velocity[i], ang_mom);
    GEO_vec_length3(ang_mom, &ang_mom_mag[i]);
    ang_mom_z[i] = ang_mom[2];
  }

  if (GEO_abs_limit_check(ang_mom_mag, num_samples, ang_mom_limit, ancil_flags)
      == FAIL) {
    /* call SDP function to report error */
    modsmf(MODIS_E_NO_VAL_ORB_SAMP, "",
    "GEO_abs_limit_check, GEO_validate_orbit_data.c");
    
    return FAIL;
  }

  if (GEO_abs_limit_check(ang_mom_z, num_samples, ang_mom_z_limit, ancil_flags)
      == FAIL) {
    /* call SDP function to report error */
    modsmf(MODIS_E_NO_VAL_ORB_SAMP, "",
    "GEO_abs_limit_check, GEO_validate_orbit_data.c");
    
    return FAIL;
  }
  /* End of angular momentum sanity check */

  /* Position/velocity consistency check */
  /* Loop through x, y, z */
  for (j = 0; j < 3; j++) {
   
    /* Check for at least two unflagged samples */
    f1 = GEO_find_next_flag(ancil_flags, num_samples, 0);  
    if ((f2 = GEO_find_next_flag(ancil_flags, num_samples, f1+1))
    == FAIL) {
      /* call SDP function to report error */
      modsmf(MODIS_E_ONE_UNFLAG, "",
      "GEO_find_next_flag, GEO_validate_orbit_data.c");

      return SUCCESS;
    }

  
    /* Check all unflagged samples */
    valid = FALSE;
    num_valid = 0;
    while (f2 != FAIL) {

      /* First find a valid pair */
      while ((f2 != FAIL) && (valid == FALSE)) {

    /* Compute position/velocity consistency difference */
    del = fabs(sc_position[f2][j] - sc_position[f1][j] - 
           (sc_velocity[f2][j] + sc_velocity[f1][j])*
           (time_stamp[f2] - time_stamp[f1])/2.0);
    if (del <= orbit_consistency) {
      num_valid += 2;
      valid = TRUE;
    }
    else {
      ancil_flags[f1] = BAD_DATA;
    }
    f1 = f2;
    f2 = GEO_find_next_flag(ancil_flags, num_samples, f2+1);
      }
      
      /* Now check remaining unflagged samples in array */
      while ((f2 != FAIL) && (valid == TRUE)) {

    /* Compute position/velocity consistency difference */
    del = fabs(sc_position[f2][j] - sc_position[f1][j] - 
           (sc_velocity[f2][j] + sc_velocity[f1][j])*
           (time_stamp[f2] - time_stamp[f1])/2.0);
    if (del > orbit_consistency) {
      ancil_flags[f2] = BAD_DATA;
      valid = FALSE;
    }
    else {
      num_valid += 1;
    }
    f1 = f2;
    f2 = GEO_find_next_flag(ancil_flags, num_samples, f2+1);
      }

      /* If not at end of array, move forward one sample */
      if (f2 != FAIL) {
    f1 = f2;
    f2 = GEO_find_next_flag(ancil_flags, num_samples, f2+1);
      }
    }
  } /* End of vector component loop */

  /* If no valid pairs found, return FAIL */
  if (num_valid == 0) {

    /* call SDP function to report error */
    modsmf(MODIS_E_NO_VAL_ORB_SAMP, "",
    "GEO_validate_orbit_data, GEO_validate_orbit_data.c");

    return FAIL;
  }

  return SUCCESS;
}