ocssw V2020
pml_iop_tables.c
Go to the documentation of this file.
1 #include <math.h>
2 #include "pml_iop.h"
3 #include "pml_iop_config.h"
4 #include "pml_iop_tables.h"
5 #include "pml_iop_calculate.h"
6 #include "pml_bright.h"
7 #include "l12_parms.h"
8 #include "genutils.h"
9 
10 /* Module: pml_iop_tables.c */
11 /* Authors: Gerald Moore and Tim Smyth */
12 /* Date: 06/03/13 */
13 /* Version: 1.5 */
14 /* Description: Module containing functions to read in the various */
15 /* tables defined in the config file and to perform interpolations */
16 
17 #define MAX_LINE 180
18 
19 /* set the endian-ness of the PML iop table binary file (1=little endian) */
20 #define PML_FILE_ENDIAN 1
21 
22 
23 float *lambda, lc[MAX_BANDS], *a_w, *b_w;
24 /* Geophysical (GOP) variables */
25 int32_t nband, ch_n, sp_n, od_n;
28 float *od_lev, *od[MAX_BANDS];
29 
30 /* IOP variables */
31 int32_t th_s_n, th_v_n, dphi_n;
33 int32_t ap_n, bp_n;
34 float *ap_lev, *bp_lev;
35 
36 float *refen; /* The pointer for refen.*/
37 static int32_t refind = 0l; /* current index */
38 static int32_t refind_max = 0l;
39 
40 /* Constants for interior conversions */
41 /* loaded by config routine */
42 int bp[2], maxit;
45 float tol;
46 
47 /* Gelbstoff and pigment parameters */
50 
51 /* Bright pixel variables */
53 float tol_n, tol_b, n_init;
54 double lc1, lc2, log_lc1, e_init;
58 
59 /* Function: load_work_tab */
60 
61 /* Loads the sensor Look-Up Tables into memory */
62 int load_work_tab(char *configfname, int sensorID) {
63  char *tmp_str;
64  char fname[FILENAME_MAX];
65 
66  int i, j;
67  int32_t t_nbands, v_len;
68  float *t_lambda;
69  char created[MAX_LINE];
70  char sensor_name[MAX_LINE];
71 
72  FILE *table;
73 
74  /* Geophysical LUT */
75  if ((tmp_str = getenv("OCDATAROOT")) == NULL) {
76  printf("OCDATAROOT environment variable is not defined.\n");
77  exit(1);
78  }
79 
80  /* sensor specific LUTs used - only available for MODIS and SeaWiFS */
81  switch (sensorID) {
82  case SEAWIFS:
83  sprintf(sensor_name, "seawifs");
84  t_nbands = 8;
85  break;
86  case MODISA:
87  case MODIST:
88  sprintf(sensor_name, "modis");
89  t_nbands = 9;
90  break;
91  default:
92  printf("Sensor not either SeaWiFS or MODIS and the LUTs do not exist\n");
93  exit(1);
94  break;
95  }
96 
97  sprintf(fname, "%s/%s/iop/pml/%s", tmp_str, sensor_name, get_cfg_s("gop_table", configfname));
98  if ((table = fopen(fname, "r")) == NULL) {
99  printf("Error opening %s\n", fname);
100  exit(1);
101  }
102 
103  /* start by reading bands and alocating variables */
104  /* t_nbands=(int32_t)get_cfg_i("n_bands",configfname); */
105  fread_swap(PML_FILE_ENDIAN, &nband, sizeof (int32_t), 1, table);
106  /* verify correct size of table */
107  if (nband != t_nbands) {
108  printf("Table band mismatch expected %d read %d\n", t_nbands, nband);
109  printf("Using Geophysical Look-up Table: %s \n", fname);
110  exit(1);
111  }
112  /* Allocate the arrays according to the number of wavelengths */
113  lambda = calloc(nband, sizeof (float));
114  a_w = calloc(nband, sizeof (float));
115  b_w = calloc(nband, sizeof (float));
116  /* Read in the wavelengths and aw,bw (in that order) */
117  fread_swap(PML_FILE_ENDIAN, lambda, sizeof (float), nband, table);
118  fread_swap(PML_FILE_ENDIAN, a_w, sizeof (float), nband, table);
119  fread_swap(PML_FILE_ENDIAN, b_w, sizeof (float), nband, table);
120 
121  /* Chlorophyll */
122  fread_swap(PML_FILE_ENDIAN, &ch_n, sizeof (int32_t), 1, table);
123  ch_lev = calloc(ch_n, sizeof (float));
124  fread_swap(PML_FILE_ENDIAN, ch_lev, sizeof (float), ch_n, table);
125 
126  for (i = 0; i < nband; i++) {
127  ac[i] = calloc(ch_n, sizeof (float));
128  bc[i] = calloc(ch_n, sizeof (float));
129  }
130  for (i = 0; i < ch_n; i++) {
131  for (j = 0; j < nband; j++) {
132  fread_swap(PML_FILE_ENDIAN, &ac[j][i], sizeof (float), 1, table);
133  }
134  }
135  for (i = 0; i < ch_n; i++) {
136  for (j = 0; j < nband; j++) {
137  fread_swap(PML_FILE_ENDIAN, &bc[j][i], sizeof (float), 1, table);
138  }
139  }
140 
141  /* SPM */
142  fread_swap(PML_FILE_ENDIAN, &sp_n, sizeof (int32_t), 1, table);
143  sp_lev = calloc(sp_n, sizeof (float));
144  fread_swap(PML_FILE_ENDIAN, sp_lev, sizeof (float), sp_n, table);
145 
146  for (i = 0; i < nband; i++) {
147  as[i] = calloc(sp_n, sizeof (float));
148  bs[i] = calloc(sp_n, sizeof (float));
149  }
150  for (i = 0; i < sp_n; i++) {
151  for (j = 0; j < nband; j++) {
152  fread_swap(PML_FILE_ENDIAN, &as[j][i], sizeof (float), 1, table);
153  }
154  }
155  for (i = 0; i < sp_n; i++) {
156  for (j = 0; j < nband; j++) {
157  fread_swap(PML_FILE_ENDIAN, &bs[j][i], sizeof (float), 1, table);
158  }
159  }
160 
161  /* Gelbstoff */
162  fread_swap(PML_FILE_ENDIAN, &od_n, sizeof (int32_t), 1, table);
163  od_lev = calloc(od_n, sizeof (float));
164  fread_swap(PML_FILE_ENDIAN, od_lev, sizeof (float), od_n, table);
165 
166  for (i = 0; i < nband; i++) {
167  od[i] = calloc(od_n, sizeof (float));
168  }
169  for (i = 0; i < od_n; i++) {
170  for (j = 0; j < nband; j++) {
171  fread_swap(PML_FILE_ENDIAN, &od[j][i], sizeof (float), 1, table);
172  }
173  }
174 
175  fread_swap(PML_FILE_ENDIAN, &v_len, sizeof (int32_t), 1, table);
176  fread_swap(PML_FILE_ENDIAN, created, sizeof (char), v_len, table);
177  created[v_len] = '\0';
178 
179  fclose(table);
180 
181  /* IOP tables */
182  /* IOP header file */
183  sprintf(fname, "%s/%s/iop/pml/%s", tmp_str, sensor_name, get_cfg_s("iop_F_head", configfname));
184  if ((table = fopen(fname, "r")) == NULL) {
185  printf("Error opening %s\n", fname);
186  exit(1);
187  }
188 
189  /* start by reading bands and alocating variables */
190  /* t_nbands=(int32_t)get_cfg_i("n_bands",configfname); */
191  fread_swap(PML_FILE_ENDIAN, &nband, sizeof (int32_t), 1, table);
192  /* verify correct size of table */
193  if (nband != t_nbands) {
194  printf("Table band mismatch expected %d read %d\n", t_nbands, nband);
195  printf("Using IOP header Table: %s \n", fname);
196  exit(1);
197  }
198  /* First wavelengths */
199  t_lambda = calloc(nband, sizeof (float));
200  fread_swap(PML_FILE_ENDIAN, t_lambda, sizeof (float), nband, table);
201 
202  /* verify that these match */
203  for (i = 0; i < nband; i++) {
204  if (fabsf(t_lambda[i] - lambda[i]) > 15.0) {
205  printf("Error IOP table wavelength mismatch expected %f got %f\n", lambda[i], t_lambda[i]);
206  exit(1);
207  }
208  }
209  free(t_lambda);
210  /* Solar zenith angle */
211  fread_swap(PML_FILE_ENDIAN, &th_s_n, sizeof (int32_t), 1, table);
212  th_s_lev = calloc(th_s_n, sizeof (float));
213  fread_swap(PML_FILE_ENDIAN, th_s_lev, sizeof (float), th_s_n, table);
214  /* view zenith angle */
215  fread_swap(PML_FILE_ENDIAN, &th_v_n, sizeof (int32_t), 1, table);
216  th_v_lev = calloc(th_v_n, sizeof (float));
217  fread_swap(PML_FILE_ENDIAN, th_v_lev, sizeof (float), th_v_n, table);
218  /* azimuth angle difference (view and satellite)*/
219  fread_swap(PML_FILE_ENDIAN, &dphi_n, sizeof (int32_t), 1, table);
220  dphi_lev = calloc(dphi_n, sizeof (float));
221  fread_swap(PML_FILE_ENDIAN, dphi_lev, sizeof (float), dphi_n, table);
222  /* absorption (a) */
223  fread_swap(PML_FILE_ENDIAN, &ap_n, sizeof (int32_t), 1, table);
224  ap_lev = calloc(ap_n, sizeof (float));
225  fread_swap(PML_FILE_ENDIAN, ap_lev, sizeof (float), ap_n, table);
226  /* scatter (b) */
227  fread_swap(PML_FILE_ENDIAN, &bp_n, sizeof (int32_t), 1, table);
228  bp_lev = calloc(bp_n, sizeof (float));
229  fread_swap(PML_FILE_ENDIAN, bp_lev, sizeof (float), bp_n, table);
230 
231  fclose(table);
232 
233  /* Master IOP table for the geometry */
234  sprintf(fname, "%s/%s/iop/pml/%s", tmp_str, sensor_name, get_cfg_s("iop_F_table", configfname));
235  if ((table = fopen(fname, "r")) == NULL) {
236  printf("Error opening %s\n", fname);
237  exit(1);
238  }
239 
240  /* Allocate memory for refen array */
241  refind = th_s_n * th_v_n * dphi_n * ap_n * bp_n*nband;
242  refind_max = refind - (ap_n * bp_n * nband);
243  refen = (float *) calloc((refind), sizeof (float));
244  if (refen == NULL) {
245  fprintf(stderr, "load_work_tab: memory allocation failure for refen\n");
246  exit(1);
247  }
248 
249  fread_swap(PML_FILE_ENDIAN, refen, sizeof (float), refind, table);
250 
251  /* Check that table limits are not exceeded */
252  if (feof(table)) {
253  printf("IOP master table error: table too short!\n");
254  exit(1);
255  }
256  /* Try next byte as constitancy check */
257  i = fgetc(table);
258  if (!feof(table)) {
259  printf("IOP master table error: table too long!\n");
260  exit(1);
261  }
262 
263  fclose(table);
264  refind = 0l;
265  return refind;
266 }
267 
268 /* Function: load_config */
269 /* Stores the config table values such that they are available to */
270 
271 /* the main calling routine */
272 void load_config(char *configfname) {
273  bp[0] = get_cfg_i("low_band", configfname);
274  bp[1] = get_cfg_i("high_band", configfname);
275  b_tilde_p = get_cfg_f("b_tilde_p", configfname);
276  b_tilde_w = get_cfg_f("b_tilde_w", configfname);
277 
278  /* Step 1: 490:510 ratio absorption and backscatter */
279  eps_a_init = get_cfg_f("eps_a_init", configfname);
280  eps_bb_init = get_cfg_f("eps_bb_init", configfname);
281  /* Additional information if processing a MODIS pass */
282  eps_a_init_modis = get_cfg_f("eps_a_init_modis", configfname);
283  scat_l_modis = get_cfg_f("scat_l_modis", configfname);
284  scat_a = get_cfg_f("scat_a", configfname);
285  scat_b = get_cfg_f("scat_b", configfname);
286  scat_c = get_cfg_f("scat_c", configfname);
287  scat_n = get_cfg_f("scat_n", configfname);
288  scat_l = get_cfg_f("scat_l", configfname);
289 
290  /* Iterations to get the F parameter correctly */
291  init_chl = get_cfg_f("init_chl", configfname);
292  tol = get_cfg_f("iop_tol", configfname);
293  maxit = get_cfg_i("iop_maxit", configfname);
294 
295  /* Step 2: 412:443 ratios to get the gelbstoff and pigment */
296  eps_y_412_443 = get_cfg_f("eps_y_412_443", configfname);
297  eps_p_412_443 = get_cfg_f("eps_p_412_443", configfname);
298 
299  ysbpa_0 = get_cfg_f("YSBPA_0", configfname);
300  ysbpa_s = get_cfg_f("YSBPA_S", configfname);
301  ysbpa_l = get_cfg_f("YSBPA_l", configfname);
302 
303  /* Additional variables for the bright pixel code */
304  bp_base = get_cfg_i("bp_base", configfname); /* base band */
305  bp_1 = get_cfg_i("bp_1", configfname); /* first NIR */
306  bp_2 = get_cfg_i("bp_2", configfname); /* second(lower) NIR */
307 
308  /* convergence criterion */
309  tol_b = get_cfg_f("bp_tol_b", configfname); /* Tolerence for converge */
310  tol_n = get_cfg_f("bp_tol_n", configfname); /* Tolerence for converge */
311  max_iter = get_cfg_i("bp_iter", configfname); /* Max iterations */
312 
313  n_init = get_cfg_f("bp_n", configfname); /* inititial Angstrom exponent */
314  n_min = get_cfg_f("n_min", configfname); /* min. Angstrom exponent */
315  n_max = get_cfg_f("n_max", configfname); /* max. Angstrom exponent */
316  b_low_init = get_cfg_f("low_spm_init", configfname);
317  b_high_init = get_cfg_f("high_spm_init", configfname);
318  b_init = get_cfg_f("b_init", configfname);
319 
320  delta_b_init = get_cfg_f("delta_b_init", configfname);
321  min_db = get_cfg_f("min_db", configfname);
322  max_db = get_cfg_f("max_db", configfname);
323  spm_min = get_cfg_f("spm_min", configfname);
324  spm_max = get_cfg_f("spm_max", configfname);
325  iter_scale = get_cfg_f("iter_scale", configfname);
326  rst_n = get_cfg_f("rst_n", configfname);
327  rst_n_step = get_cfg_f("rst_n_step", configfname);
328  rst_spm = get_cfg_f("rst_spm", configfname);
329  rst_db = get_cfg_f("rst_db", configfname);
330  clim_spm = get_cfg_f("clim_spm", configfname);
331 
332 }
333 
334 /* Function: geo2iop */
335 
336 /* Returns the IOP values for a given geophysical input */
337 float geo2iop(float *levels, float *iopv[MAX_BANDS], int band, float value, int size) {
338 
339  float res, ind;
340  /* Conversion of band number to account for an 11 band IOP table */
341  ind = interp_l(levels, value, size);
342  res = iopv[band][(int) ind]*(floor(ind) + 1.0 - ind) + iopv[band][(int) ind + 1]*(ind - floor(ind));
343 
344  return res;
345 }
346 
347 /* Function: interp */
348 
349 /* Returns an interpolated value */
350 float interp(float *x, float u, int n) {
351  int s, i;
352  s = 0;
353  if (u > x[n - 1]) return n - 1;
354  for (i = 0; i < n; i++) {
355  if (x[i] >= u) {
356  s = i - 1;
357  break;
358  }
359  }
360  if (s < 0) s = 0;
361  return ((u - x[s]) / (x[s + 1] - x[s]) + s);
362 }
363 
364 /* Function: interp_l */
365 /* Returns the log interpolated value */
366 
367 /* Fast version for geophysical variables */
368 float interp_l(float *x, float u, int n) {
369  int s, i;
370  s = 0;
371  if (u > x[n - 1]) return n - 1;
372  for (i = 0; i < n; i++) {
373  if (x[i] >= u) {
374  s = i - 1;
375  break;
376  }
377  }
378  if (s < 0) s = 0;
379  if (s == 0) return ((u - x[s]) / (x[s + 1] - x[s]) + s);
380  return ((log(u) - log(x[s])) / (log(x[s + 1]) - log(x[s])) + s);
381 }
382 
383 /* Function: setgeom */
384 
385 /* Interpolates from the LUT to get correct value for geometry */
386 int setgeom(float sun_theta, float sen_theta, float dphi) {
387  int status = 0;
388  int32_t th_s_ent, th_v_ent, dphi_ent;
389 
390  /* Page in IOP table */
391  /* check that the angle matches index */
392  th_s_ent = (int32_t) floor(interp(th_s_lev, sun_theta, th_s_n) + 0.5);
393  th_v_ent = (floor) (interp(th_v_lev, sen_theta, th_v_n) + 0.5);
394  if (dphi < 0.0) dphi = dphi + M_PI * 2.0;
395  if (dphi > M_PI * 2.0) dphi = dphi - M_PI * 2.0;
396  dphi_ent = (int32_t) floor(interp(dphi_lev, dphi, dphi_n) + 0.5);
397  /* IOP data */
398  refind = (int) (th_s_ent * th_v_n * dphi_n * nband * bp_n * ap_n)
399  +(th_v_ent * dphi_n * nband * bp_n * ap_n)
400  +(dphi_ent * nband * bp_n * ap_n);
401 
402  /* Geometry beyond table limits */
403  if (refind > refind_max) {
404  status = 1;
405  return status;
406  }
407  return status;
408 }
409 
410 /* Function: f_ab */
411 /* Interpolates to get a value f/Q */
412 
413 /* for a pair of a and b */
414 double f_ab(double a, double b, int band) {
415  double ain, bin;
416  double res;
417  ain = interp_l(ap_lev, a, ap_n);
418  bin = interp_l(bp_lev, b, bp_n);
419  res = fint(ain, bin, band);
420 
421  return res;
422 }
423 
424 /* Function: fint */
425 
426 /* Interpolates for a pair of doubles and a given waveband */
427 double fint(double a, double b, int band) {
428  double ral, rah, res;
429  int al, bl, bh, ah;
430  if (a > 0) al = (int) floor(a);
431  else al = 0;
432  if (b > 0) bl = (int) floor(b);
433  else bl = 0;
434  bh = bl + 1;
435  ah = al + 1;
436 
437  if ((bh > 15) || (ah > 15)) return 0.0;
438  ral = refen[refind + band * bp_n * ap_n + bl * ap_n + ah]*(a - (double) al)
439  + refen[refind + band * bp_n * ap_n + bl * ap_n + al]*((double) ah - a);
440  rah = refen[refind + band * bp_n * ap_n + bh * ap_n + ah]*(a - (double) al)
441  + refen[refind + band * bp_n * ap_n + bh * ap_n + al]*((double) ah - a);
442  res = rah * (b - (double) bl) + ral * ((double) bh - b);
443 
444  return res;
445 }
446 
447 /* Function: iop_ref */
448 
449 /* Depending on the iop binary flag returns sediment / chlorophyll conc */
450 float iop_ref(float conc, int band, int iop) {
451  /* Sediment is set for 0, chlorophyll for 1 .. */
452  if (iop == 0) return sed_ref(conc, band);
453  if (iop == 1) return chl_ref(conc, band);
454  printf("Call error in iop_ref (type = %d)\n", iop);
455  exit(1);
456 }
457 
458 /* Function: r_ab */
459 
460 /* Given value of a and b return reflectance (from LUT) */
461 float r_ab(float a, float b, int band) {
462  double F;
463  float res;
464  F = f_ab(a, b, band);
465  res = F * (b_w[band] * b_tilde_w + b * b_tilde_p) / (a_w[band] + a);
466 
467  return res;
468 }
469 
470 /* Function: sed_ref */
471 
472 /* Returns reflectance for a given sediment value */
473 float sed_ref(float spm, int band) {
474  float res;
475  if (spm < spm_min) spm = spm_min;
476  else if (spm > spm_max) spm = spm_max;
477  res = r_ab(geo2iop(sp_lev, as, band, spm, sp_n), geo2iop(sp_lev, bs, band, spm, sp_n), band);
478 
479  return res;
480 }
481 
482 /* Function: chl_ref */
483 
484 /* Returns reflectance for a given chlorophyll value */
485 float chl_ref(float chl, int band) {
486  float res;
487  /* Need to debug this (or at least make nomenclature change */
488  if (chl < spm_min) chl = spm_min;
489  else if (chl > spm_max) chl = spm_max;
490  res = r_ab(geo2iop(ch_lev, ac, band, chl, ch_n), geo2iop(ch_lev, bc, band, chl, ch_n), band);
491 
492  return res;
493 }
494 
float eps_bb_init
int max_iter
float * refen
int bp_2
int32 value
Definition: Granule.c:1235
double rst_n_step
double fint(double a, double b, int band)
int load_work_tab(char *configfname, int sensorID)
double n_min
int32_t th_s_n
int j
Definition: decode_rs.h:73
int status
Definition: l1_czcs_hdf.c:31
int bp_1
double rst_db
float sed_ref(float spm, int band)
float * ch_lev
list levels
Definition: mapgen.py:169
float interp(float *x, float u, int n)
int maxit
float * b_w
string fname
Definition: mie_kernal.py:124
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
int n_bands
#define NULL
Definition: decode_rs.h:63
float ysbpa_s
int get_cfg_i(char *tok, char *fname)
float tol_n
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
float ysbpa_0
float lc[MAX_BANDS]
double b_high_init
float * od_lev
float b_tilde_w
double spm_min
float * a_w
#define MODIST
Definition: sensorDefs.h:18
int32_t sp_n
size_t fread_swap(int little_endian, void *ptr, size_t size, size_t nmemb, FILE *stream)
Definition: fread_swap.c:4
#define MAX_LINE
const double F
float geo2iop(float *levels, float *iopv[MAX_BANDS], int band, float value, int size)
int setgeom(float sun_theta, float sen_theta, float dphi)
int32_t dphi_n
double max_db
int32_t ch_n
int bp_base
#define MAX_BANDS
Definition: pml_iop.h:11
double clim_spm
#define PML_FILE_ENDIAN
float chl_ref(float chl, int band)
float init_chl
double iter_scale
float * od[MAX_BANDS]
double min_db
float * sp_lev
double rst_spm
double delta_b_init
float scat_a
double n_max
double lc1
float r_ab(float a, float b, int band)
float tol
void load_config(char *configfname)
#define M_PI
Definition: pml_iop.h:15
float * bs[MAX_BANDS]
float * ac[MAX_BANDS]
float eps_a_init_modis
double f_ab(double a, double b, int band)
float scat_l_modis
float * ap_lev
double rst_n
double log_lc1
float * th_v_lev
char * get_cfg_s(char *tok, char *fname)
data_t b[NROOTS+1]
Definition: decode_rs.h:77
float interp_l(float *x, float u, int n)
int32_t nband
float * lambda
float eps_p_412_443
double b_low_init
double e_init
float scat_l
float * dphi_lev
data_t u
Definition: decode_rs.h:74
float iop_ref(float conc, int band, int iop)
float n_init
float eps_a_init
float tol_b
float * as[MAX_BANDS]
float get_cfg_f(char *tok, char *fname)
double spm_max
data_t s[NROOTS]
Definition: decode_rs.h:75
int bp[2]
float * bp_lev
float scat_n
int32_t ap_n
float ysbpa_l
int32_t th_v_n
float scat_b
double b_init
double lc2
#define SEAWIFS
Definition: sensorDefs.h:12
int32_t bp_n
int i
Definition: decode_rs.h:71
float b_tilde_p
float * th_s_lev
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
int32_t sensorID[MAXNFILES]
Definition: l2bin.cpp:95
float eps_y_412_443
#define MODISA
Definition: sensorDefs.h:19
int32_t od_n
float scat_c
float * bc[MAX_BANDS]