NASA Ocean Color

ocssw V2022

 /* =====================================================================*/
 /*                                                                      */
 /* Program: l1det2det - multi-sensor detector-to-detector calibration   */
 /*                                                                      */
 /*                                                                      */
 /* Written By:                                                          */
 /*                                                                      */
 /*     Ewa J. Kwiatkowska                                               */
 /*     SAIC                                                             */
 /*     NASA/Ocean Color Project                                         */
 /*     June 2007                                                        */
 /*                                                                      */
 /*     Programmer     Organization      Date       Description of change*/
 /*   --------------   ------------    --------     ---------------------*/
 /*   Joel Gales       Futuretech      08/01/13     Add support for      */
 /*                                                 NETCDF4              */
 /*   B. Franz         NASA            09/10/13     Remove references to */
 /*                                                 resolution and 1640  */
 /*                                                 and 500m MODIS code  */
 /*   Sean Bailey      Futuretech      04/15/13     Entirely reworked to */
 /*                                                 handle any mission,  */
 /*                                                 work with existing   */
 /*                                                 product definitions  */
 /*                                                 and require complete */
 /*                                                 scans                */
 /* =====================================================================*/
  
 #include <stdio.h>
 #include <sys/stat.h>
 #include <stdlib.h>
 #include <fcntl.h>
 #include <string.h>
 #include <errno.h>
 #include <unistd.h>
 #include <libgen.h>
 #include <setupflags.h>
 #include "l12_proto.h"
 #include "calfile_utils.h"
 #include <hdf5.h>
  
 int read9km_mask(char *file, char *mask);
 int is_masked(int32_t bin, char *mask, int32_t nrows);
 int16_t fileID = 0;
  
 float ***aots, ***nlws; //arrays to contain the values needed to avg over for inversion
  
 /* -------------------------------------------------------------------- */
 /*                            main                                      */
  
 /* -------------------------------------------------------------------- */
 int main(int argc, char* argv[]) {
  
     static int32_t nrows = 2160;
     long iscan = 0; /* input scan number                  */
     long npix = 0; /* input number pixels per scan       */
     long spix = 0; /* start pixel for subscene process   */
     long epix = -1; /* end pixel for subscene process     */
     long sscan = 0; /* start scan for subscene process    */
     long escan = -1; /* end scan for subscene process      */
     long nscan;
     long nbands;
     int32_t ndets;
     long nruns; /* number of output detector runs     */
     long ipix;
     long jscan; /* loop variables                     */
     int band;
     long scanidx;
     long runidx;
     int initial_mirror_side;
     int goodscan;
     idDS ds_id;
  
     l1str l1rec; /* generic level-1b scan structure    */
     l2str l2rec; /* generic level-2  scan structure    */
     tgstr tgrec; /* structure to store target values   */
     aestr aerec; /* structure to store aerosol values  */
     calstr** detrecArray; /* detrec for each pixel in a scan    */
  
     filehandle l1file; /* input l1 file handle               */
  
     double start_time;
     long i, j, ib, runCounter, nir_l, nprods;
     int32 *numbin, *basebin;
     int32_t bin, ibin, bin_row, bin_col;
     long **valid_pixel_array; //Valid pixel array 0=invalid, 1=pixel valid
     int numContiguousDetectorRuns; // number of scans for detector runs
     int status;
  
     char buf[5000], *mask, *maskfile, maskname[1000];
     float lat, lon, latbin;
     int32_t flagusemask;
     uint32 required;
  
     if (argc == 1) {
         l2gen_usage("l1det2det");
         return 0;
     }
  
     want_verbose = 1;
  
     setvbuf(stdout, NULL, _IOLBF, 0);
     setvbuf(stderr, NULL, _IOLBF, 0);
  
     /* Initialize file handles */
     cdata_();
     filehandle_init(&l1file);
     msl12_input_init();
  
     /* Parse input parameters */
     if (msl12_input(argc, argv, "l1det2det", &l1file) != 0) {
         printf("-E- %s: Error parsing input parameters.\n", argv[0]);
         exit(FATAL_ERROR);
     }
  
     if (access(input->ifile[0], F_OK) || access(input->ifile[0], R_OK)) {
         printf("-E- %s: Input file '%s' does not exist or cannot open.\n",
                 argv[0], input->ifile[0]);
         exit(FATAL_ERROR);
     }
  
     /*                                                                  */
     /* Open input file and get sensor   */
     /* and scan information from handle */
     /*                                                                  */
     strcpy(l1file.name, input->ifile[0]);
     l1file.geofile = input->geofile;
  
     if (openl1(&l1file) != 0) {
         printf("-E- %s: Error opening %s for reading.\n",
                 argv[0], l1file.name);
         exit(FATAL_ERROR);
     }
  
     /*
      * Check output file for matching sensorID
      */
     int existingSensorID;
  
     /* Save old HDF5 error handler */
     H5E_auto_t old_func;
     void *old_client_data;
     H5Eget_auto(H5E_DEFAULT, &old_func, &old_client_data);
  
     /* Turn off error handling */
     H5Eset_auto(H5E_DEFAULT, NULL, NULL);
  
     if (Hishdf(input->ofile[0]) == TRUE || H5Fis_hdf5(input->ofile[0]) == TRUE) {
         ds_id = openDS(input->ofile[0]);
         status = readAttr(ds_id, "sensorID", &existingSensorID);
         if (status) {
             printf("-E- %s: Problem reading output file: %s\n", argv[0], input->ofile[0]);
             exit(EXIT_FAILURE);
         }
         endDS(ds_id);
         if (l1file.sensorID != existingSensorID) {
             printf("-E- %s: Mixing L2 data from different sensors, %s and %s.\n",
                     argv[0], sensorId2SensorName(l1file.sensorID), sensorId2SensorName(existingSensorID));
             exit(EXIT_FAILURE);
         }
  
     }
     /* Restore previous HDF5 error handler */
     H5Eset_auto(H5E_DEFAULT, old_func, old_client_data);
  
     npix = l1file.npix;
     numContiguousDetectorRuns = input->ybox;
     if (numContiguousDetectorRuns < 1)
         numContiguousDetectorRuns = 1;
  
     if (numContiguousDetectorRuns > 2) {
         printf("ybox > 2, sorry, only letting you use 2 - talk to management if you want more...\n");
         numContiguousDetectorRuns = 2;
     }
     /*                                                                  */
     /* Allocate memory for L1 and L2 scan data                          */
     /*                                                                  */
     if (alloc_l1(&l1file, &l1rec) == 0) {
         printf("-E- %s: Unable to allocate L1 record.\n", argv[0]);
         exit(FATAL_ERROR);
     }
     if (alloc_l2(&l1rec, &l2rec) == 0) {
         printf("-E- %s: Unable to allocate L2 record.\n", argv[0]);
         exit(FATAL_ERROR);
     }
  
     /* Set the end pixel if it was not set by command argument          */
     if (l1_input->epixl == -1 || l1_input->epixl > l1file.npix)
         l1_input->epixl = l1file.npix;
     if (l1_input->eline == -1 || l1_input->eline > l1file.nscan)
         l1_input->eline = l1file.nscan;
     if (l1_input->spixl < 1)
         l1_input->spixl = 1;
     if (l1_input->sline < 1)
         l1_input->sline = 1;
  
     spix = MAX(l1_input->spixl - 1, 0);
     epix = MIN(l1_input->epixl - 1, l1file.npix - 1);
     sscan = MAX(l1_input->sline - 1, 0);
     escan = MIN(l1_input->eline - 1, l1file.nscan - 1);
  
     ndets = l1file.ndets;
     // ensure there are full scans
     if (sscan > 0) {
         while (sscan % ndets)
             sscan++;
     }
     int numContiguousDets = ndets * numContiguousDetectorRuns;
     escan = ((escan + 1) / numContiguousDets) * numContiguousDets - 1;
     //escan = ((escan + 1) / ndets) * ndets - 1;
  
     if (sscan > escan || spix > epix) {
         printf("-E- %s: scan and pixel limits make no sense.\n", argv[0]);
         printf(" start scan  = %ld\n", sscan + 1);
         printf(" end   scan  = %ld\n", escan + 1);
         printf(" start pixel = %ld\n", spix + 1);
         printf(" end   pixel = %ld\n", epix + 1);
         exit(FATAL_ERROR);
     }
  
     /* Note: for the L1 file, npix is still the native scan pixel count */
     l1file.spix = spix;
     l1file.epix = epix;
  
     nscan = (escan - sscan) + 1;
     npix = (epix - spix) + 1;
     nbands = l1file.nbands;
  
     /*                                                                  */
     /* Transfer any additional header info to the L2 record headers     */
     /*                                                                  */
     l2rec.bindx = l1file.bindx;
  
     /*                                                                  */
     /* Set up parameters for strict ocean color forward processing      */
     /*                                                                  */
     input->proc_ocean = 1;
     input->proc_land = 0;
     input->proc_sst = 0;
     input->atmocor = 1;
     input->aer_opt = AERWANG;
     l1_input->outband_opt = 0;
     input->mode = FORWARD;
     char outprod[L1_MAXPROD][32];
     int nvars1d = 2;
     char vars1Dnames[nvars1d][32]; // floating point one dimensional data to include in output - lon, lat
     nprods = prodlist(l1file.sensorID, 0, (const char *) &(input->l2prod), (const char *) &(input->def_l2prod), outprod);
  
     /*
      * Allocating memory for the multidimentional arrays of pixel index, nLw and aot
      */
     if ((valid_pixel_array = (long **) malloc(nscan * sizeof (long *))) == NULL) {
         printf("-E- %s: Error allocating memory to the pixel index.\n", argv[0]);
         exit(FATAL_ERROR);
     }
  
     if ((aots = (float ***) malloc(nscan * sizeof (float *))) == NULL) {
         printf("-E- : Error allocating memory to in situ inputs\n");
         exit(FATAL_ERROR);
     }
     if ((nlws = (float ***) malloc(nscan * sizeof (float *))) == NULL) {
         printf("-E- : Error allocating memory to in situ inputs\n");
         exit(FATAL_ERROR);
     }
  
     for (i = 0; i < nscan; i++) {
         if ((valid_pixel_array[i] = (long *) calloc(npix, sizeof (long))) == NULL) {
             printf("-E- %s: Error allocating memory to the pixel index.\n", argv[0]);
             exit(FATAL_ERROR);
         }
  
         if ((aots[i] = (float **) malloc(npix * sizeof (float *))) == NULL) {
             printf("-E- %s: Error allocating memory to the AOT data.\n", argv[0]);
             exit(FATAL_ERROR);
         }
         if ((nlws[i] = (float **) malloc(npix * sizeof (float *))) == NULL) {
             printf("-E- %s: Error allocating memory to the nLw data.\n", argv[0]);
             exit(FATAL_ERROR);
         }
         for (j = 0; j < npix; j++) {
             if ((aots[i][j] = (float *) calloc(nbands, sizeof (float))) == NULL) {
                 printf("-E- %s: Error allocating memory to the aot data.\n", argv[0]);
                 exit(FATAL_ERROR);
             }
             if ((nlws[i][j] = (float *) calloc(nbands, sizeof (float))) == NULL) {
                 printf("-E- %s: Error allocating memory to the nLw data.\n", argv[0]);
                 exit(FATAL_ERROR);
             }
         }
     }
  
     // Allocate memory for and set up deepwater mask
     if ((mask = (char *) malloc(5940424 * sizeof (char))) == NULL) {
         printf("-E- %s: Error allocating memory to the mask data\n", argv[0]);
         exit(FATAL_ERROR);
     }
     if ((maskfile = getenv("OCDATAROOT")) == NULL) {
         printf("-E- %s: OCDATAROOT directory undefined.\n", argv[0]);
         exit(FATAL_ERROR);
     }
     strcpy(maskname, maskfile);
     strcat(maskname, "/common/deep_water_mask_9km.dat\x0");
  
     if (read9km_mask(maskname, mask) > 0) {
         printf("-E- %s: Failed reading the deep water mask file\n", argv[0]);
         exit(FATAL_ERROR);
     }
  
     /* ----------------- */
     /* Set up bin arrays */
     /* ----------------- */
     if ((numbin = (int32 *) calloc(nrows, sizeof (int32))) == NULL) {
         printf("-E- %s: Error allocating memory to numbin\n", argv[0]);
         exit(FATAL_ERROR);
     }
     if ((basebin = (int32 *) calloc(nrows + 1, sizeof (int32))) == NULL) {
         printf("-E- %s: Error allocating memory to basebin\n", argv[0]);
         exit(FATAL_ERROR);
     }
  
     bin = 0;
     for (i = 0; i < nrows; i++) {
         latbin = (i + 0.5) * (180.0 / nrows) - 90.0;
         numbin[i] = (int32) (cos(latbin * PI / 180.0) * (2.0 * nrows) + 0.5);
         bin += numbin[i];
     }
     basebin[0] = 1;
     for (i = 1; i <= nrows; i++) {
         basebin[i] = basebin[i - 1] + numbin[i - 1];
     }
  
  
     strcpy(buf, "\x0");
     for (i = 0; i < L1_NFLAGS; i++) {
         strcat(buf, l2_flag_lname[i]);
         if (i < L1_NFLAGS - 1) strcat(buf, ",\x0");
     }
     setupflags(buf, input->flaguse, (uint32 *) & flagusemask, &required, &status);
     if (status < 0) {
         printf("-E- %s: Error reading L2 flags %s.\n", argv[0], input->ifile[0]);
         exit(FATAL_ERROR);
     }
  
     strcpy(vars1Dnames[0], "lon");
     strcpy(vars1Dnames[1], "lat");
  
     nir_l = bindex_get(input->aer_wave_long);
  
     printf("\n\nBegin %s Processing\n", "l1det2det\x0");
     printf("\nSensor is %s\n", sensorId2SensorName(l1file.sensorID));
     printf("Sensor ID is %d\n", l1file.sensorID);
     printf("Sensor has %d reflective bands\n", l1file.nbands);
     printf("Sensor has %d emissive bands\n", l1file.nbandsir);
     printf("Sensor resolution %d m\n", l1_input->resolution);
     printf("Number of along-track detectors per band is %d\n", ndets);
     printf("Number of input pixels per scan is %d\n", l1file.npix);
     printf("Processing pixels %ld to %ld\n", spix + 1, epix + 1);
     printf("Processing scans %ld to %ld\n", sscan + 1, escan + 1);
  
     start_time = now();
     printf("\nBegin l1det2det processing at %s\n\n", ydhmsf(start_time, 'L'));
  
     /*
      *  Read file scan by scan, convert to L2
      *  determine valid detector "runs" and
      *  populate the nLw and tau arrays needed
      *  for averaging to insert into inverse
      *  processing.
      */
     for (iscan = sscan; iscan <= escan; iscan++) {
  
         scanidx = iscan - sscan;
  
         if (getl1rec(iscan, 1, &l1rec) != 0) {
             exit(FATAL_ERROR);
         }
         // First Line!
         if (iscan == sscan) {
             initial_mirror_side = l1rec.mside;
         }
  
         if ((iscan % 50) == 0)
             printf("Processing scan #%6ld (%ld of %ld) after %6.0f seconds\n",
                 iscan, iscan - sscan + 1, escan - sscan + 1, now() - start_time);
  
         /*                                                              */
         /* Convert the L1B radiances to L2                              */
         /*                                                              */
         convl12(&l1rec, &l2rec, 0, l1rec.npix - 1, NULL);
  
         /*                                                      */
         /* Loop through each pixel and check exclusion criteria */
         /*  on pixel flags and values                           */
         /*                                                      */
         for (ipix = 0; ipix < l1rec.npix; ipix++) {
             ibin = 1;
  
             lat = l1rec.lat[ipix];
             lon = l1rec.lon[ipix];
             bin_row = (int32_t) ((90.0 + lat) * ((float64) nrows / (float64) 180.0));
             bin_col = (int32_t) ((float64) numbin[bin_row] * (lon + 180.0) / (float64) 360.0);
             bin = basebin[bin_row] + bin_col;
             ibin = (int32_t) is_masked(bin, mask, nrows);
  
             if (((l1rec.flags[ipix] & flagusemask) == 0) &&
                     l2rec.chl[ipix] > 0.0 &&
                     l2rec.chl[ipix] <= input->chlthreshold &&
                     l2rec.taua[ipix * nbands + nir_l] > 0.0 &&
                     l2rec.taua[ipix * nbands + nir_l] <= input->aotthreshold && ibin > 0) {
  
                 valid_pixel_array[scanidx][ipix] = 1;
                 for (ib = 0; ib < nbands; ib++) {
                     nlws[scanidx][ipix][ib] = l2rec.nLw [ipix * nbands + ib];
                     aots[scanidx][ipix][ib] = l2rec.taua[ipix * nbands + ib];
                 }
             }
             /*
              * Once a detector run is complete,
              * check the all lines in the scan to ensure all detectors are valid
              */
             if (l1rec.detnum == ndets - 1) {
                 if (numContiguousDetectorRuns == 1 || l1rec.mside != initial_mirror_side) {
                     for (i = 0; i < ndets * numContiguousDetectorRuns; i++) {
                         if (!valid_pixel_array[scanidx - i][ipix]) {
                             for (j = 0; j < ndets * numContiguousDetectorRuns; j++) {
                                 valid_pixel_array[scanidx - j][ipix] = 0;
                             }
                             break;
                         }
                     }
  
                 }
             }
         }
     }
  
     printf("\nEnd of line-by-line processing at %s\n", ydhmsf(now(), 'L'));
     printf("Processing Rate = %f scans/sec\n", nscan / (now() - start_time));
  
     // Free memory associated with deepwater mask
     free(mask);
     free(numbin);
     free(basebin);
  
     /*
      * Count the number of valid detector runs (i.e. scans with all detectors valid)
      */
     nruns = 0;
     for (iscan = sscan; iscan <= escan; iscan += ndets) {
         scanidx = iscan - sscan;
         for (ipix = 0; ipix < l1rec.npix; ipix++) {
             if (valid_pixel_array[scanidx][ipix])
                 nruns++;
         }
     }
  
     if (!nruns) {
         printf("-W- %s: No analysis pixel data found in the L2 file %s\n", argv[0], input->ifile[0]);
     } else {
  
         printf("\n\nNow extracting valid pixel runs\n");
         printf("Along-track pixel runs of %d found: %ld\n", numContiguousDets, nruns);
  
         start_time = now();
  
         /*
          * Allocate detrec, aer and tgt structures
          */
         if ((detrecArray = (calstr **) malloc(l1rec.npix * sizeof (calstr *))) == NULL) {
             printf("-E- : Error allocating memory for detector record structures\n");
             exit(EXIT_FAILURE);
         }
         for (i = 0; i < l1rec.npix; i++) {
             detrecArray[i] = alloc_calrec(ndets, nbands, nprods, nvars1d);
         }
  
  
         alloc_aer(l1rec.npix, nbands, &aerec);
         alloc_target(l1rec.npix, nbands, &tgrec);
         /*
          * set up the bits for inversion
          */
         input->aer_opt = FIXAOT;
         input->mode = INVERSE_NLW;
         aerec.mode = ON;
         tgrec.mode = ON;
         l2rec.tgrec = &tgrec;
  
         /*
          * Open the output file.  It will be created if necessary
          */
  
         runCounter = 0;
         ds_id = calfile_open(input->ofile[0], l1file.sensorID, nruns, ndets, nprods, nvars1d, outprod, vars1Dnames, &runCounter, DET2DET);
  
         /*
          * Fill up detrec with detector info and grab avg aot/nlws
          * for use in inversion to fill in vLt array in detrec
          *  along with the other
          * detector values...
          */
  
         runCounter--; //nruns index
         int runNum = 0; //just for nice printing on output...
  
         for (iscan = sscan; iscan <= escan; iscan += ndets * numContiguousDetectorRuns) {
             goodscan = 0;
             runidx = iscan - sscan;
             for (ipix = 0; ipix < l1rec.npix; ipix++) {
                 if (valid_pixel_array[runidx][ipix]) {
                     goodscan = 1;
                     break;
                 }
             }
             if (goodscan) {
                 // For "good scans", loop through detectors for the valid runs and get the pixel info for detrec
                 for (jscan = iscan; jscan < iscan + ndets * numContiguousDetectorRuns; jscan++) {
                     scanidx = jscan - sscan;
                     int detidx = jscan - iscan;
                     if (detidx >= ndets)
                         detidx -= ndets;
  
                     if (getl1rec(jscan, 1, &l1rec) != 0) {
                         exit(EXIT_FAILURE);
                     }
                     // For the first line in the scan, fill up the per run values in detrec
                     if (detidx == 0) {
                         int16_t year, day;
                         double sec;
                         unix2yds(l1rec.scantime, &year, &day, &sec);
  
                         for (ipix = 0; ipix < l1rec.npix; ipix++) {
                             if (valid_pixel_array[scanidx][ipix]) {
                                 detrecArray[ipix]->sensorID = l1rec.l1file->sensorID;
                                 detrecArray[ipix]->year = (int32_t) year;
                                 detrecArray[ipix]->day = (int32_t) day;
                                 detrecArray[ipix]->msec = (int32_t) (sec * 1.e3);
                                 detrecArray[ipix]->mside = l1rec.mside;
                                 detrecArray[ipix]->iscan = (int16_t) jscan;
                                 detrecArray[ipix]->pixnum = l1rec.pixnum[ipix];
                                 detrecArray[ipix]->vars1D[0] = l1rec.lon[ipix];
                                 detrecArray[ipix]->vars1D[1] = l1rec.lat[ipix];
                                 // average the nLws and aots over the pixels in ndets*numContiguousDetectorRuns
                                 // and fills in the aerec and tgrec arrays needed for the inversion step
                                 inversion_init(ndets*numContiguousDetectorRuns, runidx, nbands, ipix, &aerec, &tgrec);
                             }
                         }
                     }
                     // The Lt array is filled and the avg nLw and taua needed for the inversion
                     // are set up in this loop
                     for (ipix = 0; ipix < l1rec.npix; ipix++) {
                         if (valid_pixel_array[scanidx][ipix]) {
                             // average the nLws and aots over the pixels in ndets*numContiguousDetectorRuns
                             // and fills in the aerec and tgrec arrays needed for the inversion step
                             //                            inversion_init(ndets*numContiguousDetectorRuns, runidx, l1rec.nbands, ipix, &aerec, &tgrec);
                             for (band = 0; band < nbands; band++) {
                                 ib = ipix * nbands + band;
                                 detrecArray[ipix]->Lt[band][detidx] = (float) l1rec.Lt[ib];
                             }
                         }
                     }
                     /*                                                              */
                     /* Convert the L1B radiances to L2                              */
                     /*                                                              */
                     convl12(&l1rec, &l2rec, 0, l1rec.npix - 1, &aerec);
                     /*                                                              */
                     /* Convert back to L1B to get vLts                              */
                     /*                                                              */
                     convl21(&l2rec, &tgrec, 0, l1rec.npix - 1, l1rec.Lt, NULL);
  
                     // set detrec data and vLts obtained via inversion step
                     for (ipix = 0; ipix < l1rec.npix; ipix++) {
                         if (valid_pixel_array[scanidx][ipix]) {
                             // The vLts are filled here
                             for (band = 0; band < nbands; band++) {
                                 ib = ipix * nbands + band;
                                 detrecArray[ipix]->vLt[band][detidx] = (float) l1rec.Lt[ib];
                             }
                             // The detrec entries for the other request products are populated here
                             for (i = 0; i < nprods; i++) {
                                 if (strcmp(outprod[i], "pixnum") != 0 &&
                                         strcmp(outprod[i], "mside") != 0 &&
                                         strncmp(outprod[i], "Lt", 2) != 0 &&
                                         strncmp(outprod[i], "vLt", 3) != 0 &&
                                         strcmp(outprod[i], "detnum") != 0 &&
                                         strcmp(outprod[i], "l2_flags") != 0) {
                                     // get the product index record
                                     l2prodstr *p;
  
                                     if ((p = get_l2prod_index(outprod[i], l1rec.l1file->sensorID,
                                             nbands + l1file.nbandsir, l1rec.npix, l1rec.l1file->nscan, l1rec.l1file->iwave)) == NULL) {
                                         fprintf(stderr,
                                                 "-E- %s line %d: product index failure.\n",
                                                 __FILE__, __LINE__);
                                         return (1);
                                     };
  
                                     // extract the product
                                     float *pbuf;
                                     pbuf = prodgen(p, &l2rec);
  
                                     // fill up detrec data
                                     detrecArray[ipix]->data[i][detidx] = pbuf[ipix];
                                 }
                             }
                         }
                     }
  
                     // Write out the valid runs for this scan
                     if (detidx == ndets - 1) {
                         for (ipix = 0; ipix < l1rec.npix; ipix++) {
                             if (valid_pixel_array[scanidx][ipix]) {
                                 runCounter++;
                                 runNum++;
                                 if ((runNum % 500) == 0)
                                     printf("Writing run %d of %ld\n", runNum, nruns);
                                 calfile_write(ds_id, detrecArray[ipix], runCounter, nruns, ndets, nprods, nbands, nvars1d, outprod, vars1Dnames, DET2DET);
                             }
                         }
                     }
                 }
             }
         }
         printf("\nEnd pixel-run extraction at %s, pixel-run number found: %ld\n\n\n", ydhmsf(now(), 'L'), nruns);
         if (calfile_close(ds_id) != 0) {
             printf("Trouble closing file %s\n", input->ofile[0]);
             exit(EXIT_FAILURE);
         }
         // Free up some memory
         for (i = 0; i < l1rec.npix; i++) {
             free_calrec(detrecArray[i], nbands, nprods);
         }
  
     }
  
     for (ib = 0; ib < nbands; ib++) {
         free(aots[ib]);
         free(nlws[ib]);
     }
     free(aots);
     free(nlws);
  
     /*                                                                  */
     /* Close all files                                                  */
     /*                                                                  */
     closel1(&l1file);
  
     if (nruns > 0) return (EXIT_SUCCESS);
     else return (NOMATCH_ERROR);
 }

ydhmsf

char * ydhmsf(double dtime, char zone)

Definition: ydhmsf.c:12

L1_MAXPROD

#define L1_MAXPROD

Definition: filehandle.h:20

l1file

int32 l1file(int32 sdfid, int32 *nsamp, int32 *nscans, int16 *dtynum)

Definition: l1stat_chk.c:586

l1mapgen.stderr

stderr

Definition: l1mapgen.py:204

MAX

#define MAX(A, B)

Definition: swl0_utils.h:26

MIN

#define MIN(x, y)

Definition: rice.h:169

MDN.parameters.float

float

Definition: parameters.py:23

EXIT_SUCCESS

#define EXIT_SUCCESS

Definition: GEO_basic.h:72

int j

Definition: decode_rs.h:73

INVERSE_NLW

#define INVERSE_NLW

Definition: filehandle.h:13

day

int32_t day

Definition: atrem_corl1v2.h:308

msl12_input

int msl12_input(int argc, char *argv[], const char *progName, filehandle *l1file)

Definition: msl12_input.c:4201

status

int status

Definition: l1_czcs_hdf.c:32

nlws

float *** nlws

Definition: main_l1det2det.c:45

openDS

idDS openDS(const char *filename)

Definition: wrapper.c:616

calfile_write

int calfile_write(idDS ds_id, calstr *calrec, int recnum, int ydim, int xdim, int nprods, int nbands, int nvars1d, char l2prods[L1_MAXPROD][32], char vars1Dnames[L1_MAXPROD][32], caltype ctype)

Definition: calfile_utils.c:348

alloc_aer

int alloc_aer(int32_t npix, int32_t nbands, aestr *rec)

Definition: alloc_aer.c:12

MDN.parameters.required

required

Definition: parameters.py:9

l1mapgen.stdout

stdout

Definition: l1mapgen.py:204

NOMATCH_ERROR

#define NOMATCH_ERROR

Definition: l12_parms.h:82

NULL

#define NULL

Definition: decode_rs.h:63

filehandle_init

void filehandle_init(filehandle *file)

Definition: filehandle_init.c:43

l1rec

read l1rec

Definition: HOWTO_Add_a_sensor.txt:72

band

PARAM_TYPE_NONE Default value No parameter is buried in the product name name_prefix is case insensitive string compared to the product name PARAM_TYPE_VIS_WAVE The visible wavelength bands from the sensor are buried in the product name The product name is compared by appending and name_suffix ie aph_412_giop where prod_ix will be set to PARAM_TYPE_IR_WAVE same search method as PARAM_TYPE_VIS_WAVE except only wavelength above are looped through but prod_ix is still based ie aph_2_giop for the second band

Definition: HOWTO_Add_a_product.txt:42

TRUE

#define TRUE

Definition: rice.h:165

lat

float * lat

Definition: l1_hmodis_hdf.c:756

#define ON

Definition: l1.h:43

msl12_input_init

void msl12_input_init()

Definition: msl12_input.c:485

nscan

int32 nscan

Definition: l1_czcs_hdf.c:19

spacetrack_tles.year

year

Definition: spacetrack_tles.py:170

l2gen_usage

int l2gen_usage(const char *prog)

Definition: msl12_input.c:4254

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

input

instr * input

Definition: main_l2binmatch.cpp:27

FORWARD

#define FORWARD

Definition: regen_attr.h:12

readAttr

int readAttr(idDS ds_id, const char *nam, void *data)

l12_proto.h

#define PI

Definition: l3_get_org.c:6

alloc_target

int alloc_target(int32_t npix, int32_t nbands, tgstr *rec)

Definition: alloc_target.c:12

prodlist

int32_t prodlist(int32_t sensorID, int32_t evalmask, const char *inprod, const char *defprod, char outprod[L1_MAXPROD][32])

alloc_l2

int alloc_l2(l1str *l1rec, l2str *l2rec)

Definition: alloc_l2.c:17

bindex_get

int bindex_get(int32_t wave)

Definition: windex.c:45

AERWANG

#define AERWANG

Definition: l12_parms.h:23

setupflags

void setupflags(char *flagdef, char *flaguse, uint32_t *flagusemask, uint32_t *required, int *status)

Definition: setupflags.c:5

convl12

int convl12(l1str *l1rec, l2str *l2rec, int32_t spix, int32_t epix, aestr *aerec)

Definition: convl12.c:16

free_calrec

void free_calrec(calstr *calrec, int nbands, int nprods)

Definition: calfile_utils.c:578

cdata_

void cdata_()

l1_input

l1_input_t * l1_input

Definition: l1_options.c:9

FATAL_ERROR

#define FATAL_ERROR

Definition: swl0_parms.h:5

nrows

int32 nrows

Definition: get_dem_height.c:11

getl1rec

INT32 getl1rec(INT16 sceneFrameNum, swl0scene *scene, swl0ctl *l0ctl, input_sType navinp[], navblk_sType navblk[], tilt_states_sType *tiltblk, swl1rec l1rec[])

Definition: getl1rec.c:45

fileID

int16_t fileID

Definition: main_l1det2det.c:43

want_verbose

int want_verbose

Definition: genutils_globals.c:3

mask

a context in which it is NOT documented to do so subscript which cannot be easily calculated when extracting TONS attitude data from the Terra L0 files Corrected several defects in extraction of entrained ephemeris and and as HDF file for both the L1A and Geolocation enabling retrieval of South Polar DEM data Resolved Bug by changing to opent the geolocation file only after a successful read of the L1A and also by checking for fatal errors from not restoring C5 and to report how many of those high resolution values were water in the new WaterPresent SDS Added valid_range attribute to Land SeaMask Changed to bilinearly interpolate the geoid_height to remove artifacts at one degree lines Made corrections to const qualification of pointers allowed by new version of M API library Removed casts that are no longer for same not the geoid Corrected off by one error in calculation of high resolution offsets Corrected parsing of maneuver list configuration parameter Corrected to set Height SDS to fill values when geolocation when for elevation and land water mask

Definition: HISTORY.txt:114

unix2yds

void unix2yds(double usec, short *year, short *day, double *secs)

DET2DET

@ DET2DET

Definition: calfile_utils.h:21

closel1

void closel1(filehandle *l1file)

Definition: l1_io.c:68

main

int main(int argc, char *argv[])

Definition: main_l1det2det.c:51

setupflags.h

alloc_calrec

calstr * alloc_calrec(int ydim, int nbands, int nprods, int nvar1d)

Definition: calfile_utils.c:516

inversion_init

void inversion_init(long ndets, long iscan, int nbands, long ipix, aestr *aerec, tgstr *tgrec)

Definition: calfile_utils.c:480

nbands

int32_t nbands

Definition: atrem_corl1v3.h:190

sensorId2SensorName

const char * sensorId2SensorName(int sensorId)

Definition: sensorInfo.c:198

spix

int32 spix

Definition: l1_czcs_hdf.c:21

iscan

int32_t iscan

Definition: l1_hmodis_hdf.c:745

prodgen

void * prodgen(l2prodstr *p, l2str *l2rec)

Definition: prodgen.c:89

now

u5 which has been done in the LOCALGRANULEID metadata should have an extension NRT It is requested to identify the NRT production Changes from v6 which may affect scientific the sector rotation may actually occur during one of the scans earlier than the one where it is first reported As a the b1 values are about the LOCALGRANULEID metadata should have an extension NRT It is requested to identify the NRT to fill pixels affected by dead subframes with a special value Output the metadata of noisy and dead subframe Dead Subframe EV and Detector Quality Flag2 Removed the function call of Fill_Dead_Detector_SI to stop interpolating SI values for dead but also for all downstream products for science test only Changes from v5 which will affect scientific to conform to MODIS requirements Removed the Mixed option from the ScanType in the code because the L1A Scan Type is never Mixed Changed for ANSI C compliance and comments to better document the fact that when the HDF_EOS metadata is stricly the and products are off by and in the track respectively Corrected some misspelling of RCS swir_oob_sending_detector to the Reflective LUTs to enable the SWIR OOB correction detector so that if any of the sending detectors becomes noisy or non near by good detectors from the same sending band can be specified as the substitute in the new look up table Code change for adding an additional dimension of mirror side to the Band_21_b1 LUT to separate the coefficient of the two mirror sides for just like other thermal emissive so that the L1B code can calibrate Band scan to scan with mirror side dependency which leads better calibration result Changes which do not affect scientific when the EV data are not provided in this Crosstalk Correction will not be performed to the Band calibration data Changes which do not affect scientific and BB_500m in L1A Logic was added to turn off the or to spatial aggregation processes and the EV_250m_Aggr1km_RefSB and EV_500m_Aggr1km_RefSB fields were set to fill values when SDSs EV_250m and EV_500m are absent in L1A file Logic was added to skip the processing and turn off the output of the L1B QKM and HKM EV data when EV_250m and EV_500m are absent from L1A In this the new process avoids accessing and reading the and L1A EV skips and writing to the L1B and EV omits reading and subsampling SDSs from geolocation file and writing them to the L1B and omits writing metadata to L1B and EV and skips closing the L1A and L1B EV and SDSs Logic was added to turn off the L1B OBC output when the high resolution OBC SDSs are absent from L1A This is accomplished by skipping the openning the writing of metadata and the closing of the L1B OBC hdf which is Bit in the scan by scan bit QA has been changed Until now

Definition: HISTORY.txt:361

pbuf

This should be set to the NetCDF standard name if exists for this product Create a function that computes your product edit get_myprod c add prototype to l12_proto h add get_myprod c to add_executable for l2gen and l3gen in CMakeLists txt Add an entry to the output routine to call your function edit prodgen c edit function prodgen() case CAT_myprod pbuf

Definition: HOWTO_Add_a_product.txt:128

idDS

Definition: dfutils.h:28

lon

float * lon

Definition: l1_hmodis_hdf.c:755

read9km_mask

int read9km_mask(char *file, char *mask)

Definition: read9km_mask.c:25

convl21

int convl21(l2str *l2rec, tgstr *tgrec, int32_t spix, int32_t epix, float *vLt, vcstr *vrec)

Definition: convl21.c:15

epix

int32 epix

Definition: l1_czcs_hdf.c:23

alloc_l1

int32_t alloc_l1(filehandle *l1file, l1str *l1rec)

Definition: alloc_l1.c:15

calfile_close

int calfile_close(idDS ds_id)

Definition: calfile_utils.c:210

endDS

int endDS(idDS ds_id)

Definition: wrapper.c:634

calfile_open

idDS calfile_open(char *ofile, int sensorID, int ydim, int xdim, int nprods, int nvars1d, char l2prods[L1_MAXPROD][32], char vars1Dnames[L1_MAXPROD][32], long *numExistingRecords, caltype ctype)

Definition: calfile_utils.c:48

aots

float *** aots

Definition: main_l1det2det.c:45

int i

Definition: decode_rs.h:71

openl1

int openl1(filehandle *l1file)

Definition: l1_io.c:207

strcpy

How many dimensions is the output array Default is Not sure if anything above will work correctly strcpy(l2prod->title, "no title yet")

FIXAOT