NASA Ocean Color

ocssw V2022

 #include "sst_cloud_mask_utils.hpp"
 #include "d3940tref.h"
  
 namespace envset {
     std::string get_ocdata_root() {
         if (const char *env_p = std::getenv("OCDATAROOT")) {
             return env_p;
         }
         std::cerr << "--Error-: OCDATAROOT env variable NOT found; exiting ..." << std::endl;
         exit(EXIT_FAILURE);
         return "";
     }
  
 }
  
 namespace cldmsk {
     std::vector<float> month_data_; // month_data;
     std::vector<float> &month_data() { return month_data_; }
  
     std::string get_sensor(int key) {
         for (const auto &sens_data: all_sensors) {
             if (sens_data.second.count(key) > 0)
                 return sens_data.first;
         }
         std::cerr << "--Error-: Sensor is  Not Found; Currently, the code process only VIIRS and MODIS; exiting ...  "
                   << std::endl;
         exit(EXIT_FAILURE);
         return "";
     }
  
     float btrefdiffv6(int32_t ip, float BT39, float BT40, const l1str *l1rec, int fullscanpix) {
         float diff;
         float satzdir;
         float senz;
         float tref;
         satzdir = (l1rec->pixnum[ip] < fullscanpix / 2) ? -1.0 : 1.0;
         senz = l1rec->senz[ip] * satzdir;
         tref = linterp(sza, trefv6, NSENZ, senz);
         diff = BT39 - BT40 - tref;
         return (diff);
     }
  
     void get_var_mask(int *mask, const l1str &l1str, size_t npix, int nbands, int ib, get_valid get_mask) {
         for (size_t i = 0; i < npix; i++) {
             mask[i] = get_mask(l1str, i, nbands, ib);
         }
     }
  
     void get_var_vals(float *BT, const l1str &l1str, size_t npix, int nbands, int ib, get_value get_val) {
         for (size_t i = 0; i < npix; i++) {
             BT[i] = get_val(l1str, i, nbands, ib);
         }
     }
  
     void get_window_1D_max(float *maxs_1d, const float *inp1d, const int *mask1d, size_t npix, size_t radius) {
         for (size_t i_p = 0; i_p < npix; i_p++) {
             maxs_1d[i_p] = BAD_FLT;
             const size_t i_p_s = std::max(0, (int) i_p - (int) radius);
             const size_t i_p_e = std::min(npix - 1, i_p + radius);
             for (size_t i = i_p_s; i <= i_p_e; i++) {
                 if (mask1d[i]) {
                     const float val = inp1d[i];
                     if (val > maxs_1d[i_p]) {
                         maxs_1d[i_p] = val;
                     }
                 }
             }
         }
     }
  
     void
     get_total_2d_max(float *max_global, const float *inp2d, size_t npix, size_t nscan, size_t center, size_t radius) {
         const size_t i_q_s = std::max(0, (int) center - (int) radius);
         const size_t i_q_e = std::min(nscan - 1, center + radius);
         for (size_t i_p = 0; i_p < npix; i_p++) {
             max_global[i_p] = BAD_FLT;
             for (size_t i_q = i_q_s; i_q <= i_q_e; i_q++) {
                 const size_t ind = i_p + i_q * npix;
                 const float val = inp2d[ind];
                 if (val > max_global[i_p]) {
                     max_global[i_p] = val;
                 }
             }
         }
     }
  
     void get_window_1D_min(float *mins_1d, const float *inp1d, const int *mask1d, size_t npix, size_t radius) {
         const float max_possible_val = std::abs(BAD_FLT);
         for (size_t i_p = 0; i_p < npix; i_p++) {
             mins_1d[i_p] = max_possible_val;
             const size_t i_p_s = std::max(0, (int) i_p - (int) radius);
             const size_t i_p_e = std::min(npix - 1, i_p + radius);
             for (size_t i = i_p_s; i <= i_p_e; i++) {
                 if (mask1d[i]) {
                     const float val = inp1d[i];
                     if (val < mins_1d[i_p]) {
                         mins_1d[i_p] = val;
                     }
                 }
             }
         }
     }
  
     void
     get_total_2d_min(float *min_global, const float *inp2d, size_t npix, size_t nscan, size_t center, size_t radius) {
         const size_t i_q_s = std::max(0, (int) center - (int) radius);
         const size_t i_q_e = std::min(nscan - 1, center + radius);
         const float max_possible_val = std::abs(BAD_FLT);
         for (size_t i_p = 0; i_p < npix; i_p++) {
             min_global[i_p] = max_possible_val;
             for (size_t i_q = i_q_s; i_q <= i_q_e; i_q++) {
                 const size_t ind = i_p + i_q * npix;
                 const float val = inp2d[ind];
                 if (val < min_global[i_p]) {
                     min_global[i_p] = val;
                 }
             }
         }
     }
  
     void get_std_box(const float *inp2d, const int *mask2d, size_t npix, size_t nscan, size_t radius_x, size_t radius_y,
                      float *out, size_t center, l1qstr *l1qrec) {
         std::vector<double> sums(npix * nscan, 0.0);
         std::vector<double> sums2(npix * nscan, 0.0);
         std::vector<size_t> counts(npix * nscan, 0);
         for (size_t i_q = 0; i_q < nscan; i_q++) {
             for (size_t i_p = 0; i_p < npix; i_p++) {
                 const size_t i_p_s = std::max(0, (int) i_p - (int) radius_x);
                 const size_t i_p_e = std::min(npix - 1, i_p + radius_x);
                 const size_t ind = i_p + i_q * npix;
                 for (size_t i = i_p_s; i <= i_p_e; i++) {
                     const size_t index = i + i_q * npix;
                     if (mask2d[index]) {
                         sums.at(ind) += (inp2d[index]);
                         sums2.at(ind) += (inp2d[index]) * (inp2d[index]);
                         counts.at(ind) += 1;
                     }
                 }
             }
         }
         const size_t i_q_s = std::max(0, (int) center - (int) radius_y);
         const size_t i_q_e = std::min(nscan - 1, center + radius_y);
         for (size_t i_p = 0; i_p < npix; i_p++) {
             double sum_local = 0.0f;
             double sum_local2 = 0.0f;
             size_t count_local = 0;
             for (size_t i_q = i_q_s; i_q <= i_q_e; i_q++) {
                 const size_t ind = i_p + i_q * npix;
                 count_local += counts.at(ind);
                 sum_local += sums.at(ind);
                 sum_local2 += sums2.at(ind);
             }
             if (count_local > 2) {
                 double diff = (sum_local2 - sum_local * sum_local / (int) count_local) / ((int) count_local - 1);
                 if (diff <= 0) {
                     out[i_p] = BAD_FLT;
                 } else {
                     out[i_p] = std::sqrt(diff);
                 }
             } else {
                 out[i_p] = BAD_FLT;
             }
         }
     }
  
     void read_sst_bands(const std::string &sat, std::unordered_map<std::string, int> &bands) {
         for (const auto &var_pair: bands_set.at(sat)) {
             const std::string key = var_pair.first;
             const int value = var_pair.second;
             bands[key] = bindex_get(value);
         }
     }
 }

seadasutils.DictUtils.val

int val

Definition: DictUtils.py:140

sst_cloud_mask_utils.hpp

index

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 the first two or last two tables respectively will be used for the interpolation If there is only one LUT in the set of it will be treated as a constant LUT The manner in which Earth View data is checked for saturation was changed Previously the raw Earth View DNs and Space View DNs were checked against the lookup table values contained in the table dn_sat The change made is to check the raw Earth and Space View DNs to be sure they are less than the maximum saturation value and to check the Space View subtracted Earth View dns against a set of values contained in the new lookup table dn_sat_ev The metadata configuration and ASSOCIATEDINSTRUMENTSHORTNAME from the MOD02HKM product The same metatdata with extensions and were removed from the MOD021KM and MOD02OBC products ASSOCIATEDSENSORSHORTNAME was set to MODIS in all products These changes are reflected in new File Specification which users may consult for exact the pow functions were eliminated in Emissive_Cal and Emissive bands replaced by more efficient code Other calculations throughout the code were also made more efficient Aside from a few round off there was no difference to the product The CPU time decreased by about for a day case and for a night case A minor bug in calculating the uncertainty index for emissive bands was corrected The frame index(0-based) was previously being used the frame number(1-based) should have been used. There were only a few minor changes to the uncertainty index(maximum of 1 digit). 3. Some inefficient arrays(Sigma_RVS_norm_sq) were eliminated and some code lines in Preprocess_L1A_Data were moved into Process_OBCEng_Emiss. There were no changes to the product. Required RAM was reduced by 20 MB. Now

value

int32 value

Definition: Granule.c:1235

fascode_routines::tref

real, dimension(fnm) tref

Definition: FASCODE_routines.f90:136

cldmsk::get_valid

bool(* get_valid)(const l1str &, int, int, int)

Definition: sst_cloud_mask_utils.hpp:215

mapgen.key

key

Definition: mapgen.py:231

min

These are used to scale the SD before writing it to the HDF4 file The default is and which means the product is not scaled at all Since the product is usually stored as a float inside of this is a way to write the float out as a integer l2prod min

Definition: HOWTO_Add_a_product.txt:76

cldmsk::get_window_1D_min

void get_window_1D_min(float *mins_1d, const float *inp1d, const int *mask1d, size_t npix, size_t radius)

the same as get_window_1D_max but for min

Definition: sst_cloud_mask_utils.cpp:87

cldmsk::bands_set

const std::unordered_map< std::string, const std::unordered_map< std::string, int > > bands_set

Definition: sst_cloud_mask_utils.hpp:85

out

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 as required for compatibility with version of the SDP toolkit Corrected test output file names to end in out

Definition: HISTORY.txt:422

d3940tref.h

cldmsk::get_value

float(* get_value)(const l1str &, int, int, int)

Definition: sst_cloud_mask_utils.hpp:216

l1rec

read l1rec

Definition: HOWTO_Add_a_sensor.txt:72

cldmsk::read_sst_bands

void read_sst_bands(const std::string &sat, std::unordered_map< std::string, int > &bands)

Definition: sst_cloud_mask_utils.cpp:166

counts

uint8 * counts

Definition: l1_czcs_hdf.c:30

nscan

int32 nscan

Definition: l1_czcs_hdf.c:19

envset::get_ocdata_root

std::string get_ocdata_root()

Returns OCDATAROOT.

Definition: sst_cloud_mask_utils.cpp:5

string

@ string

Definition: GEO_read_param_file.c:64

hico.proc_hico.senz

senz

Definition: proc_hico.py:239

cldmsk::get_sensor

std::string get_sensor(int key)

Get the sensor string.

Definition: sst_cloud_mask_utils.cpp:20

MDN.parameters.int

int

Definition: parameters.py:18

bindex_get

int bindex_get(int32_t wave)

Definition: windex.c:45

linterp

float linterp(float xin[], float yin[], int32_t nin, float xout)

Definition: lspline.c:59

cldmsk

Contains supportive functions and constants.

Definition: sst_cloud_mask_utils.cpp:16

cldmsk::get_window_1D_max

void get_window_1D_max(float *maxs_1d, const float *inp1d, const int *mask1d, size_t npix, size_t radius)

Compute max values within a 1D window in one line in a queue.

Definition: sst_cloud_mask_utils.cpp:55

envset

Definition: sst_cloud_mask_utils.cpp:4

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

cldmsk::get_total_2d_min

void get_total_2d_min(float *min_global, const float *inp2d, size_t npix, size_t nscan, size_t center, size_t radius)

the same as get_total_2d_max but for min

Definition: sst_cloud_mask_utils.cpp:105

diff

subroutine diff(x, conec, n, dconecno, dn, dconecmk, units, u, inno, i, outno, o, input, deriv)

Definition: ffnet.f:205

cldmsk::month_data

std::vector< float > & month_data()

month variable for the desicion tree traversal

Definition: sst_cloud_mask_utils.cpp:18

#define BT

Definition: st_lt.h:10

sort_gring.center

def center

Definition: sort_gring.py:68

cldmsk::month_data_

std::vector< float > month_data_

Definition: sst_cloud_mask_utils.cpp:17

BAD_FLT

#define BAD_FLT

Definition: jplaeriallib.h:19

nbands

int32_t nbands

Definition: atrem_corl1v3.h:190

cldmsk::get_std_box

void get_std_box(const float *inp2d, const int *mask2d, size_t npix, size_t nscan, size_t radius_x, size_t radius_y, float *out, size_t center, l1qstr *l1qrec)

Compute standard deviation in a window.

Definition: sst_cloud_mask_utils.cpp:121

cldmsk::get_total_2d_max

void get_total_2d_max(float *max_global, const float *inp2d, size_t npix, size_t nscan, size_t center, size_t radius)

Get the max value of center line with 2D sliding window using a 1D max queue computed with get_window...

Definition: sst_cloud_mask_utils.cpp:72

NSENZ

#define NSENZ

Definition: d3940tref.h:3

cldmsk::btrefdiffv6

float btrefdiffv6(int32_t ip, float BT39, float BT40, const l1str *l1rec, int fullscanpix)

Legacy BT diff test with interpolation adjutment.