NASA Ocean Color

ocssw V2022

 #include "expand3D.hpp"
 #include "sensorInfo.h"
 #include <limits>
 #include "find_variable.hpp"
  
 namespace {
 std::unordered_map<std::string, std::string> l3d_to_l2_prod_map;
 std::unordered_map<std::string, float> l3d_wave_attr;
 std::unordered_map<std::string, std::pair<int, int>> l3d_indexes;
 std::unordered_map<std::string, std::vector<int>> three_dims_prod_wavelength;
 std::unordered_map<std::string, std::vector<float>> three_d_original_prod_wavelength;
 std::unordered_set<std::string> original_l2_products;
 std::unordered_map<std::string, std::pair<float, float>> min_max_values;
 std::unordered_set<int> wavelength_all;
 std::string platform, instrument;
 int sensorID;
 bool ini_3d{false};
 bool use_l2_flags{false};
  
 template <class T, class F>
 std::vector<F> vector_rounder(const std::vector<T> &inp) {
     std::vector<F> result(inp.size());
     std::transform(inp.begin(), inp.end(), result.begin(),
                    [](const auto &c) { return static_cast<F>(std ::round(c)); });
     return result;
 }
  
 }  // namespace
  
 void parse_colon_range(const std::string &wv_range, const std::unordered_map<int, int> &wv3d_list,
                        std::vector<int> &wv_requested_vals, std::vector<int> &wv_requested_indexes,
                        std::unordered_set<int> &wv_requested_vals_lookup) {
     std::vector<std::string> result_colon;
     boost::split(result_colon, wv_range, boost::is_any_of(":"), boost::algorithm::token_compress_on);
     if (result_colon.size() != 2) {
         EXIT_LOG(std::cerr << "--Error-- : The range must be supplied in the form nnn:nnn. The input "
                            << wv_range << " does not match the format" << std::endl)
     }
     try {
         int min_wv = boost::lexical_cast<int>(result_colon.at(0));
         int max_wv = boost::lexical_cast<int>(result_colon.at(1));
         if (wv3d_list.count(min_wv) == 0) {
             EXIT_LOG(std::cerr << "--Error-- : Start range value not found : " << min_wv << std::endl)
         }
         if (wv3d_list.count(max_wv) == 0) {
             EXIT_LOG(std::cerr << "--Error-- : End range value not found : " << max_wv << std::endl)
         }
         for (int wv = min_wv; wv <= max_wv; wv++) {
             if (wv3d_list.count(wv) > 0) {
                 if (wv_requested_vals_lookup.count(wv) == 0) {
                     wv_requested_vals.push_back(wv);
                     wv_requested_indexes.push_back(wv3d_list.at(wv));
                     wv_requested_vals_lookup.insert(wv);
                 }
             }
         }
     } catch (const boost::bad_lexical_cast &error_boost) {
         EXIT_LOG(std::cerr << "--Error-- : Conversion failed for WV3D : " << error_boost.what() << std::endl)
     }
 };
 void parse_wv_list(const std::string &wv_list, const std::unordered_map<int, int> &wv3d_list,
                    std::vector<int> &wv_requested_vals, std::vector<int> &wv_requested_indexes,
                    bool exit_on_not_found) {
     std::vector<std::string> result_comma;
     std::unordered_set<int> wv_requested_vals_lookup;
     boost::split(result_comma, wv_list, boost::is_any_of(", "), boost::algorithm::token_compress_on);
     try {
         std::for_each(result_comma.begin(), result_comma.end(), [&](const std::string &wv_str) {
             if (boost::contains(wv_str, ":"))
                 parse_colon_range(wv_str, wv3d_list, wv_requested_vals, wv_requested_indexes,
                                   wv_requested_vals_lookup);
             else {
                 int wv = boost::lexical_cast<int>(wv_str);
                 if (wv3d_list.count(wv) > 0) {
                     if (wv_requested_vals_lookup.count(wv) == 0) {
                         wv_requested_vals.push_back(wv);
                         wv_requested_indexes.push_back(wv3d_list.at(wv));
                         wv_requested_vals_lookup.insert(wv);
                     }
                 } else if (exit_on_not_found) {
                     EXIT_LOG(std::cerr << "--Error-- : Wavelength " << wv << " nm "
                                        << "not found");
                 }
             }
         });
     } catch (const boost::bad_lexical_cast &error_boost) {
         EXIT_LOG(std::cerr << "--Error-- : Conversion failed for WV3D : " << error_boost.what() << std::endl)
     }
     std::cout << "\n";
 }
  
 std::vector<std::string> create_min_max_values(const std::vector<std::string> &products_requested_separated,
                                                productInfo_t *info) {
     std::vector<std::string> output_expanded_products;
  
     for (const auto &prod_with_min_max : products_requested_separated) {
         std::vector<std::string> prod_data;
         float max_val_preset, min_val_preset;
         boost::algorithm::split(prod_data, prod_with_min_max, boost::is_any_of("="),
                                 boost::token_compress_on);  // products_requested}
         {
             if (findProductInfo(prod_data.at(0).c_str(), sensorID, info)) {
                 min_val_preset = info->validMin;
                 max_val_preset = info->validMax;
             } else {
                 min_val_preset = 0.0;
                 max_val_preset = std::numeric_limits<float>::max();
             }
         }
         if (prod_data.size() > 1) {
             output_expanded_products.push_back(prod_data.at(0));
             std::vector<std::string> min_max_sep;
             boost::algorithm::split(min_max_sep, prod_data.at(1), boost::is_any_of(":"),
                                     boost::token_compress_on);  // products_requested}
             if (min_max_sep.size() == 1) {
                 min_max_values[prod_data.at(0)] = {std::stof(min_max_sep.at(0)), max_val_preset};
             } else if (min_max_sep.size() == 2) {
                 float max_val =
                     min_max_sep.at(1).length() > 0 ? std::stof(min_max_sep.at(1)) : max_val_preset;
                 float min_val =
                     min_max_sep.at(0).length() > 0 ? std::stof(min_max_sep.at(0)) : min_val_preset;
                 min_max_values[prod_data.at(0)] = {min_val, max_val};
             } else {
                 EXIT_LOG(std::cerr << "--Error-- : Can't parse the product " << prod_with_min_max
                                    << std::endl)
             }
         } else {
             output_expanded_products.push_back(prod_with_min_max);
             min_max_values[prod_with_min_max] = {min_val_preset, max_val_preset};
         }
     }
  
     return output_expanded_products;
 }
  
 std::string get_3d_product_name(const std::string &prod_3d, const std::string &wv,
                                 productInfo_t *info = nullptr) {
     if (findProductInfo(prod_3d.c_str(), sensorID, info)) {
         std::string prefix = info->prefix;
         std::string suffix = info->suffix;
         return prefix + "_" + wv + suffix;
     }
     return prod_3d + "_" + wv;
 }
  
 std::string get_3d_product_name(const std::string &prod_3d, int wv, productInfo_t *info = nullptr) {
     return get_3d_product_name(prod_3d, std::to_string(wv), info);
 }
  
 std::string get_3d_product_name(const std::string &prod_3d, int *wv, productInfo_t *info = nullptr) {
     std::vector<std::string> parsed_product;
     boost::algorithm::split(parsed_product, prod_3d, boost::is_any_of("_"));
     std::string return_string;
     for (size_t i = 0; i < parsed_product.size(); i++) {
         try {
             int wv_3d = std::stoi(parsed_product.at(i));
             if (wavelength_all.find(wv_3d) != wavelength_all.end()) {
                 // check if the name does exist
                 std::string name_l2 = parsed_product.at(0);
                 for (size_t k = 1; k < i; k++) {
                     name_l2 += "_" + parsed_product.at(k);
                 }
                 for (size_t k = i + 1; k < parsed_product.size(); k++) {
                     name_l2 += "_" + parsed_product.at(k);
                 }
                 return_string = name_l2;
                 if (findProductInfo(return_string.c_str(), sensorID, info)) {
                     std::string prefix = info->prefix;
                     std::string suffix = info->suffix;
                     return_string = prefix + suffix;
                 }
                 if (original_l2_products.count(name_l2) || original_l2_products.count(return_string)) {
                     *wv = wv_3d;
                     break;
                 }
             }
         } catch (...) {
         }
     }
     return return_string;
 }
  
 void expand_l2_requested(std::vector<std::string> &products_requested_separated, productInfo_t *info) {
     std::unordered_set<std::string> remove;
     std::vector<std::string> add_3d_expanded;
     for (auto &prod : products_requested_separated) {
         if (three_dims_prod_wavelength.count(prod) > 0) {
             remove.insert(prod);
             std::vector<int> &wavelengths_3d = three_dims_prod_wavelength[prod];
             for (const auto &wv : wavelengths_3d) {
                 std::string exp3d_name =
                     get_3d_product_name(prod, wv, info);  // prod + "_" + std::to_string(wv);
                 add_3d_expanded.push_back(exp3d_name);
                 min_max_values[exp3d_name] = min_max_values.at(prod);
             }
         }
     }
  
     if (!remove.empty()) {
         for (const auto &rem : remove) {
             // std::cout << "All wavelength will be binned and sent to output for " << rem << std::endl;
             auto it =
                 std::find(products_requested_separated.begin(), products_requested_separated.end(), rem);
             products_requested_separated.erase(it);
         }
         for (const auto &prod_exp_3d : add_3d_expanded) {
             products_requested_separated.push_back(prod_exp_3d);
         }
     }
 }
  
 void set_mapper(const std::string &input_file_name, std::string &products_requested,
                 std::vector<std::string> &products_requested_separated,
                 const std::string &requested_wavelengths) {
     ini_3d = true;
     netCDF::NcFile l2_file(input_file_name, netCDF::NcFile::read);
     l2_file.getAtt("instrument").getValues(instrument);
     l2_file.getAtt("platform").getValues(platform);
     sensorID = instrumentPlatform2SensorId(instrument.c_str(), platform.c_str());
     // set 3d and 2d products
     {
         std::multimap<std::string, netCDF::NcVar> vars = find_all_variables(l2_file);
         for (const auto &var : vars) {
             const auto dims = var.second.getDims();
             if (dims.size() <= 1)
                 continue;
             if (dims.size() == 3) {
                 std::string dim_name = dims[2].getName();
                 int dim_id = dims[2].getId();
                 size_t dim_size = dims[2].getSize();
                 // get variable name using dimension
                 const std::string &variable_3d = dim_name;
                 netCDF::NcVar nc_var = find_nc_variable_cpp(variable_3d, l2_file);
                 int dim_3d_id = -1;
                 size_t dim_3d_size = 0;
                 if (!nc_var.isNull()) {
                     dim_3d_id = nc_var.getDims().at(0).getId();
                     dim_3d_size = nc_var.getDims().at(0).getSize();
                 }
                 if (nc_var.isNull() || dim_3d_id != dim_id || dim_3d_size != dim_size) {
                     netCDF::NcGroup parent_grp = var.second.getParentGroup();
                     nc_var = find_nc_variable_cpp("wavelength", parent_grp);
                 }
                 // third dimension is not wavelength
                 if (nc_var.isNull()) {
                     std::cout << "Variable " << var.second.getName()
                               << " is 3D dimensional but no suitable wavelength set was found" << std::endl;
                     continue;
                 }
                 std::vector<int> waves;
                 std::vector<float> waves_original;
                 if (nc_var.getType() == netCDF::ncFloat) {
                     std::vector<float> temp_(dim_size);
                     nc_var.getVar(temp_.data());
                     waves = vector_rounder<float, int>(temp_);
                     std::copy(temp_.begin(), temp_.end(), std::back_inserter(waves_original));
                 } else if (nc_var.getType() == netCDF::ncDouble) {
                     std::vector<double> temp_(dim_size);
                     nc_var.getVar(temp_.data());
                     waves = vector_rounder<double, int>(temp_);
                     std::copy(temp_.begin(), temp_.end(), std::back_inserter(waves_original));
                 } else if (nc_var.getType() == netCDF::ncInt) {
                     waves.resize(dim_size);
                     nc_var.getVar(waves.data());
                     std::copy(waves.begin(), waves.end(), std::back_inserter(waves_original));
                 }
                 three_dims_prod_wavelength[var.first] = waves;
                 three_d_original_prod_wavelength[var.first] = waves_original;
                 for (auto &wv_ : waves)
                     wavelength_all.insert(wv_);
             }
             original_l2_products.insert(var.first);
         }
     }
     // read dimensions and set wavelength needed.
     for (auto &var_dim : three_dims_prod_wavelength) {
         if (requested_wavelengths != "ALL") {
             std::unordered_map<int, int> wv_3d_val_index;
             std::vector<int> &wavelengths_3d = var_dim.second;
             int count = 0;
             std::for_each(wavelengths_3d.begin(), wavelengths_3d.end(), [&](const int &val) {
                 wv_3d_val_index.insert({val, count});
                 count++;
             });
             std::vector<int> wv_requested_indexes;
             wavelengths_3d.clear();
             parse_wv_list(requested_wavelengths, wv_3d_val_index, wavelengths_3d, wv_requested_indexes,
                           false);
         }
     }
     {
         boost::algorithm::split(products_requested_separated, products_requested, boost::is_any_of(", "),
                                 boost::token_compress_on);  // products_requested
         productInfo_t *info = allocateProductInfo();
         products_requested_separated = create_min_max_values(products_requested_separated, info);
         // l2->l2 3d wavelength expansion
         expand_l2_requested(products_requested_separated, info);
         {
             for (const auto &prod : products_requested_separated) {
                 if (original_l2_products.count(prod)) {
                     l3d_to_l2_prod_map[prod] = prod;
                     l3d_indexes[prod] = {0, 1};
                     continue;
                 }
                 {
                     int wv_num = -1;
                     std::string original_2_prod_name = get_3d_product_name(prod, &wv_num, info);
                     // original_2_prod_name should be a 3D poduct
                     if (original_l2_products.count(original_2_prod_name)) {
                         // const auto wv_str = parsed_product.at(len_of_underscore_sep - 1);
                         try {
                             // const int wv_num = std::stoi(wv_str);
                             int index = -1;
                             if (three_dims_prod_wavelength.count(original_2_prod_name)) {
                                 std::vector<int> &wavelengths_3d =
                                     three_dims_prod_wavelength[original_2_prod_name];
                                 auto it = std::find(wavelengths_3d.begin(), wavelengths_3d.end(), wv_num);
                                 if (it == wavelengths_3d.end()) {
                                     EXIT_LOG(std::cerr << "--Error-- : Wavelength not found; product = "
                                                        << prod << ", wavelength =  " << wv_num
                                                        << ", L2 file = " << input_file_name << std::endl)
                                 }
                                 index = it - wavelengths_3d.begin();
                                 l3d_indexes[prod] = {index, index + 1};
                                 l3d_to_l2_prod_map[prod] = original_2_prod_name;
                                 std::vector<float> &wavelengths_original =
                                     three_d_original_prod_wavelength[original_2_prod_name];
                                 l3d_wave_attr[prod] = wavelengths_original[index];
                             } else {
                                 EXIT_LOG(std::cerr << "--Error-- : product = " << prod << " must be 3d"
                                                    << std::endl)
                             }
  
                         } catch (const std::exception &e) {
                             EXIT_LOG(std::cerr << e.what() << '\n')
                         }
                     } else {
                         EXIT_LOG(std::cerr << "--Error-- : Product not found = " << prod
                                            << ", L2 file = " << input_file_name << std::endl)
                     }
                 }
             }
         }
         freeProductInfo(info);
     }
  
     l2_file.close();
 }
  
 int32_t get_l2prod_index(const l2_prod &l2, const char *prodname) {
     int32_t index;
     for (index = 0; index < l2.nprod; index++)
         if (strcmp(prodname, l2.prodname[index]) == 0)
             break;
     if (index == l2.nprod)
         index = -1;
     return index;
 }
  
 void set_prodname_3d_to_l2(const std::vector<std::string> &prodparam, l2_prod &l2_str,
                            std::vector<std::string> &l2_prodname, std::vector<std::string> &l3_prodname,
                            std::vector<int32_t> &thirdDimId, std::vector<float> &min_value,
                            std::vector<float> &max_value) {
     for (const auto &prod_name : prodparam) {
         int32_t l2_iprod = get_l2prod_index(l2_str, prod_name.c_str());
         if (l2_iprod == -1) {
             printf("--Error-- Product: %s was not found in the L2 file: %s. See line %d in %s\n",
                    prod_name.c_str(), l2_str.filename, __LINE__, __FILE__);
             exit(EXIT_FAILURE);
         }
         int32_t tmpThirdDim = l2_str.thirdDim[l2_iprod];
         if (tmpThirdDim == 1) {
             l2_prodname.push_back(prod_name);
             l3_prodname.push_back(prod_name);
             thirdDimId.push_back(0);
             min_value.push_back(min_max_values.at(prod_name).first);
             max_value.push_back(min_max_values.at(prod_name).second);
         } else {
             EXIT_LOG(std::cerr << "--Error--: All products must be 2D. Error for " << prod_name << std::endl)
         }
     } /* iprod loop */
 }
  
 bool set_l2_flags_use(const std::string &flagsuse) {
     if (!flagsuse.empty())
         use_l2_flags = true;
     return use_l2_flags;
 }
  
 void l3_l2_conversion(char **inp3, char **out2) {
     if (ini_3d) {
         *out2 = &l3d_to_l2_prod_map.at(*inp3)[0];
     } else {
         *out2 = *inp3;
     }
 }
  
 float l3_attr(const std::string &inp3) {
     if (l3d_wave_attr.count(inp3))
         return l3d_wave_attr.at(inp3);
     else
         return BAD_FLT;
 }
  
 void l3_l2_index(char **inp3, int *start, int *count) {
     if (ini_3d) {
         *start = l3d_indexes.at(*inp3).first;
         *count = l3d_indexes.at(*inp3).second - l3d_indexes.at(*inp3).first;
     }
 }
 int get_set_flag() {
     return ini_3d ? 1 : 0;
 }
 int get_l2_flag_use() {
     int ans = use_l2_flags ? 1 : 0;
     if (!ini_3d)
         return true;
     return ans;
 }

seadasutils.DictUtils.val

int val

Definition: DictUtils.py:140

convert2ocrvc.instrument

instrument

Definition: convert2ocrvc.py:29

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

nc_var

Definition: val_extract.h:273

freeProductInfo

void freeProductInfo(productInfo_t *info)

Definition: productInfo.cpp:145

instrumentPlatform2SensorId

int instrumentPlatform2SensorId(const char *instrument, const char *platform)

Definition: sensorInfo.c:405

mapgen_overlay.transform

transform

Definition: mapgen_overlay.py:186

get_l2prod_index

int32_t get_l2prod_index(const l2_prod &l2, const char *prodname)

Definition: expand3D.cpp:373

string

@ string

Definition: GEO_read_param_file.c:64

get_set_flag

int get_set_flag()

Definition: expand3D.cpp:434

seadasutils.ProcUtils.remove

def remove(file_to_delete)

Definition: ProcUtils.py:319

find_nc_variable_cpp

netCDF::NcVar find_nc_variable_cpp(const std::string &var_name, T &nc_file)

Definition: find_variable.hpp:7

EXIT_LOG

#define EXIT_LOG(...)

Definition: Log.hpp:26

find_variable.hpp

l3_l2_conversion

void l3_l2_conversion(char **inp3, char **out2)

Definition: expand3D.cpp:413

l3_l2_index

void l3_l2_index(char **inp3, int *start, int *count)

Definition: expand3D.cpp:428

find_all_variables

std::multimap< std::string, netCDF::NcVar > find_all_variables(T &nc_id)

Definition: find_variable.hpp:37

get_3d_product_name

std::string get_3d_product_name(const std::string &prod_3d, const std::string &wv, productInfo_t *info=nullptr)

Definition: expand3D.cpp:145

allocateProductInfo

productInfo_t * allocateProductInfo()

Definition: productInfo.cpp:133

expand3D.hpp

expand_l2_requested

void expand_l2_requested(std::vector< std::string > &products_requested_separated, productInfo_t *info)

The user can supply a 3D product such as "Lt" or "Rrs" and they will be expanded: Rrs_449 etc.

Definition: expand3D.cpp:197

set_prodname_3d_to_l2

void set_prodname_3d_to_l2(const std::vector< std::string > &prodparam, l2_prod &l2_str, std::vector< std::string > &l2_prodname, std::vector< std::string > &l3_prodname, std::vector< int32_t > &thirdDimId, std::vector< float > &min_value, std::vector< float > &max_value)

Definition: expand3D.cpp:383

color_dtdb.result

result

Definition: color_dtdb.py:197

min_value

std::vector< float32 > min_value

Definition: l2bin.cpp:100

seadasutils.aquarius_utils.start

start

Definition: aquarius_utils.py:27

set_l2_flags_use

bool set_l2_flags_use(const std::string &flagsuse)

Definition: expand3D.cpp:407

convert2ocrvc.platform

platform

Definition: convert2ocrvc.py:30

focs::LogSeverity::info

@ info

info severity

modis.modis_utils.prefix

prefix

Definition: modis_utils.py:280

findProductInfo

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

Definition: productInfo.cpp:983

thirdDimId

std::vector< int32_t > thirdDimId

Definition: l2bin.cpp:99

BAD_FLT

#define BAD_FLT

Definition: jplaeriallib.h:19

copy

void copy(double **aout, double **ain, int n)

parse_colon_range

void parse_colon_range(const std::string &wv_range, const std::unordered_map< int, int > &wv3d_list, std::vector< int > &wv_requested_vals, std::vector< int > &wv_requested_indexes, std::unordered_set< int > &wv_requested_vals_lookup)

Definition: expand3D.cpp:30

l3_attr

float l3_attr(const std::string &inp3)

Definition: expand3D.cpp:421

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 per delivery and then split off a new MYD_PR03 pcf file for Aqua Added AssociatedPlatformInstrumentSensor to the inventory metadata in MOD01 mcf and MOD03 mcf Created new versions named MYD01 mcf and MYD03 where AssociatedPlatformShortName is rather than Terra The program itself has been changed to read the Satellite Instrument validate it against the input L1A and LUT and to use it determine the correct files to retrieve the ephemeris and attitude data from Changed to produce a LocalGranuleID starting with MYD03 if run on Aqua data Added the Scan Type file attribute to the Geolocation copied from the L1A and attitude_angels to radians rather than degrees The accumulation of Cumulated gflags was moved from GEO_validate_earth_location c to GEO_locate_one_scan c

Definition: HISTORY.txt:464

create_min_max_values

std::vector< std::string > create_min_max_values(const std::vector< std::string > &products_requested_separated, productInfo_t *info)

Definition: expand3D.cpp:101

int i

Definition: decode_rs.h:71

max_value

std::vector< float32 > max_value

Definition: l2bin.cpp:100

sensorID

int32_t sensorID[MAXNFILES]

Definition: l2bin.cpp:91

int k

Definition: decode_rs.h:73

get_l2_flag_use

int get_l2_flag_use()

Definition: expand3D.cpp:437

sensorInfo.h

set_mapper

void set_mapper(const std::string &input_file_name, std::string &products_requested, std::vector< std::string > &products_requested_separated, const std::string &requested_wavelengths)

readL2, openL2 uses the maps from this module. If the module is not initialized, the function read an...

Definition: expand3D.cpp:235

parse_wv_list

void parse_wv_list(const std::string &wv_list, const std::unordered_map< int, int > &wv3d_list, std::vector< int > &wv_requested_vals, std::vector< int > &wv_requested_indexes, bool exit_on_not_found)

Definition: expand3D.cpp:70

max

l2prod max

Definition: HOWTO_Add_a_product.txt:77

count

int count

Definition: decode_rs.h:79