NASA Ocean Color

ocssw V2022

 /* ============================================================================ */
 /* module l1_xcal_hdf.c - functions to read the XCAL cross-calibration file     */
 /*                        from MCcalmerge for processing through MSL12          */
 /*                                                                              */
 /* Written By: B. Franz, NASA/SIMBIOS, December 2003.                           */
 /*                                                                              */
 /* ============================================================================ */
  
 #include "l1_xcal_hdf.h"
  
 #include <hdf4utils.h>
 #include "l1.h"
 #include <genutils.h>
  
 #include <hdf.h>
 #include <mfhdf.h>
  
 #define OBSERVED  1
 #define VICARIOUS 2
 #define NPIX      1
 #define SBUF      5000
  
 static int32_t sd_id;
  
 /* ----------------------------------------------------------------------------------- */
 /* openl1_xcal_hdf() - opens an XCAL file for reading.                                 */
 /*                                                                                     */
 /* B. Franz, SAIC, February 2003.                                                      */
  
 /* ----------------------------------------------------------------------------------- */
 int openl1_xcal_hdf(filehandle *file) {
     int32_t nscan;
     int32_t dims[3];
  
     /* Open the HDF input file */
     sd_id = SDstart(file->name, DFACC_RDONLY);
     if (sd_id == FAIL) {
         fprintf(stderr, "-E- %s line %d: SDstart(%s, %d) failed.\n",
                 __FILE__, __LINE__, file->name, DFACC_RDONLY);
         return (HDF_FUNCTION_ERROR);
     }
  
     /* Get pixel and scan dimensions */
     if (getDims(sd_id, "fileID", dims) != 0) {
         printf("-E- %s line %d: Could not read HDF file dimensions, %s .\n",
                 __FILE__, __LINE__, file->name);
         SDend(sd_id);
         return (FATAL_ERROR);
     }
     if (dims[0] < 0) {
         printf("-E- %s line %d: Invalid dimension information for %s.\n",
                 __FILE__, __LINE__, file->name);
         SDend(sd_id);
         return (FATAL_ERROR);
     }
     nscan = dims[0];
  
     file->npix = 1;
     file->nscan = nscan;
     file->sd_id = sd_id;
  
     return (LIFE_IS_GOOD);
 }
  
  
 /* ----------------------------------------------------------------------------------- */
 /* readl1_xcal_hdf() - reads 1 line (1 pixel) from a cross-calibration (XCAL) file.    */
 /*                                                                                     */
 /* B. Franz, SAIC, February 2003.                                                      */
  
 /* ----------------------------------------------------------------------------------- */
 int readl1_xcal_hdf(filehandle *file, int32_t scan, l1str *l1rec) {
     static int16_t *year;
     static int16_t *day;
     static int32_t *msec;
     static int16_t *pixnum;
     static int8_t *detnum;
     static int8_t *mside;
     static float *lon;
     static float *lat;
     static float *solz;
     static float *sola;
     static float *senz;
     static float *sena;
     static float *alpha;
     static float *Lt;
  
     static int32_t lastscan = -SBUF, firstCall = 1;
  
     int32_t nbands = (int32_t) file->nbands;
     int32_t nscan = (int32_t) file->nscan;
     int32_t indx = scan % SBUF;
  
     int32_t nread;
  
     if (firstCall == 1) {
         year = (int16_t*) allocateMemory(SBUF * sizeof (int16_t), "readl1_xcal_hdf - year");
         day = (int16_t*) allocateMemory(SBUF * sizeof (int16_t), "readl1_xcal_hdf - day");
         msec = (int32_t*) allocateMemory(SBUF * sizeof (int32_t), "readl1_xcal_hdf - msec");
         pixnum = (int16_t*) allocateMemory(SBUF * sizeof (int16_t), "readl1_xcal_hdf - pixnum");
         detnum = (int8_t*) allocateMemory(SBUF * sizeof (int8_t), "readl1_xcal_hdf - detnum");
         mside = (int8_t*) allocateMemory(SBUF * sizeof (int8_t), "readl1_xcal_hdf - mside");
         lon = (float*) allocateMemory(SBUF * sizeof (float), "readl1_xcal_hdf - lon");
         lat = (float*) allocateMemory(SBUF * sizeof (float), "readl1_xcal_hdf - lat");
         solz = (float*) allocateMemory(SBUF * sizeof (float), "readl1_xcal_hdf - solz");
         sola = (float*) allocateMemory(SBUF * sizeof (float), "readl1_xcal_hdf - sola");
         senz = (float*) allocateMemory(SBUF * sizeof (float), "readl1_xcal_hdf - senz");
         sena = (float*) allocateMemory(SBUF * sizeof (float), "readl1_xcal_hdf - sena");
         alpha = (float*) allocateMemory(SBUF * sizeof (float), "readl1_xcal_hdf - alpha");
         Lt = (float*) allocateMemory(file->nbands * SBUF * sizeof (float32), "readl1_xcal_hdf - Lt");
         firstCall = 0;
     }
     /* Do we need to read the next buffered block? */
     if (scan / SBUF != lastscan / SBUF) {
  
         if (scan + SBUF < nscan)
             nread = SBUF;
         else
             nread = nscan - scan + 1;
  
         printf("%d %d %d\n", scan, nread, nscan);
  
         /* Read scan time */
         READ_SDS_ID(sd_id, "year", year, scan, 0, 0, 0, nread, 1, 1, 1);
         READ_SDS_ID(sd_id, "day", day, scan, 0, 0, 0, nread, 1, 1, 1);
         READ_SDS_ID(sd_id, "msec", msec, scan, 0, 0, 0, nread, 1, 1, 1);
  
         /* Get location within instrument */
         READ_SDS_ID(sd_id, "ipix", pixnum, scan, 0, 0, 0, nread, 1, 1, 1);
         READ_SDS_ID(sd_id, "idet", detnum, scan, 0, 0, 0, nread, 1, 1, 1);
         READ_SDS_ID(sd_id, "mside", mside, scan, 0, 0, 0, nread, 1, 1, 1);
  
         /* Get position and path geometry */
         READ_SDS_ID(sd_id, "lon", lon, scan, 0, 0, 0, nread, 1, 1, 1);
         READ_SDS_ID(sd_id, "lat", lat, scan, 0, 0, 0, nread, 1, 1, 1);
         READ_SDS_ID(sd_id, "solz", solz, scan, 0, 0, 0, nread, 1, 1, 1);
         READ_SDS_ID(sd_id, "sola", sola, scan, 0, 0, 0, nread, 1, 1, 1);
         READ_SDS_ID(sd_id, "senz", senz, scan, 0, 0, 0, nread, 1, 1, 1);
         READ_SDS_ID(sd_id, "sena", sena, scan, 0, 0, 0, nread, 1, 1, 1);
         READ_SDS_ID(sd_id, "alpha", alpha, scan, 0, 0, 0, nread, 1, 1, 1);
  
         /* Read radiances */
         READ_SDS_ID(sd_id, "Lt", Lt, scan, 0, 0, 0, nread, nbands, 1, 1);
     }
  
     l1rec->scantime = yds2unix(year[indx], day[indx], (double) (msec[indx] / 1.e3));
  
     l1rec->pixnum[0] = (int32_t) pixnum [indx];
     l1rec->detnum = (int32_t) detnum [indx];
     l1rec->mside = (int32_t) mside [indx];
  
     l1rec->lon [0] = lon [indx];
     l1rec->lat [0] = lat [indx];
     l1rec->solz [0] = solz [indx];
     l1rec->sola [0] = sola [indx];
     l1rec->senz [0] = senz [indx];
     l1rec->sena [0] = sena [indx];
     l1rec->alpha[0] = alpha [indx];
  
     memcpy(l1rec->Lt, &Lt[indx * nbands], nbands);
  
     l1rec->npix = 1;
     l1rec->iscan = scan;
  
     lastscan = scan;
  
     return (LIFE_IS_GOOD);
 }
  
 int closel1_xcal_hdf(filehandle *file) {
     if (SDend(sd_id)) {
         fprintf(stderr, "-E- %s line %d: SDend(%d) failed for file, %s.\n",
                 __FILE__, __LINE__, sd_id, file->name);
         return (HDF_FUNCTION_ERROR);
     }
  
     return (LIFE_IS_GOOD);
 }
  
  
  
  
  

l1mapgen.stderr

stderr

Definition: l1mapgen.py:204

closel1_xcal_hdf

int closel1_xcal_hdf(filehandle *file)

Definition: l1_xcal_hdf.c:170

day

int32_t day

Definition: atrem_corl1v2.h:308

genutils.h

yds2unix

double yds2unix(int16_t year, int16_t day, double secs)

Definition: yds2unix.c:7

FAIL

#define FAIL

Definition: ObpgReadGrid.h:18

allocateMemory

void * allocateMemory(size_t numBytes, const char *name)

Definition: allocateMemory.c:7

scan

MOD_PR01 Production producing one five minute granule of output data in each run It can be configured to produce as many as three five minute granules per run Each execution with one construction record and one date file for each dataset In normal these are created by which splits them out of the hour datasets For LANCE they are created by which merges all session MODIS L0 datasets overlapping the requested time and extracts from the merged data those packets which fall within that time period Each scan of data is stored in the L1A granule that covers the start time of that scan

Definition: MOD_PR01_pr.txt:19

l1rec

read l1rec

Definition: HOWTO_Add_a_sensor.txt:72

lat

float * lat

Definition: l1_hmodis_hdf.c:756

msec

int32 * msec

Definition: l1_czcs_hdf.c:31

nscan

int32 nscan

Definition: l1_czcs_hdf.c:19

READ_SDS_ID

#define READ_SDS_ID(sd_id, nam, ptr, s0, s1, s2, s3, e0, e1, e2, e3)

Definition: hdf4utils.h:109

spacetrack_tles.year

year

Definition: spacetrack_tles.py:170

hico.proc_hico.solz

solz

Definition: proc_hico.py:240

hico.proc_hico.senz

senz

Definition: proc_hico.py:239

file

no change in intended resolving MODur00064 Corrected handling of bad ephemeris attitude resolving resolving GSFcd00179 Corrected handling of fill values for[Sensor|Solar][Zenith|Azimuth] resolving MODxl01751 Changed to validate LUT version against a value retrieved from the resolving MODxl02056 Changed to calculate Solar Diffuser angles without adjustment for estimated post launch changes in the MODIS orientation relative to incidentally resolving defects MODxl01766 Also resolves MODxl01947 Changed to ignore fill values in SCI_ABNORM and SCI_STATE rather than treating them as resolving MODxl01780 Changed to use spacecraft ancillary data to recognise when the mirror encoder data is being set by side A or side B and to change calculations accordingly This removes the need for seperate LUTs for Side A and Side B data it makes the new LUTs incompatible with older versions of the and vice versa Also resolves MODxl01685 A more robust GRing algorithm is being which will create a non default GRing anytime there s even a single geolocated pixel in a granule Removed obsolete messages from seed file

Definition: HISTORY.txt:413

LIFE_IS_GOOD

#define LIFE_IS_GOOD

Definition: passthebuck.h:4

getDims

int getDims(int32_t fileID, const char sdsname[], int32_t dims[])

mside

int32_t mside

Definition: l1_hmodis_hdf.c:752

hico.proc_hico.sena

sena

Definition: proc_hico.py:241