NASA Ocean Color

ocssw V2022

 /* ============================================================================================== */
 /* aph.c - functions to compute phytoplankton-specific absorption                                 */
 /* ============================================================================================== */
  
 #include "l12_proto.h"
 #include "giop.h"
  
 /* ---------------------------------------------------------------------------------------------- */
 /* aph_bricaud() - compute aph for input wavelength and chl using Bricaud                         */
  
 /* ---------------------------------------------------------------------------------------------- */
 float aph_bricaud_1995(float wave, float chl) {
     static int firstCall = 1;
     static float *wtab;
     static float *atab, *datab;
     static float *btab, *dbtab;
     static int ntab = 0;
  
     float a, b, aph;
  
     if (firstCall) {
  
         FILE *fp;
         char *filedir;
         char filename[FILENAME_MAX];
         char line [80];
         int32_t itab;
         float a, b, w;
  
         if ((filedir = getenv("OCDATAROOT")) == NULL) {
             printf("-E- %s: OCDATAROOT env variable undefined.\n", __FILE__);
             exit(1);
         }
         strcpy(filename, filedir);
         strcat(filename, "/common/aph_bricaud_1995.txt");
  
         if ((fp = fopen(filename, "r")) == NULL) {
             fprintf(stderr,
                     "-E- %s line %d: unable to open %s for reading\n", __FILE__, __LINE__, filename);
             exit(1);
         }
  
         printf("Reading aph* from %s.\n", filename);
  
         // number of lines
         ntab = 0;
         while (fgets(line, 80, fp))
             ntab++;
         rewind(fp);
  
         // allocate space
         if ((wtab = (float *) calloc(ntab, sizeof (float))) == NULL) {
             printf("-E- %s line %d : error allocating memory for Bricaud aph.\n",
                     __FILE__, __LINE__);
             exit(1);
         }
         if ((atab = (float *) calloc(ntab, sizeof (float))) == NULL) {
             printf("-E- %s line %d : error allocating memory for Bricaud aph.\n",
                     __FILE__, __LINE__);
             exit(1);
         }
         if ((btab = (float *) calloc(ntab, sizeof (float))) == NULL) {
             printf("-E- %s line %d : error allocating memory for Bricaud aph.\n",
                     __FILE__, __LINE__);
             exit(1);
         }
         if ((datab = (float *) calloc(ntab, sizeof (float))) == NULL) {
             printf("-E- %s line %d : error allocating memory for Bricaud aph.\n",
                     __FILE__, __LINE__);
             exit(1);
         }
         if ((dbtab = (float *) calloc(ntab, sizeof (float))) == NULL) {
             printf("-E- %s line %d : error allocating memory for Bricaud aph.\n",
                     __FILE__, __LINE__);
             exit(1);
         }
  
         // read into arrays, skipping header or comment lines
         itab = 0;
         while (itab < ntab) {
             if (fgets(line, 80, fp) == NULL) {
                 fprintf(stderr, "-E- %s line %d: error reading %s at line %d\n", __FILE__, __LINE__, filename, itab);
                 exit(1);
             }
             if (line[0] != '/' && line[0] != '!') {
                 sscanf(line, "%f,%f,%f", &w, &a, &b);
                 wtab [itab] = w;
                 atab [itab] = a;
                 btab [itab] = b;
                 itab++;
             }
         }
         ntab = itab;
  
         // precompute derivatives for spline interpolation
         spline(wtab, atab, ntab, 1e30, 1e30, datab);
         spline(wtab, btab, ntab, 1e30, 1e30, dbtab);
  
         firstCall = 0;
     }
  
     if (wave > wtab[ntab - 1]) wave = wtab[ntab - 1];
  
     // interpolate coefficients to wavelength
     splint(wtab, atab, datab, ntab, wave, &a);
     splint(wtab, btab, dbtab, ntab, wave, &b);
     aph = a * pow(chl, -b);
  
     return (aph);
 }
  
 /* ---------------------------------------------------------------------------------------------- */
 /* aph_bricaud() - compute aph for input wavelength and chl using Bricaud                         */
  
 /* ---------------------------------------------------------------------------------------------- */
 float aph_bricaud_1998(float wave, float chl) {
     static int firstCall = 1;
     static float *table;
     static float *wtab;
     static float *aphitab, *daphitab;
     static float *ephitab, *dephitab;
     static int ntab = 0;
  
     float aph, aphi, ephi;
  
     if (firstCall) {
  
         char *filedir;
         char filename[FILENAME_MAX];
         int ncol, nrow;
  
         if ((filedir = getenv("OCDATAROOT")) == NULL) {
             printf("-E- %s: OCDATAROOT env variable undefined.\n", __FILE__);
             exit(1);
         }
         strcpy(filename, filedir);
         strcat(filename, "/common/aph_bricaud_1998.txt");
         printf("Reading aph* from %s.\n", filename);
  
         nrow = table_row_count(filename);
         if (nrow <= 0) {
             printf("-E- %s line %d: error opening (%s) file", __FILE__, __LINE__, filename);
             exit(1);
         }
  
         ncol = table_column_count(filename);
         table = table_read_r4(filename, ncol, nrow);
         ntab = nrow;
  
         wtab = &table[nrow * 0];
         aphitab = &table[nrow * 3];
         ephitab = &table[nrow * 4];
  
         // precompute derivatives for spline interpolation
         if ((daphitab = (float *) calloc(ntab, sizeof (float))) == NULL) {
             printf("-E- %s line %d : error allocating memory for Bricaud aph.\n",
                     __FILE__, __LINE__);
             exit(1);
         }
         if ((dephitab = (float *) calloc(ntab, sizeof (float))) == NULL) {
             printf("-E- %s line %d : error allocating memory for Bricaud aph.\n",
                     __FILE__, __LINE__);
             exit(1);
         }
         spline(wtab, aphitab, ntab, 1e30, 1e30, daphitab);
         spline(wtab, ephitab, ntab, 1e30, 1e30, dephitab);
  
         firstCall = 0;
     }
  
     if (wave > wtab[ntab - 1]) wave = wtab[ntab - 1];
  
     // interpolate coefficients to wavelength
     splint(wtab, aphitab, daphitab, ntab, wave, &aphi);
     splint(wtab, ephitab, dephitab, ntab, wave, &ephi);
     aph = aphi * pow(chl, ephi - 1);
  
     return (aph);
 }
  
 float aph_bricaud(float wave, float chl) {
     return (aph_bricaud_1998(wave, chl));
 }
  
  
 /* ---------------------------------------------------------------------------------------------- */
 /* aph_ciotti() - compute aph for input wavelength and size fraction using Cioti                  */
  
 /* ---------------------------------------------------------------------------------------------- */
 float aph_ciotti(float wave, float sf) {
     static int firstCall = 1;
     static float *wtab;
     static float *ptab, *dptab; // pico
     static float *mtab, *dmtab; // micro
     static int ntab = 0;
  
     float pico, micro, aph;
  
     if (firstCall) {
  
         FILE *fp;
         char *filedir;
         char filename[FILENAME_MAX];
         char line [80];
         int32_t itab;
         float wv;
  
         if ((filedir = getenv("OCDATAROOT")) == NULL) {
             printf("-E- %s: OCDATAROOT env variable undefined.\n", __FILE__);
             exit(1);
         }
         strcpy(filename, filedir);
         strcat(filename, "/common/aph_ciotti_2002_2006.txt");
  
         if ((fp = fopen(filename, "r")) == NULL) {
             fprintf(stderr,
                     "-E- %s line %d: unable to open %s for reading\n", __FILE__, __LINE__, filename);
             exit(1);
         }
  
         printf("Reading aph* from %s.\n", filename);
  
         // number of lines
         ntab = 0;
         while (fgets(line, 80, fp))
             ntab++;
         rewind(fp);
  
         // allocate space
         if ((wtab = (float *) calloc(ntab, sizeof (float))) == NULL) {
             printf("-E- %s line %d : error allocating memory for Ciotti aph.\n",
                     __FILE__, __LINE__);
             exit(1);
         }
         if ((ptab = (float *) calloc(ntab, sizeof (float))) == NULL) {
             printf("-E- %s line %d : error allocating memory for Ciotti aph.\n",
                     __FILE__, __LINE__);
             exit(1);
         }
         if ((mtab = (float *) calloc(ntab, sizeof (float))) == NULL) {
             printf("-E- %s line %d : error allocating memory for Ciotti aph.\n",
                     __FILE__, __LINE__);
             exit(1);
         }
         if ((dptab = (float *) calloc(ntab, sizeof (float))) == NULL) {
             printf("-E- %s line %d : error allocating memory for Ciotti aph.\n",
                     __FILE__, __LINE__);
             exit(1);
         }
         if ((dmtab = (float *) calloc(ntab, sizeof (float))) == NULL) {
             printf("-E- %s line %d : error allocating memory for Ciotti aph.\n",
                     __FILE__, __LINE__);
             exit(1);
         }
  
         // read into arrays, skipping header or comment lines
         itab = 0;
         while (itab < ntab) {
             if (fgets(line, 80, fp) == NULL) {
                 fprintf(stderr, "-E- %s line %d: error reading %s at line %d\n", __FILE__, __LINE__, filename, itab);
                 exit(1);
             }
             if (line[0] != '/' && line[0] != '!') {
                 sscanf(line, "%f %f %f", &wv, &pico, &micro);
                 wtab [itab] = wv;
                 ptab [itab] = pico * 0.0230 / 0.891;
                 mtab [itab] = micro * 0.0086 / 1.249;
                 itab++;
             }
         }
         ntab = itab;
  
         // precompute derivatives for spline interpolation
         spline(wtab, ptab, ntab, 1e30, 1e30, dptab);
         spline(wtab, mtab, ntab, 1e30, 1e30, dmtab);
  
         firstCall = 0;
     }
  
     if (wave > wtab[ntab - 1]) wave = wtab[ntab - 1];
  
     // interpolate coefficients to wavelength
     splint(wtab, ptab, dptab, ntab, wave, &pico);
     splint(wtab, mtab, dmtab, ntab, wave, &micro);
  
     aph = sf * pico + (1.0 - sf) * micro;
  
     return (aph);
 }
  
  
 /* ---------------------------------------------------------------------------------------------- */
 /* get_aphstar() - compute aph* for center wavelength, wavelength width, function type, and proxy */
  
 /* ---------------------------------------------------------------------------------------------- */
 float get_aphstar(float wave, int dwave, int ftype, float proxy) {
     int32_t npts;
     float wave1, wave2, wv;
     float aph = 0.0;
  
     if (dwave > 1) {
         npts = dwave + 1;
         wave1 = wave - dwave / 2;
         wave2 = wave + dwave / 2;
     } else {
         npts = 1;
         wave1 = wave;
         wave2 = wave;
     }
  
     for (wv = wave1; wv <= wave2; wv += 1.0) {
         switch (ftype) {
         case APHBRICAUD:
             aph += aph_bricaud(wv, proxy);
             break;
         case APHCIOTTI:
             aph += aph_ciotti(wv, proxy);
             break;
         }
     }
  
     aph /= npts;
  
     return (aph);
 }

l1mapgen.stderr

stderr

Definition: l1mapgen.py:204

table_read_r4

float * table_read_r4(char *input_filename, int m, int n)

Definition: table_io.cpp:2540

get_aphstar

float get_aphstar(float wave, int dwave, int ftype, float proxy)

Definition: aph.c:296

table_column_count

int table_column_count(char *input_filename)

Definition: table_io.cpp:2524

table

an array had not been initialized Several spelling and grammar corrections were which is read from the appropriate MCF the above metadata values were hard coded A problem calculating the average background DN for SWIR bands when the moon is in the space view port was corrected The new algorithm used to calculate the average background DN for all reflective bands when the moon is in the space view port is now the same as the algorithm employed by the thermal bands For non SWIR changes in the averages are typically less than Also for non SWIR the black body DNs remain a backup in case the SV DNs are not available For SWIR the changes in computed averages were larger because the old which used the black body suffered from contamination by the micron leak As a consequence of the if SV DNs are not available for the SWIR the EV pixels will not be the granule time is used to identify the appropriate tables within the set given for one LUT table(e.g. m1) to be used for interpolation. The table values will be linearly interpolated using the tables corresponding to the node times bracketing the granule time. If the granule time falls before the time of the first node or after the time of the last node

NULL

#define NULL

Definition: decode_rs.h:63

aph_bricaud_1998

float aph_bricaud_1998(float wave, float chl)

Definition: aph.c:116

spline

subroutine spline(s, x, y, n, in, t, il, iu, vl, vu, e, u)

Definition: phs.f:1348

table_row_count

int table_row_count(char *input_filename)

Definition: table_io.cpp:2528

l12_proto.h

filename

char filename[FILENAME_MAX]

Definition: atrem_corl1.h:122

fix_mac_rpath.line

line

Definition: fix_mac_rpath.py:55

mapgen.ftype

ftype

Definition: mapgen.py:232

data_t b[NROOTS+1]

Definition: decode_rs.h:77

APHCIOTTI

#define APHCIOTTI

Definition: giop.h:35

itab

Definition: common.h:9

aph_ciotti

float aph_ciotti(float wave, float sf)

Definition: aph.c:190

APHBRICAUD

#define APHBRICAUD

Definition: giop.h:34

splint

subroutine splint(xa, ya, y2a, n, x, y)

Definition: atrem_app_refl_f90_cubeio.f:3270

giop.h

aph_bricaud_1995

float aph_bricaud_1995(float wave, float chl)

Definition: aph.c:12

strcpy

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

PGE01 indicating that PGE02 PGE01 V6 for and PGE01 V2 for MOD03 were used to produce the granule By convention adopted in all MODIS Terra PGE02 code versions are The fourth digit of the PGE02 version denotes the LUT version used to produce the granule The source of the metadata environment variable ProcessingCenter was changed from a QA LUT value to the Process Configuration A sign used in error in the second order term was changed to a

Definition: HISTORY.txt:424

aph_bricaud

float aph_bricaud(float wave, float chl)

Definition: aph.c:181