NASA Ocean Color

ocssw V2022

 // =====================================================================
 // l3gen - level-3 to level-3 ocean algorithm processor                 
 // B. Franz, NASA/OBPG, August 2008            
 //                         
 // Modification History
 // --------------------
 // Use hdf_bin class rather than hdf4_bin class
 // J. Gales     Futuretech     07/18/11
 // =====================================================================
  
 #include <stdio.h>
 #include <math.h>
 #include <iostream>
 #include <sstream>
 #include <list>
 #include "netcdf.h"
 #include "hdf_bin.h"
 #include "version.h"
  
 #define NBINREAD MAXPIX
 #define FLAGMASK PRODFAIL
  
 #include "l12_proto.h"
  
  
 using namespace std;
  
 typedef Hdf::binListStruct blstr;
  
 void l3gen_usage(char *prog) {
     l2gen_usage("l3gen");
 }
  
 void load_l3file_handle(int sensorID, int filenum, filehandle *file) {
     strcpy(file->name, (const char *) input->ofile[filenum]);
     strcpy(file->l2prod, (const char *) input->l2prod[filenum]);
     strcpy(file->def_l2prod, input->def_l2prod[filenum]);
  
     file->format = FT_L3BIN;
     file->mode = WRITE;
     file->sensorID = sensorID;
  
     file->tot_prod = prodlist(file->sensorID, l1_input->evalmask, file->l2prod,
             file->def_l2prod, file->l2_prod_names);
 }
  
 void load_input_filehandle(filehandle *l1file) {
     int32 sensorID = l1file->sensorID;
     int32 evalmask = l1_input->evalmask;
  
     l1file->nbands = rdsensorinfo(sensorID, evalmask, NULL, NULL);
     l1file->nbandsir = rdsensorinfo(sensorID, evalmask, "NbandsIR", NULL);
     l1file->ndets = 1;
  
     rdsensorinfo(sensorID, evalmask, "Bindx", (void **) &l1file->bindx);
     rdsensorinfo(sensorID, evalmask, "Lambda", (void **) &l1file->iwave);
     rdsensorinfo(sensorID, evalmask, "fwave", (void **) &l1file->fwave);
     rdsensorinfo(sensorID, evalmask, "Fobar", (void **) &l1file->Fobar);
     rdsensorinfo(sensorID, evalmask, "Tau_r", (void **) &l1file->Tau_r);
     rdsensorinfo(sensorID, evalmask, "k_oz", (void **) &l1file->k_oz);
     rdsensorinfo(sensorID, evalmask, "k_no2", (void **) &l1file->k_no2);
     rdsensorinfo(sensorID, evalmask, "aw", (void **) &l1file->aw);
     rdsensorinfo(sensorID, evalmask, "bbw", (void **) &l1file->bbw);
  
     bindex_set(l1file->iwave, l1file->nbands + l1file->nbandsir, BANDW);
  
     if ((l1file->Fonom = (float*) calloc(l1file->nbands, sizeof (float))) == NULL) {
         printf("-E- (%s, %d) Cannot allocate space for l1file->Fonom\n", __FILE__, __LINE__);
         exit(EXIT_FAILURE);
     }
     int i;
     for (i = 0; i < l1file->nbands; i++) {
         if (l1_input->outband_opt >= 2) {
             get_f0_thuillier_ext(l1file->iwave[i], BANDW, l1file->Fonom + i);
         } else {
             l1file->Fonom[i] = l1file->Fobar[i];
         }
     }
  
 }
  
 void load_l12(l2str *l2rec) {
     int32 iw;
  
     l1str* l1rec = l2rec->l1rec;
     filehandle* l1file = l1rec->l1file;
     int32 nbands = l1file->nbands;
  
     //memset(l1rec->data, 0, l1rec->length);
     //memset(l2rec->data, 0, l2rec->length);
  
     for (iw = 0; iw < nbands; iw++) {
         l1rec->Fo[iw] = l1file->Fobar[iw]; // for the moment
     }
  
     l1rec->tilt = 0.0;
     l1rec->mside = 0;
     l1rec->detnum = 0;
  
     int ip;
     for (ip = 0; ip < l1rec->npix; ip++) {
         l1rec->pixnum[ip] = 0;
         l1rec->alpha[ip] = 0.0;
         l1rec->flags[ip] = 0;
         l1rec->mask[ip] = 0;
     }
  
 }
  
 // -------------------------------------------------------------------- 
 //                            main                                      
 // -------------------------------------------------------------------- 
  
 int main(int argc, char* argv[]) {
     static l1str *l1rec; // generic level-1b scan structure
     static l2str *l2rec; // generic level-2  scan structure
     static filehandle ifile; // input file handle 
     static filehandle ofile; // output file handle 
     int iprod;
  
     char *ptime = ydhmsf(now(), 'G');
     double start_time = now();
  
     int16 year, day;
     int32_t syear;
     int32_t sday;
     double dsec;
     double mtime;
  
     char soft_id[200];
     float gmt;
     float solz;
     float sola;
     char buf[FILENAME_MAX];
  
     int i;
     int ip;
     int offset;
     int64_t bin_num;
     int nobs;
     int nscenes;
     int nwrite;
     static bool atLeastOne = false;
     int mainReturnCode = EXIT_SUCCESS;
  
     char units_string[MD_ATTRSZ];
  
     if (argc == 1) {
         l3gen_usage(argv[0]);
         return EXIT_SUCCESS;
     }
  
     // see if help on command line
     for (i = 0; i < argc; i++) {
         if ((strcmp(argv[i], "-h") == 0) || (strcmp(argv[i], "-help") == 0)) {
             l3gen_usage(argv[0]);
             return EXIT_SUCCESS;
         }
     }
  
     setvbuf(stdout, NULL, _IOLBF, 0);
     setvbuf(stderr, NULL, _IOLBF, 0);
  
     // Initialize file handles
     msl12_input_init();
  
     // cdata_();
     filehandle_init(&ifile);
     filehandle_init(&ofile);
  
     // Parse input parameters
     if (msl12_input(argc, argv, "l3gen", &ifile) != 0) {
         printf("-E- %s: Error parsing input parameters.\n", argv[0]);
         exit(1);
     }
  
     load_input_filehandle(&ifile);
  
     char proc_con[2048];
     strcpy(proc_con, basename(argv[0]));
     for (i = 1; i < argc; i++) {
         strcat(proc_con, " ");
         strcat(proc_con, argv[i]);
     }
  
     // Transfer input info to file handles
     load_l3file_handle(ifile.sensorID, 0, &ofile);
  
     // Build output product list
  
     cout << endl << "The following products will be included in " << ofile.name
             << endl;
     int32 nprods_out = ofile.tot_prod;
     char prodlist_out[L1_PRODSTRLEN] = "";
     for (iprod = 0; iprod < ofile.tot_prod; iprod++) {
         cout << iprod + 1 << " " << ofile.l2_prod_names[iprod] << endl;
         strcat(prodlist_out, ofile.l2_prod_names[iprod]);
         if (iprod < ofile.tot_prod - 1)
             strcat(prodlist_out, ",");
     }
  
     // Open input binfile and get full input product list
  
     static Hdf::hdf_bin *input_binfile;
     const char *inputfile;
  
     inputfile = input->ifile[0];
     input_binfile = Hdf::openBinObject(inputfile);
  
     int len = input_binfile->query();
     char *fullprodlist = (char *) malloc(len);
     input_binfile->query(fullprodlist);
     int nrows = input_binfile->nrows;
  
     // Get input bin dimension
     int32 npix = NBINREAD;
  
     // Get mean time
     mtime = (input_binfile->meta_l3b.startTime + input_binfile->meta_l3b.endTime) / 2.0;
  
     unix2yds(mtime, &year, &day, &dsec);
     //yes, silly, but easier than fixing the various routines that need either a 16 or 32bit int for year/day
     syear = year;
     sday = day;
  
     // Allocate memory for L1 and L2 scan data (the L2 record shares
     // space with the L1 record, hence we need to allocate both)
     l1rec = (l1str*) malloc(sizeof (l1str));
     l2rec = (l2str*) malloc(sizeof (l2str));
  
     ifile.npix = npix;
     ifile.nscan = 1;
     if (alloc_l1(&ifile, l1rec) == 0) {
         printf("-E- %s: Unable to allocate L1 record.\n", argv[0]);
         exit(1);
     }
     if (alloc_l2(l1rec, l2rec) == 0) {
         printf("-E- %s: Unable to allocate L2 record.\n", argv[0]);
         exit(1);
     }
  
     // Add meta-data to L1 and L2 structures - use a single pixel just to get things
     // started - load_l12 will be called for each bin row with an appropriate # of pixels
     load_l12(l2rec);
  
     // Build input product request list
  
     int32 n_vvv = MIN(windex(700., ifile.fwave, ifile.nbands) + 1, ifile.nbands);
     char prodstr[L1_PRODSTRLEN] = "";
  
     //   what we have
  
     char **prodlist_in;
     int32 nprods_in = input_binfile->query(&prodlist_in);
  
     //   what we want
  
     char prodlist_wt[L1_MAXPROD][32];
     int32 nprods_wt = prodlist(ifile.sensorID, l1_input->evalmask,
             "Rrs_vvv nLw_vvv Rrs_vc_vvv solz sola senz sena relaz", "",
             prodlist_wt);
  
     enum geo_order {
         SOLZ, SOLA, SENZ, SENA, RELAZ
     };
  
     //   what we have that we want
  
     int32 *rrs_bindex;
     int32 *rrs_windex;
     int32 n_rrs = 0;
     int32 *nlw_bindex;
     int32 *nlw_windex;
     int32 n_nlw = 0;
     int32 geo_bindex[5];
     int32 geo_windex[5];
     int32 n_geo = 0;
     int32 have_solz = 0;
     int32 have_sola = 0;
     int32 have_sena = 0;
     int32 have_relaz = 0;
  
     if ((rrs_bindex = (int32 *) malloc(ifile.nbands * sizeof (int32))) == NULL) {
         printf("-E- %s: Error allocating memory to the input data array.\n",
                 argv[0]);
         exit(FATAL_ERROR);
     }
     if ((rrs_windex = (int32 *) malloc(ifile.nbands * sizeof (int32))) == NULL) {
         printf("-E- %s: Error allocating memory to the input data array.\n",
                 argv[0]);
         exit(FATAL_ERROR);
     }
     if ((nlw_bindex = (int32 *) malloc(ifile.nbands * sizeof (int32))) == NULL) {
         printf("-E- %s: Error allocating memory to the input data array.\n",
                 argv[0]);
         exit(FATAL_ERROR);
     }
     if ((nlw_windex = (int32 *) malloc(ifile.nbands * sizeof (int32))) == NULL) {
         printf("-E- %s: Error allocating memory to the input data array.\n",
                 argv[0]);
         exit(FATAL_ERROR);
     }
  
     cout << endl << "Checking input for desired products: " << endl;
     iprod = 0;
     for (int32 iwant = 0; iwant < nprods_wt; iwant++) {
         for (int32 ihave = 0; ihave < nprods_in; ihave++) {
             if (strcmp(prodlist_in[ihave], prodlist_wt[iwant]) == 0) {
                 strcat(prodstr, prodlist_in[ihave]);
                 strcat(prodstr, ",");
                 cout << "found " << prodlist_wt[iwant] << endl;
                 if (iwant < n_vvv) {
                     rrs_bindex[n_rrs] = iprod; // posiiton in bin read
                     rrs_windex[n_rrs] = iwant; // position in sensor wavelengths
                     n_rrs++;
                     iprod++;
                 } else if (iwant < n_vvv * 2) {
                     nlw_bindex[n_nlw] = iprod; // positon in bin read
                     nlw_windex[n_nlw] = iwant - n_vvv; // position in sensor wavelengths
                     n_nlw++;
                     iprod++;
                 } else if (iwant < n_vvv * 3) { // Rrs_vc products overwriting Rrs
                     rrs_bindex[n_rrs] = iprod; // posiiton in bin read
                     rrs_windex[n_rrs] = iwant - 2 * n_vvv; // position in sensor wavelengths
                     n_rrs++;
                     iprod++;
                 } else {
                     geo_bindex[n_geo] = iprod;
                     geo_windex[n_geo] = iwant - 3 * n_vvv;
                     switch (geo_windex[n_geo]) {
                     case SOLZ:
                         have_solz = 1;
                         break;
                     case SOLA:
                         have_sola = 1;
                         break;
                     case SENA:
                         have_sena = 1;
                         break;
                     case RELAZ:
                         have_relaz = 1;
                         break;
                     }
                     n_geo++;
                     iprod++;
                 }
                 break;
             }
         }
     }
     nprods_in = iprod;
  
     // remove trailing comma
     len = strlen(prodstr);
     prodstr[len - 1] = '\0';
  
     // Allocate data arrays and bin list and masking flag
     float **outData;
     float **tmpData;
     float **inData;
     if ((inData = (float **) malloc(nprods_in * sizeof (float *))) == NULL) {
         printf("-E- %s: Error allocating memory to the input data array.\n",
                 argv[0]);
         exit(FATAL_ERROR);
     }
     if ((outData = (float **) malloc(nprods_out * sizeof (float *))) == NULL) {
         printf("-E- %s: Error allocating memory to the output data array.\n",
                 argv[0]);
         exit(FATAL_ERROR);
     }
     if ((tmpData = (float **) malloc(nprods_out * sizeof (float *))) == NULL) {
         printf("-E- %s: Error allocating memory to the temp data array.\n",
                 argv[0]);
         exit(FATAL_ERROR);
     }
     for (i = 0; i < nprods_in; i++) {
         if ((inData[i] = (float *) calloc(2 * npix, sizeof (float))) == NULL) {
             printf("-E- %s: Error allocating memory to the output data array.\n",
                     argv[0]);
             exit(FATAL_ERROR);
         }
     }
     for (i = 0; i < nprods_out; i++) {
         if ((outData[i] = (float *) calloc(2 * npix, sizeof (float))) == NULL) {
             printf(
                     "-E- %s: Error allocating memory to the output data array.\n",
                     argv[0]);
             exit(FATAL_ERROR);
         }
         if ((tmpData[i] = (float *) calloc(npix, sizeof (float))) == NULL) {
             printf(
                     "-E- %s: Error allocating memory to the output data array.\n",
                     argv[0]);
             exit(FATAL_ERROR);
         }
     }
     char *outMask = (char *) calloc(npix, sizeof (char));
  
     // set up the bin file reading for the products we need
     input_binfile->read(prodstr);
  
     /* Create output file */
     /* ------------------ */
     Hdf::hdf_bin *output_binfile;
  
     /*
      * If the input structure does not set the output format,
      * make the output format match the input L3 format
      */
     if (getFileFormatName(input->oformat) == NULL) {
         if (input_binfile->isHDF5) {
             strcpy(input->oformat, "HDF5");
         } else if (input_binfile->isCDF4) {
             strcpy(input->oformat, "netCDF4");
         } else {
             strcpy(input->oformat, "HDF4");
         }
     }
  
     if (strcmp(input->oformat, "HDF4") == 0) {
         output_binfile = new Hdf::hdf4_bin;
         output_binfile->hasNoext = true;
     }
     if (strcmp(input->oformat, "HDF5") == 0)
         output_binfile = new Hdf::hdf5_bin;
     if (strcmp(input->oformat, "netCDF4") == 0)
         output_binfile = new Hdf::cdf4_bin;
  
     output_binfile->deflate = input->deflate;
  
     strcpy(output_binfile->meta_l3b.product_name, ofile.name);
     strncpy(output_binfile->meta_l3b.ptime, ptime, 16);
     strcpy(output_binfile->meta_l3b.proc_con, proc_con);
     strcpy(output_binfile->meta_l3b.input_parms, l1_input->input_parms);
  
     char* tmpProdNames[ofile.tot_prod];
     for (int i = 0; i < ofile.tot_prod; i++) {
         tmpProdNames[i] = ofile.l2_prod_names[i];
     }
     output_binfile->setProductList(ofile.tot_prod, tmpProdNames);
     output_binfile->create(ofile.name, input_binfile->nrows);
  
     // Begin processing
     for (int32 iscan = 0; iscan < nrows; iscan++) {
         if (iscan % 50 == 0) {
             int secs = (int) now() - start_time;
             cout << "Reading row " << iscan << " of " << nrows << " after " << secs << " seconds" << endl;
         }
         // Read the inputs
         // Get basebin and numbin for this input row
         int64_t basebin = input_binfile->get_basebin(iscan);
         input_binfile->readBinIndex(iscan);
         int ext = input_binfile->get_ext();
         int64_t beg = input_binfile->get_beg();
         // if the row has no filled bins, skip it
         if (beg == 0)
             continue;
  
         input_binfile->readBinList(ext);
  
         // fill the input data array with the necessary input data
         i = 0;
         for (int j = 0; j < input_binfile->nprod(); j++) {
  
             if (input_binfile->active_data_prod[j] == true) {
                 input_binfile->get_prodname(j, buf);
                 if (strcmp(prodlist_in[j], buf) == 0) {
                     input_binfile->readSums(inData[i], ext, j);
                     i++;
                 }
             }
         }
         if (input_binfile->isHDF5 || input_binfile->isCDF4)
             input_binfile->setDataPtr(ext);
  
  
         // Stuff the L2 record
         // only process as many pixels as the row as filled bins
         l1rec->npix = ext;
         ifile.npix = ext;
         ifile.epix = ext - 1;
         ifile.terrain_corrected = 1;
  
         memset(outMask, '\0', npix);
         init_l1(l1rec);
         init_l2(l2rec, ifile.nbands);
  
         load_l12(l2rec);
  
         l1rec->iscan = iscan;
         l1rec->scantime = mtime;
  
         // Fill in the l1/2 structures with data from input bin file
         // nLw, Rrs, geometries - if available.
         for (ip = 0; ip < ext; ip++) {
             float weight = input_binfile->get_weights(ip);
             int32 ipw;
             float lat;
             float lon;
             float flat, flon;
  
             bin_num = input_binfile->get_bin_num(ip);
             input_binfile->bin2latlon(bin_num, lat, lon);
             l1rec->lon[ip] = lon;
             l1rec->lat[ip] = lat;
             l1rec->nobs[ip] = input_binfile->get_nobs(ip);
             for (int32 iw = 0; iw < n_nlw; iw++) {
                 ipw = ip * ifile.nbands + nlw_windex[iw];
                 l2rec->nLw[ipw] = inData[nlw_bindex[iw]][2 * ip] / weight;
                 l2rec->Rrs[ipw] = MAX(l2rec->nLw[ipw] / ifile.Fonom[iw], BAD_FLT);
             }
             for (int32 iw = 0; iw < n_rrs; iw++) {
                 ipw = ip * ifile.nbands + rrs_windex[iw];
                 l2rec->Rrs[ipw] = inData[rrs_bindex[iw]][2 * ip] / weight;
                 l2rec->nLw[ipw] = MAX(l2rec->Rrs[ipw] * ifile.Fonom[iw], BAD_FLT);
             }
             l1rec->solz[ip] = 0.0;
             l1rec->sola[ip] = 0.0;
             l1rec->senz[ip] = 0.0;
             l1rec->sena[ip] = 90.0;
             l1rec->delphi[ip] = 90.0;
  
             for (int32 iw = 0; iw < n_geo; iw++) {
                 switch (geo_windex[iw]) {
                 case SOLZ:
                     l1rec->solz[ip] = inData[geo_bindex[iw]][2 * ip] / weight;
                     break;
                 case SOLA:
                     l1rec->sola[ip] = inData[geo_bindex[iw]][2 * ip] / weight;
                     break;
                 case SENZ:
                     l1rec->senz[ip] = inData[geo_bindex[iw]][2 * ip] / weight;
                     break;
                 case SENA:
                     l1rec->sena[ip] = inData[geo_bindex[iw]][2 * ip] / weight;
                     break;
                 case RELAZ:
                     l1rec->delphi[ip] = inData[geo_bindex[iw]][2 * ip] / weight;
                     break;
                 }
             }
             if (!have_solz) {
                 // assume noon orbit
                 flon = l1rec->lon[ip];
                 flat = l1rec->lat[ip];
                 gmt = 12 - lon / 15;
                 sunangs_(&syear, &sday, &gmt, &flon, &flat, &solz, &sola);
                 l1rec->solz[ip] = solz;
                 l1rec->sola[ip] = sola;
             }
             if (have_sola && have_sena && !have_relaz) {
                 l1rec->delphi[ip] = l1rec->sena[ip] - 180.0 - l1rec->sola[ip];
                 if (l1rec->delphi[ip] < -180)
                     l1rec->delphi[ip] += 360.0;
             } else if (!have_sola && !have_sena && have_relaz) {
                 l1rec->sena[ip] = 90.0;
                 l1rec->sola[ip] = l1rec->sena[ip] - 180.0
                         - l1rec->delphi[ip];
                 if (l1rec->sola[ip] < -180)
                     l1rec->sola[ip] += 360.0;
             }
         }
  
         // Add ancillary, Rayleigh, etc.
         loadl1(&ifile, l1rec);
  
         // clear out the masks
         for (ip = 0; ip < ext; ip++)
             l1rec->mask[ip] = 0;
  
         // Add a default chl
  
         for (ip = 0; ip < ext; ip++)
             l2rec->chl[ip] = get_default_chl(l2rec, &l2rec->Rrs[ip * ifile.nbands]);
  
         // Add default inherent optical properties
  
         if (input->iop_opt > 0 && (input->proc_ocean != 0))
             get_iops(l2rec, input->iop_opt);
  
         // Compute output products and store in temporary buffer
  
         for (iprod = 0; iprod < nprods_out; iprod++) {
  
             // get the product index record
             for (i = 0; i < ext; i++)
                 tmpData[iprod][i] = BAD_FLT;
  
             l2prodstr *p;
  
             if ((p = get_l2prod_index(ofile.l2_prod_names[iprod],
                     ifile.sensorID, ifile.nbands + ifile.nbandsir, ext,
                     ifile.nscan, ifile.iwave)) == NULL) {
                 printf("-E- %s line %d: product index failure.\n", __FILE__,
                         __LINE__);
                 exit(1);
             };
  
             // Compute or extract the product & copy to output buffer
  
             VOIDP pbuf = prodgen(p, l2rec);
  
             // build the units attribute string
  
             productInfo_t *p_info;
             p_info = allocateProductInfo();
  
             if (!findProductInfo(ofile.l2_prod_names[iprod], ifile.sensorID, p_info)) {
                 printf("-E- product %s not found in XML product table\n",
                         ofile.l2_prod_names[iprod]);
                 exit(EXIT_FAILURE);
             }
  
             if (iprod == 0){
                 strcpy(units_string,getProductNameFull(p_info));
                 strcat(units_string,":");
                 strcat(units_string,p->units);
             }
             else {
                 strcat(units_string,getProductNameFull(p_info));
                 strcat(units_string,":");
                 strcat(units_string,p->units);
             }
             if (iprod < nprods_out -1)
                 strcat(units_string,",");
  
             freeProductInfo(p_info);
  
             memcpy(tmpData[iprod], (float *) pbuf,
                     ext * sizeof (float));
  
             // Check flags and set masking
  
             for (ip = 0; ip < ext; ip++) {
                 if ((tmpData[iprod][ip] == BAD_FLT)
                         || (l1rec->flags[ip] & FLAGMASK) != 0) {
                     outMask[ip] = 1;
                 }
             }
  
         }
  
         /* Write output */
         /* ------------ */
         output_binfile->clear_binlist();
         nwrite = 0;
  
         for (ip = 0; ip < ext; ip++) {
             if (!outMask[ip]) {
                 atLeastOne = true;
                 bin_num = input_binfile->get_bin_num(ip);
                 offset = bin_num - basebin;
                 output_binfile->set_bin_num(offset, bin_num);
                 nobs = input_binfile->get_nobs(ip);
                 output_binfile->inc_nobs(offset, nobs);
                 nscenes = input_binfile->get_nscenes(ip);
                 output_binfile->inc_nscenes(offset, nscenes);
                 output_binfile->set_weights(offset, 1);
  
                 /* Loop over data products */
                 /* ----------------------- */
                 for (iprod = 0; iprod < nprods_out; iprod++) {
                     outData[iprod][2 * nwrite] = tmpData[iprod][ip];
  
                 } /* iprod loop */
                 if (nwrite != offset)
                     output_binfile->copy_binlist(offset, nwrite);
  
                 nwrite++;
             }
         } /* ip loop */
  
  
         /* Write BinList & Data Products */
         /* ----------------------------- */
         if (nwrite > 0) {
             output_binfile->writeBinList(nwrite);
             for (iprod = 0; iprod < nprods_out; iprod++) {
                 strcpy(buf, ofile.l2_prod_names[iprod]);
                 output_binfile->writeSums(outData[iprod], nwrite, buf);
             }
  
             if (strcmp(input->oformat, "HDF5") == 0
                     || strcmp(input->oformat, "netCDF4") == 0)
                 output_binfile->incNumRec(nwrite);
         }
     }
  
     output_binfile->copymeta(1, &input_binfile);
     if (strcmp(input->oformat, "netCDF4")) {
         strcpy(output_binfile->meta_l3b.sensor, sensorId2InstrumentName(ifile.sensorID));
     } else {
         strcpy(output_binfile->meta_l3b.sensor_name, sensorId2SensorName(ifile.sensorID));
     }
     strcpy(output_binfile->meta_l3b.mission, sensorId2PlatformName(ifile.sensorID));
     strcpy(output_binfile->meta_l3b.infiles, basename((char *) input->ifile[0]));
     strcpy(output_binfile->meta_l3b.soft_name, "l3gen");
     sprintf(soft_id, "%d.%d.%d-%s", VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH, GITSHA);
     strcpy(output_binfile->meta_l3b.soft_ver, soft_id);
     if (strcmp(input->oformat, "netCDF4") == 0) {
         ptime = unix2isodate(now(), 'G');
         strcpy(output_binfile->meta_l3b.ptime, ptime);
     } else {
         strcpy(output_binfile->meta_l3b.ptime, ptime);
  
     }
     strcpy(output_binfile->meta_l3b.proc_con, proc_con);
     //update units attribute to match the output products
     strcpy(output_binfile->meta_l3b.units,units_string);
     // Some missions have suites with DOIs and keywords...
  
     strcpy(output_binfile->meta_l3b.doi, input->doi);
     //if suite is somehow NOT set, clear it out as it's better than lying
     // since we copy from the source
     strcpy(output_binfile->meta_l3b.keywords, "");
     if (input->suite[0]) {
         const char* keywordStr = getGCMDKeywords(input->suite);
         if (keywordStr) {
              strcpy(output_binfile->meta_l3b.keywords, keywordStr);
         }
     }
  
     // Close files and free memory
     if (atLeastOne == false) {
         cout << "No valid bins to output!" << endl << "...seems a selected product may have resulted in 100% PRODFAIL..." << endl;
         mainReturnCode = 110;  // no bins filled
     }
     output_binfile->close();
     delete(output_binfile);
     input_binfile->close();
     delete(input_binfile);
  
     free(fullprodlist);
  
     for (i = 0; i < nprods_in; i++)
         free(inData[i]);
     free(inData);
  
     free(outMask);
  
     for (i = 0; i < nprods_out; i++) {
         free(outData[i]);
         free(tmpData[i]);
     }
     free(outData);
     free(tmpData);
  
     free_l1(l1rec);
     free_l2(l2rec);
     free(l1rec);
     free(l2rec);
     // free input internals
     for(i=0;i<input->fctl.nfilt; i++)
         free(input->fctl.f[i].kernel);
     free(input->gsm_aphs);
     free(input->gsm_aphw);
     free(input->giop_wave);
     free(input->giop_rrs_unc);
     free(input->taua);
     free(input->vcal_nLw);
     free(input->vcal_Lw);
     free(input);
  
     free(rrs_bindex);
     free(rrs_windex);
     free(nlw_bindex);
     free(nlw_windex);
  
     cout << "Processing Complete at " << ptime << endl << endl;
  
     return (mainReturnCode);
 }
  

ydhmsf

char * ydhmsf(double dtime, char zone)

Definition: ydhmsf.c:12

Hdf::hdf_bin::get_bin_num

virtual int64_t get_bin_num(int kbin)=0

L1_MAXPROD

#define L1_MAXPROD

Definition: filehandle.h:20

Hdf::hdf_bin::get_nobs

virtual int get_nobs(int kbin)=0

Hdf::hdf_bin::bin2latlon

virtual void bin2latlon(int64_t bin_num, float &lat, float &lon)

Definition: hdf_bin.h:80

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:25

cubeio::int16

integer, parameter int16

Definition: cubeio.f90:3

bindex_set

void bindex_set(int32_t wave[], int nwave, int dwave_vswir)

Definition: windex.c:15

meta_l3bType::product_name

char product_name[SM_ATTRSZ]

Definition: meta_l3b.h:16

MIN

#define MIN(x, y)

Definition: rice.h:169

aquaverse.ofile

ofile

Definition: aquaverse.py:16

EXIT_SUCCESS

#define EXIT_SUCCESS

Definition: GEO_basic.h:72

meta_l3bType::units

char units[MD_ATTRSZ]

Definition: meta_l3b.h:28

freeProductInfo

void freeProductInfo(productInfo_t *info)

Definition: productInfo.cpp:145

int j

Definition: decode_rs.h:73

getGCMDKeywords

const char * getGCMDKeywords(const char *suite)

Definition: getGCMDKeywords.cpp:15

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:4359

Hdf::hdf_bin::readSums

virtual int readSums(float *sums, int32_t nbins_to_read, int iprod)=0

free_l2

void free_l2(l2str *l2rec)

Definition: alloc_l2.c:7

FLAGMASK

#define FLAGMASK

Definition: main_l3gen.cpp:21

Hdf::hdf_bin::setProductList

virtual void setProductList(int numProducts, char *prodNames[])

Definition: bin_io.cpp:2807

Hdf::binListStruct

Definition: bin_util.h:54

meta_l3bType::infiles

char infiles[LG_ATTRSZ]

Definition: meta_l3b.h:38

l1mapgen.stdout

stdout

Definition: l1mapgen.py:204

VERSION_MINOR

#define VERSION_MINOR

Definition: version.h:2

NULL

#define NULL

Definition: decode_rs.h:63

filehandle_init

void filehandle_init(filehandle *file)

Definition: filehandle_init.c:43

meta_l3bType::mission

char mission[SM_ATTRSZ]

Definition: meta_l3b.h:21

Hdf::openBinObject

hdf_bin * openBinObject(const char *binFileName)

Definition: bin_io.cpp:32

l1rec

read l1rec

Definition: HOWTO_Add_a_sensor.txt:72

meta_l3bType::keywords

char keywords[SM_ATTRSZ]

Definition: meta_l3b.h:55

NBINREAD

#define NBINREAD

Definition: main_l3gen.cpp:20

load_l3file_handle

void load_l3file_handle(int sensorID, int filenum, filehandle *file)

Definition: main_l3gen.cpp:34

Hdf::hdf_bin::create

virtual int create(const char *l3b_filename, int32_t nrows)=0

nrows

int32 nrows

Definition: get_dem_height.c:11

meta_l3bType::input_parms

char input_parms[LG_ATTRSZ]

Definition: meta_l3b.h:36

sensorId2PlatformName

const char * sensorId2PlatformName(int sensorId)

Definition: sensorInfo.c:301

GITSHA

#define GITSHA

Definition: version.h:4

VERSION_PATCH

#define VERSION_PATCH

Definition: version.h:3

syear

int syear

Definition: l1_czcs_hdf.c:15

msl12_input_init

void msl12_input_init()

Definition: msl12_input.c:495

Hdf::hdf_bin::close

virtual int close()=0

spacetrack_tles.ext

ext

Definition: spacetrack_tles.py:188

load_input_filehandle

void load_input_filehandle(filehandle *l1file)

Definition: main_l3gen.cpp:47

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 L2GEN_PRODUCT_FILES 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:127

Hdf::hdf_bin::active_data_prod

bool active_data_prod[MAXNVDATA]

Definition: hdf_bin.h:123

Hdf::hdf_bin::get_beg

virtual int64_t get_beg()=0

Hdf::hdf_bin::copy_binlist

virtual int copy_binlist(int src, int dest)=0

l2gen_usage

int l2gen_usage(const char *prog)

Definition: msl12_input.c:4414

Hdf::hdf_bin::get_nscenes

virtual int get_nscenes(int kbin)=0

hico.proc_hico.solz

solz

Definition: proc_hico.py:240

nobs

int32_t nobs

Definition: atrem_cor.h:93

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

VERSION_MAJOR

#define VERSION_MAJOR

Definition: version.h:1

input

instr * input

Definition: main_l2binmatch.cpp:27

seadasutils.ProcUtils.mtime

def mtime(the_file)

Definition: ProcUtils.py:344

l12_proto.h

sday

int sday

Definition: l1_czcs_hdf.c:15

prodlist

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

Hdf::hdf_bin::get_ext

virtual int get_ext()=0

Hdf::hdf_bin::query

virtual int query()

Definition: bin_io.cpp:2764

Hdf::hdf_bin::hasNoext

bool hasNoext

Definition: hdf_bin.h:129

meta_l3bType::sensor

char sensor[SM_ATTRSZ]

Definition: meta_l3b.h:23

MDN.parameters.int

int

Definition: parameters.py:18

alloc_l2

int alloc_l2(l1str *l1rec, l2str *l2rec)

Definition: alloc_l2.c:17

run_local.lat

lat

Definition: run_local.py:69

sunangs_

void sunangs_(int *, int *, float *, float *, float *, float *, float *)

Definition: sunangs.c:25

run_local.lon

lon

Definition: run_local.py:69

Hdf::hdf_bin

Definition: hdf_bin.h:14

meta_l3bType::endTime

double endTime

Definition: meta_l3b.h:40

Hdf::hdf_bin::set_weights

virtual int set_weights(int offset, float weights)=0

Hdf::hdf_bin::copymeta

virtual int copymeta(int32_t nfiles, Hdf::hdf_bin *input_binfile[])

Definition: bin_io.cpp:2874

allocateProductInfo

productInfo_t * allocateProductInfo()

Definition: productInfo.cpp:133

getFileFormatName

const char * getFileFormatName(const char *str)

Definition: fileFormatUtils.c:205

Hdf::hdf_bin::get_basebin

virtual int64_t get_basebin(int irow)

Definition: hdf_bin.h:76

Hdf::hdf_bin::nrows

int32_t nrows

Definition: hdf_bin.h:121

Hdf::hdf_bin::nprod

virtual int32_t nprod()

Definition: hdf_bin.h:110

oci_hdr_strip.argc

argc

Definition: oci_hdr_strip.py:7

get_iops

void get_iops(l2str *l2rec, int32_t iop_opt)

Definition: convl12.c:118

l1_input

l1_input_t * l1_input

Definition: l1_options.c:9

L1_PRODSTRLEN

#define L1_PRODSTRLEN

Definition: filehandle.h:19

FATAL_ERROR

#define FATAL_ERROR

Definition: swl0_parms.h:5

Hdf::hdf_bin::meta_l3b

meta_l3bType meta_l3b

Definition: hdf_bin.h:133

init_l2

void init_l2(l2str *l2rec, int32_t nbands)

Definition: init_l2.c:11

unix2yds

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

Hdf::hdf_bin::isCDF4

bool isCDF4

Definition: hdf_bin.h:127

Hdf::hdf_bin::incNumRec

virtual int incNumRec(int n_write)=0

Hdf::hdf_bin::writeSums

virtual int writeSums(float *sums, int32_t nbins_to_write, const char *prodname)=0

main

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

Definition: main_l3gen.cpp:114

Hdf::hdf_bin::setDataPtr

virtual int setDataPtr(int nbins_to_read)=0

version.h

hdf_bin.h

free_l1

void free_l1(l1str *l1rec)

Definition: alloc_l1.c:7

basename

#define basename(s)

Definition: l0chunk_modis.c:29

WRITE

#define WRITE

Definition: create_Vdata.c:7

findProductInfo

int findProductInfo(const char *productName, int sensorId, productInfo_t *info)

Definition: productInfo.cpp:983

meta_l3bType::doi

char doi[SM_ATTRSZ]

Definition: meta_l3b.h:54

Hdf::cdf4_bin

Definition: hdf_bin.h:460

Hdf::hdf4_bin

Definition: hdf_bin.h:136

hico.proc_hico.sola

sola

Definition: proc_hico.py:242

BAD_FLT

#define BAD_FLT

Definition: jplaeriallib.h:19

init_l1

void init_l1(l1str *l1rec)

Definition: init_l1.c:11

get_default_chl

float get_default_chl(l2str *l2rec, float Rrs[])

Definition: get_chl.c:679

Hdf::hdf_bin::get_prodname

virtual int get_prodname(int iprod, char *prodname)

Definition: bin_io.cpp:2802

meta_l3bType::proc_con

char proc_con[MD_ATTRSZ]

Definition: meta_l3b.h:35

load_l12

void load_l12(l2str *l2rec)

Definition: main_l3gen.cpp:82

getProductNameFull

char * getProductNameFull(productInfo_t *info)

Definition: productInfo.cpp:1022

nbands

int32_t nbands

Definition: atrem_corl1v3.h:190

sensorId2SensorName

const char * sensorId2SensorName(int sensorId)

Definition: sensorInfo.c:273

MD_ATTRSZ

#define MD_ATTRSZ

Definition: meta_l3b.h:8

Hdf::hdf_bin::inc_nobs

virtual int inc_nobs(int offset, int nobs)=0

meta_l3bType::startTime

double startTime

Definition: meta_l3b.h:39

iscan

int32_t iscan

Definition: l1_hmodis_hdf.c:745

meta_l3bType::soft_ver

char soft_ver[SM_ATTRSZ]

Definition: meta_l3b.h:33

prodgen

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

Definition: prodgen.c:101

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

unix2isodate

char * unix2isodate(double dtime, char zone)

Definition: unix2isodate.c:10

sensorId2InstrumentName

const char * sensorId2InstrumentName(int sensorId)

Definition: sensorInfo.c:287

Hdf::hdf_bin::isHDF5

bool isHDF5

Definition: hdf_bin.h:126

windex

int windex(float wave, float twave[], int ntwave)

Definition: windex.c:73

strncpy

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 and prod_ix set to PARAM_TYPE_INT name_prefix is compared with the beginning of the product name If name_suffix is not empty the it must match the end of the product name The characters right after the prefix are read as an integer and prod_ix is set to that number strncpy(l2prod->name_prefix, "myprod", UNITLEN)

l3gen_usage

void l3gen_usage(char *prog)

Definition: main_l3gen.cpp:30

nscenes

int16_t * nscenes

Definition: l2bin.cpp:80

Hdf::hdf_bin::set_bin_num

virtual int set_bin_num(int offset, int64_t bin_num)=0

meta_l3bType::ptime

char ptime[SM_ATTRSZ]

Definition: meta_l3b.h:34

Hdf::hdf_bin::clear_binlist