VcstLutNetCDF4.cpp

Go to the documentation of this file.

/******************************************************************************
 *  NAME: VcstLutNetCDF4.cpp
 *
 *  DESCRIPTION: Object class that generates a netCDF4 LUT.
 *
 *  Created on: June 5, 2015
 *      Author: Sam Anderson, VCST
 *
 *  Modified: October 15, 2015, for generation and processing of time-dependent
 *  netCDF4 LUTs
 *
 ******************************************************************************/
 
#include <cstdlib>
#include <map>
#include <string>
#include <ctime>
#include <math.h>
#include <memory>
#include <sys/stat.h>
#include <dirent.h>
#include <algorithm>
#include <limits>       // std::numeric_limits
 
#include "VcstLutNetCDF4.h"
#include <VcstParamsReader.h>
#include <VcstCmnConsts.h>
#include <VcstCalLutStructures.h>
#include <VcstTime.h>
 
/**************************************************************************
 * NAME: VcstLutNetCDF4()
 *
 * DESCRIPTION: Class Constructor
 *
 *************************************************************************/
 
VcstLutNetCDF4::VcstLutNetCDF4() {
}
 
/**************************************************************************
 * NAME: ~VcstLutNetCDF4()
 *
 * DESCRIPTION: Class Destructor
 *
 *************************************************************************/
 
VcstLutNetCDF4::~VcstLutNetCDF4() {
}
 
/**************************************************************************
 * NAME: initialize()
 *
 * DESCRIPTION: Initializes data and object classes for granule
 *
 *************************************************************************/
 
int VcstLutNetCDF4::initialize( string platform ) {
 
    if (platform == "Suomi-NPP" || platform == "npp") {
        platform_ = NPP;
        platform_str_ = "NPP";
    } else if (platform == "JPSS-J1" || platform == "j1") {
        platform_ = J1;
        platform_str_ = "J1";
    } else {
        cerr << "VcstLutNetCDF4:: Invalid platform option --> "
                + platform + "." << endl;
        return VCST_FAIL;
    }
 
    return VCST_SUCCESS;
}
 
/**************************************************************************
 * NAME: create_cmngeo_lut()
 *
 * DESCRIPTION: Create Common Geolocation netCDF4 LUT.
 *
 *************************************************************************/
 
int VcstLutNetCDF4::create_cmngeo_lut() {
    int status = VCST_SUCCESS;
 
    string path = VL1_get_group(VIIRS_NETCDF_LUT_PATH);
    string filepath = path + "/VIIRS_" + platform_str_ + "_CMN_LUT_" +
            "version_source.nc";
 
    NcFile* nc_output;
 
    try {
        nc_output = new NcFile(filepath, NcFile::replace);
    } catch (NcException& e) {
        e.what();
        cerr
                << "VcstLutNetCDF4:: Failure creating CMN netCDF4 LUT file: "
                + filepath + "." << endl;
        return VCST_FAIL;
    }
 
    nc_output->putAtt("title", "VIIRS Common Geolocation LUTs");
 
    write_global_attributes(nc_output);
 
    // Add dimensions to file
 
    scalar_dim_ = nc_output->addDim("Scalar", 1);
    two_values_dim_ = nc_output->addDim("Number_of_Scan_Start_Values", 2);
    num_jpl_ipt_rows_dim_ = nc_output->addDim("Number_of_JPL_IPT_Rows",
            JPL_IPT_ROW);
    num_jpl_ipt_cols_dim_ = nc_output->addDim("Number_of_JPL_IPT_Columns",
            JPL_IPT_COL);
    num_jpl_ephem_rows_dim_ = nc_output->addDim("Number_of_JPL_Ephemeris_Rows",
            JPL_EPHEM_ROW);
    num_jpl_ephem_cols_dim_ = nc_output->addDim(
            "Number_of_JPL_Ephemeris_Columns", JPL_EPHEM_COL);
    min_max_dim_ = nc_output->addDim("Minimum_Maximum_Values",
            CMNGEO_MIN_MAX_DIM);
    num_sdsm_samples_dim_ = nc_output->addDim("Number_of_SDSM_Samples",
            SDSM_SAMPLES);
    num_sdsm_det_dim_ = nc_output->addDim("Number_of_SDSM_Detectors",
            SDSM_DETECTORS);
    num_sdsm_coef_dim_ = nc_output->addDim("Number_of_SDSM_Coeffs", SDSM_COEF);
    matrix_rows_dim_ = nc_output->addDim("Matrix_Rows", 3);
    matrix_cols_dim_ = nc_output->addDim("Matrix_Cols", 3);
    num_viirs_bands_dim_ = nc_output->addDim("Number_of_VIIRS_Bands",
            NUM_VIIRS_BAND);
    num_viirs_detectors_dim_ = nc_output->addDim("Number_of_Viirs_Detectors",
            NUM_DETECTORS);
    num_qual_flag_values_dim_ = nc_output->addDim(
            "Number_of_Quality_Flag_Values", 8);
    num_moon_offset_dim_ = nc_output->addDim("Number_of_Moon_Offset_limits",
            NUM_MOON_OFFSET_LIMITS);
 
    // Write spacecraft-specific parameters
 
    status = write_CMNGEO_PLATFORM_LUT(nc_output);
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + CMNGEO_PLATFORM_LUT
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    // Read and create LUTs in the form of groups
 
    std::string fileName = "";
    VcstCmnLutInputItem* lut_item;
 
    lut_item = read_cmngeo_lut(CMNGEO_JPL_EPHEM, sizeof (JPLEphemLutType));
 
    if (lut_item != 0) {
        jplEphemPtr_ = static_cast<JPLEphemLutType*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_CMNGEO_JPL_EPHEM(nc_output, jplEphemPtr_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + CMNGEO_JPL_EPHEM
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cmngeo_lut(CMNGEO_SAA_COEFF, sizeof (SAALutType));
 
    if (lut_item != 0) {
        saaCoeff_ = static_cast<SAALutType*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_CMNGEO_SAA_COEFF(nc_output, saaCoeff_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + CMNGEO_SAA_COEFF
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cmngeo_lut(CMNGEO_PARAM_LUT, sizeof (CmnGeoParamLutType));
 
    if (lut_item != 0) {
        paramLut_ = static_cast<CmnGeoParamLutType*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_CMNGEO_PARAM_LUT(nc_output, paramLut_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + CMNGEO_PARAM_LUT
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cmngeo_lut(VIIRS_SOLAR_DIFF_ROT_MATRIX_LUT,
            sizeof (SolarDiffRotationMatrixLutType));
 
    if (lut_item != 0) {
        SdRotMatPtr_ =
                static_cast<SolarDiffRotationMatrixLutType*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SOLAR_DIFF_ROT_MATRIX_LUT(nc_output, SdRotMatPtr_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing "
                + VIIRS_SOLAR_DIFF_ROT_MATRIX_LUT
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cmngeo_lut(VIIRS_SOLAR_DIFF_VOLT_LUT,
            sizeof (SolarDiffVoltLutType));
 
    if (lut_item != 0) {
        SdsmVoltPtr_ =
                static_cast<SolarDiffVoltLutType*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SOLAR_DIFF_VOLT_LUT(nc_output, SdsmVoltPtr_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing "
                + VIIRS_SOLAR_DIFF_VOLT_LUT + " to netCDF4 LUT file "
                << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cmngeo_lut(VIIRS_SDR_QA_LUT, sizeof (proSdrViirsCalQALUT));
 
    if (lut_item != 0) {
        QALUT_ = static_cast<proSdrViirsCalQALUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_QA_LUT(nc_output, QALUT_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_QA_LUT
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    delete nc_output;
 
    return VCST_SUCCESS;
}
 
/**************************************************************************
 * NAME: create_geo_lut()
 *
 * DESCRIPTION: Create Geolocation netCDF4 LUT.
 *
 *************************************************************************/
 
int VcstLutNetCDF4::create_geo_lut() {
    int status = VCST_SUCCESS;
 
    string path = VL1_get_group(VIIRS_NETCDF_LUT_PATH);
    string filepath = path + "/VIIRS_" + platform_str_ + "_GEO_LUT_" +
            "version_source.nc";
 
    NcFile* nc_output;
 
    try {
        nc_output = new NcFile(filepath, NcFile::replace);
    } catch (NcException& e) {
        e.what();
        cerr
                << "VcstLutNetCDF4:: Failure creating GEO netCDF4 LUT file: "
                + filepath + "." << endl;
 
        return VCST_FAIL;
    }
 
    nc_output->putAtt("title", "VIIRS Geolocation LUTs");
 
    write_global_attributes(nc_output);
 
    scalar_dim_ = nc_output->addDim("Scalar", 1);
    revision_char_dim_ = nc_output->addDim("Number_of_Revision_Characters", 10);
    max_band_num_plus_one_dim_ = nc_output->addDim("Max_Band_Number_Plus_One",
            MAX_BAND_NUMBER_PLUS_ONE);
    num_aggzones_dim_ = nc_output->addDim("Number_of_Agg_Zones", NUM_AGG_ZONES);
    num_dnb_aggzone_dim_ = nc_output->addDim("Number_of_DNB_Agg_Zones", 32);
    dnb_aggzone_bounds_dim_ = nc_output->addDim("Number_of_DNB_Agg_Zone_Bounds",
            64);
    dnb_aggzone_bound_cols_dim_ = nc_output->addDim(
            "Number_of_DNB_Agg_Zone_Bound_Cols", 3);
    num_mirror_sides_dim_ = nc_output->addDim("Mirror_Sides", 2);
    max_limit_check_dim_ = nc_output->addDim("Max_Limit_Check", 2);
    matrix_rows_dim_ = nc_output->addDim("Matrix_Rows", 3);
    matrix_cols_dim_ = nc_output->addDim("Matrix_Cols", 3);
    max_thermistor_id_dim_ = nc_output->addDim("Max_Thermistor_ID",
            MAX_THERMISTOR_ID_LEN);
    num_thermistors_dim_ = nc_output->addDim("Number_of_Thermistors",
            NUM_THERMISTORS);
    num_thermistor_coeffs_dim_ = nc_output->addDim(
            "Number_of_Thermistor_Coeffs", 6);
    max_poly_degree_plus_one_dim_ = nc_output->addDim(
            "Max_Polynomial_Deg_Plus_One", 5);
    num_electronics_sides_dim_ = nc_output->addDim("Electronics_Sides", 2);
 
    VcstGeoLutInputItem* lut_item;
    std::string fileName = "";
 
    lut_item = read_geo_lut(GEO_IMG_PARAM, sizeof (GEO_param_struct));
 
    if (lut_item != 0) {
        geoImgParams_ = static_cast<GEO_param_struct*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_GEO_PARAM_LUT(nc_output, geoImgParams_, GEO_IMG_PARAM,
            fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + GEO_IMG_PARAM
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_geo_lut(GEO_MOD_PARAM, sizeof (GEO_param_struct));
 
    if (lut_item != 0) {
        geoModParams_ = static_cast<GEO_param_struct*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_GEO_PARAM_LUT(nc_output, geoModParams_, GEO_MOD_PARAM,
            fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + GEO_MOD_PARAM
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_geo_lut(GEO_DNB_PARAM, sizeof (GEO_param_struct));
 
    if (lut_item != 0) {
        geoDnbParams_ = static_cast<GEO_param_struct*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_GEO_PARAM_LUT(nc_output, geoDnbParams_, GEO_DNB_PARAM,
            fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + GEO_DNB_PARAM
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    delete nc_output;
 
    return VCST_SUCCESS;
}
 
/**************************************************************************
 * NAME: create_cal_static_lut()
 *
 * DESCRIPTION: Create Calibration netCDF4 LUT for static tables.
 *
 *************************************************************************/
 
int VcstLutNetCDF4::create_cal_static_lut() {
    int status = VCST_SUCCESS;
 
    string path = VL1_get_group(VIIRS_NETCDF_LUT_PATH);
    string filepath = path + "/VIIRS_" + platform_str_ + "_CAL_STATIC_LUT_" +
            "version_source.nc";;
 
    NcFile* nc_output;
 
    try {
        nc_output = new NcFile(filepath, NcFile::replace);
    } catch (NcException& e) {
        e.what();
        cerr
                << "VcstLutNetCDF4:: Failure creating CAL static netCDF4 LUT file: "
                + filepath + "." << endl;
 
        return VCST_FAIL;
    }
 
    nc_output->putAtt("title", "VIIRS Calibration Static LUTs");
 
    write_global_attributes(nc_output);
 
    scalar_dim_ = nc_output->addDim("Scalar", 1);
    num_refl_750m_dg_bands_dim_ = nc_output->addDim(
            "Number_of_Refl_750m_DG_Bands", NUM_REFL_750M_DG_BANDS);
    num_750m_det_dim_ = nc_output->addDim("Number_of_750m_Detectors",
            NUM_DETECTORS_750M);
    min_max_dim_ = nc_output->addDim("Minimum_Maximum_Values",
            PRO_VIIRS_MIN_MAX_DIM);
    num_dnb_ev_frames_dim_ = nc_output->addDim("Number_of_DNB_EV_Frames",
            EV_DNB_FRAMES);
    num_dnb_detectors_dim_ = nc_output->addDim("Number_of_DNB_Detectors",
            NUM_DETECTORS_DNB);
    num_mirror_sides_dim_ = nc_output->addDim("Number_of_Mirror_Sides",
            NUM_MIRROR_SIDES);
    num_viirs_bands_dim_ = nc_output->addDim("Number_of_VIIRS_Bands",
            NUM_VIIRS_BAND);
    max_num_detectors_dim_ = nc_output->addDim("Max_Number_of_Detectors",
            MAX_NUM_DETECTOR);
    num_rtaer_files_dim_ = nc_output->addDim("Number_of_RTAER_Files",
            NUM_OF_RTAER_FILES);
    two_values_dim_ = nc_output->addDim("Two_Values", 2);
    num_rtaer_values_dim_ = nc_output->addDim("Number_of_RTAER_Values",
            MAX_RTA_ER_INDEX);
    num_hamer_files_dim_ = nc_output->addDim("Number_of_HAMER_Files",
            NUM_OF_HAMER_FILES);
    num_hamer_values_dim_ = nc_output->addDim("Number_of_HAMER_Values",
            MAX_HAM_ER_INDEX);
    num_obcer_files_dim_ = nc_output->addDim("Number_of_OBCER_Files",
            NUM_OF_OBCER_FILES);
    num_obcer_values_dim_ = nc_output->addDim("Number_of_OBCER_Values",
            MAX_OBC_ER_INDEX);
    num_obcrr_files_dim_ = nc_output->addDim("Number_of_OBCRR_Files",
            NUM_OF_OBCRR_FILES);
    num_obcrr_values_dim_ = nc_output->addDim("Number_of_OBCRR_Values",
            MAX_OBC_RR_INDEX);
    num_ebbt_files_dim_ = nc_output->addDim("Number_of_EBBT_Files",
            NUM_OF_EBBT_FILES);
    num_ebbt_values_dim_ = nc_output->addDim("Number_of_EBBT_Values",
            MAX_EBBT_INDEX);
    num_thermistors_dim_ = nc_output->addDim("Number_of_Thermistors",
            NUM_THERMISTORS);
    num_temp_coeffs_dim_ = nc_output->addDim("Number_of_Temp_Coeffs",
            NUM_TEMP_COEFFS);
    num_tref_mux_dim_ = nc_output->addDim("Number_of_EV_Tref_Mux_Coeffs",
            NUM_MAX_EV_CT_PREC_TREF_MUX1CA);
    num_solar_irad_values_dim_ = nc_output->addDim(
            "Number_of_Solar_Irad_Values", X_Y_SIZE);
    num_dg_ev_frames_dim_ = nc_output->addDim("Number_of_DG_EV_Frames",
            EV_FRAMES_750m_DG);
    num_telec_therm_dim_ = nc_output->addDim("Number_of_Telec_Thermistors",
            NUM_TELEC_THERM);
    num_therm_weights_dim_ = nc_output->addDim("Number_of_Thermistor_Weights",
            2);
    num_tomm_therm_dim_ = nc_output->addDim("Number_of_Tomm_Thermistors",
            NUM_TOMM_THERM);
    num_ttel_therm_dim_ = nc_output->addDim("Number_of_Ttel_Thermistors",
            NUM_TTEL_TSH_TCAV);
    num_tm_therm_dim_ = nc_output->addDim("Number_of_T_Mirror_Thermistors",
            NUM_T_MIR_THERMISTORS);
    num_bb_therm_dim_ = nc_output->addDim("Number_of_BB_Thermistors",
            NUM_BB_THERMISTORS);
    num_375m_bands_dim_ = nc_output->addDim("Number_of_375m_Bands",
            NUM_375M_BANDS);
    num_375m_det_dim_ = nc_output->addDim("Number_of_375m_Detectors",
            NUM_DETECTORS_375M);
    num_375m_frms_dim_ = nc_output->addDim("Number_of_375m_EV_Frames",
            EV_375M_FRAMES);
    num_bb_coeff_dim_ = nc_output->addDim("Number_of_BB_Coeffs", 5);
    num_electronics_sides_dim_ = nc_output->addDim(
            "Number_of_Electronics_Sides", NUM_ELECTRONICS_SIDE);
    num_dg_gain_states_dim_ = nc_output->addDim("Number_of_Gain_States",
            NUM_M_I_GAIN_STATES);
    num_c_coeffs_dim_ = nc_output->addDim("Number_of_C_Coefficients",
            MAX_NUM_C_COEF);
    num_thermistor_dim_ = nc_output->addDim("Number_of_Values",
            telecThermistorNum);
    num_tele_levels_dim_ = nc_output->addDim("Number_of_Tele_Levels",
            NUM_TELE_LEVEL);
    num_focal_planes_dim_ = nc_output->addDim("Number_of_Focal_Planes",
            NUM_FOCAL_PLANES);
    num_tdet_levels_dim_ = nc_output->addDim("Number_of_Tdet_Levels",
            NUM_TDET_LEVEL);
    four_values_dim_ = nc_output->addDim("Four_Values", 4);
    num_750m_sg_bands_dim_ = nc_output->addDim("Number_of_750m_SG_Bands",
            NUM_750M_SG_BANDS);
    num_sg_ev_frames_dim_ = nc_output->addDim("Number_of_750m_SG_EV_Frames",
            EV_750M_SG_FRAMES);
    num_750m_dg_bands_dim_ = nc_output->addDim("Number_of_750m_DG_Bands",
            NUM_750M_DG_BANDS);
    num_refl_dnb_bands_dim_ = nc_output->addDim( "Number_Reflective_Plus_DNB_Bands", NUM_REFL_PLUS_DNB_BANDS );
    max_rsr_dim_ = nc_output->addDim( "Max_RSR_Values", MAX_RSR_VALUES );
 
    VcstCalLutInputItem* lut_item;
    std::string fileName = "";
 
    lut_item = read_cal_lut(VIIRS_SDR_TELE_COEFFS,
            sizeof (proSdrViirsCalTeleCoeffLUT));
 
    if (lut_item != 0) {
        tCoeffs_ =
                static_cast<proSdrViirsCalTeleCoeffLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_TELE_COEFFS_LUT(nc_output, tCoeffs_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_TELE_COEFFS
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_BB_TEMP_COEFFS,
            sizeof (proSdrViirsCalBBTempCoeffs));
 
    if (lut_item != 0) {
        bBTempCoeffs_ =
                static_cast<proSdrViirsCalBBTempCoeffs*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_BB_TEMP_COEFFS_LUT(nc_output, bBTempCoeffs_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing "
                + VIIRS_SDR_BB_TEMP_COEFFS + " to netCDF4 LUT file "
                << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_DG_ANOMALY_DN_LIMITS_LUT,
            sizeof (proSdrViirsCalDgAnDnLmtLUT));
 
    if (lut_item != 0) {
        dgAnDnLimits_ =
                static_cast<proSdrViirsCalDgAnDnLmtLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_DG_ANOMALY_DN_LIMITS_LUT(nc_output, dgAnDnLimits_,
            fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing "
                + VIIRS_DG_ANOMALY_DN_LIMITS_LUT
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_COEFF_A_LUT,
            sizeof (proSdrViirsCalDetectorResponseLUT));
 
    if (lut_item != 0) {
        TableA_ =
                static_cast<proSdrViirsCalDetectorResponseLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_COEFF_A_LUT(nc_output, TableA_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_COEFF_A_LUT
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_COEFF_B_LUT,
            sizeof (proSdrViirsCalInstrumentResponseLUT));
 
    if (lut_item != 0) {
        TableB_ =
                static_cast<proSdrViirsCalInstrumentResponseLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_COEFF_B_LUT(nc_output, TableB_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_COEFF_B_LUT
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
 
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_GAIN_LUT,
            sizeof (proSdrViirsCalGainTableLUT));
 
    if (lut_item != 0) {
        GainTable_ =
                static_cast<proSdrViirsCalGainTableLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_GAIN_LUT(nc_output, GainTable_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_GAIN_LUT
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_DELTA_C_LUT,
            sizeof (proSdrViirsCalDeltaCTempLUT));
 
    if (lut_item != 0) {
        DeltaCTable_ =
                static_cast<proSdrViirsCalDeltaCTempLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_DELTA_C_LUT(nc_output, DeltaCTable_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_DELTA_C_LUT
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_DNB_FRAME_TO_ZONE,
            sizeof (proSdrViirsCalDnbFrameToZoneLUT));
 
    if (lut_item != 0) {
        ftz_ =
                static_cast<proSdrViirsCalDnbFrameToZoneLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_DNB_FRAME_TO_ZONE_LUT(nc_output, ftz_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing "
                + VIIRS_SDR_DNB_FRAME_TO_ZONE + " to netCDF4 LUT file "
                << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_DNB_RVS, sizeof (proSdrViirsCaldnbRVSLUT));
 
    if (lut_item != 0) {
        RVS_DNB_ =
                static_cast<proSdrViirsCaldnbRVSLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_DNB_RVS_LUT(nc_output, RVS_DNB_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_DNB_RVS
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_RVS_LUT, sizeof (proSdrViirsCalRVSLUT));
 
    if (lut_item != 0) {
        rvsLUT_ = static_cast<proSdrViirsCalRVSLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_RVS_LUT(nc_output, rvsLUT_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_RVS_LUT
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_REFLECTIVE_LUT,
            sizeof (proSdrViirsCalReflectiveLUT));
 
    if (lut_item != 0) {
        refLUT_ =
                static_cast<proSdrViirsCalReflectiveLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_REFLECTIVE_LUT(nc_output, refLUT_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing "
                + VIIRS_SDR_REFLECTIVE_LUT + " to netCDF4 LUT file "
                << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_EMISSIVE_LUT,
            sizeof (proSdrViirsCalEmissiveLUT));
 
    if (lut_item != 0) {
        EmissiveLUT_ =
                static_cast<proSdrViirsCalEmissiveLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_EMISSIVE_LUT(nc_output, EmissiveLUT_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_EMISSIVE_LUT
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_RADIOMETRIC_PARAMETERS,
            sizeof (proSdrViirsCalRMParametersLUT));
 
    if (lut_item != 0) {
        rmParameters_ =
                static_cast<proSdrViirsCalRMParametersLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_RADIOMETRIC_PARAMETERS_LUT(nc_output, rmParameters_,
            fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing "
                + VIIRS_SDR_RADIOMETRIC_PARAMETERS
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_OBS_TO_PIXELS,
            sizeof (proSdrViirsCalObsToPixelsLUT));
 
    if (lut_item != 0) {
        obs_to_pixels_ =
                static_cast<proSdrViirsCalObsToPixelsLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_OBS_TO_PIXELS_LUT(nc_output, obs_to_pixels_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_OBS_TO_PIXELS
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_HAM_ER_TABLE,
            sizeof (proSdrViirsCalHAMERLUT));
 
    if (lut_item != 0) {
        HAMERLUT_ =
                static_cast<proSdrViirsCalHAMERLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_HAM_ER_TABLE_LUT(nc_output, HAMERLUT_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_HAM_ER_TABLE
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_RTA_ER_TABLE,
            sizeof (proSdrViirsCalRTAERLUT));
 
    if (lut_item != 0) {
        RTAERLUT_ =
                static_cast<proSdrViirsCalRTAERLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_RTA_ER_TABLE_LUT(nc_output, RTAERLUT_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_RTA_ER_TABLE
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_OBC_ER_TABLE,
            sizeof (proSdrViirsCalOBCERLUT));
 
    if (lut_item != 0) {
        OBCERLUT_ =
                static_cast<proSdrViirsCalOBCERLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_OBC_ER_TABLE_LUT(nc_output, OBCERLUT_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_OBC_ER_TABLE
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_OBC_RR_TABLE,
            sizeof (proSdrViirsCalOBCRRLUT));
 
    if (lut_item != 0) {
        OBCRRLUT_ =
                static_cast<proSdrViirsCalOBCRRLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_OBC_RR_TABLE_LUT(nc_output, OBCRRLUT_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_OBC_RR_TABLE
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_EBBT_TABLE,
            sizeof (proSdrViirsCalLtoEBBTLUT));
 
    if (lut_item != 0) {
        EBBTLUT_ =
                static_cast<proSdrViirsCalLtoEBBTLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_EBBT_TABLE_LUT(nc_output, EBBTLUT_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_EBBT_TABLE
                + " to netCDF4 LUT file " << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut(VIIRS_SDR_SOLAR_IRAD_LUT,
            sizeof (proSdrViirsCalSolarIradLUT));
 
    if (lut_item != 0) {
        solarIradLUT_ =
                static_cast<proSdrViirsCalSolarIradLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_SOLAR_IRAD_LUT(nc_output, solarIradLUT_, fileName);
 
    delete lut_item;
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing "
                + VIIRS_SDR_SOLAR_IRAD_LUT + " to netCDF4 LUT file "
                << endl;
 
        delete nc_output;
        return VCST_FAIL;
    }
 
    lut_item = read_cal_lut( VIIRS_SDR_RELATIVE_SPECTRAL_RESPONSE_LUT, sizeof(ProSdrViirsCalRelativeSpectralResponseLUT) );
 
    if (lut_item != 0) {
        rsrLUT_ = static_cast<ProSdrViirsCalRelativeSpectralResponseLUT*> (lut_item->getDataPtr());
        fileName = lut_item->getFileName();
    } else {
        delete nc_output;
        return VCST_FAIL;
    }
 
    status = write_SDR_RELATIVE_SPECTRAL_RESPONSE_LUT( nc_output, rsrLUT_, fileName );
 
    delete lut_item;
 
    if ( status != VCST_SUCCESS )
    {
    cerr << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_RELATIVE_SPECTRAL_RESPONSE_LUT + " to netCDF4 LUT file " << endl;
 
    delete nc_output;
    return VCST_FAIL;
    }
 
    delete nc_output;
 
    return VCST_SUCCESS;
}
 
/**************************************************************************
 * NAME: create_rsb_dynamic_lut()
 *
 * DESCRIPTION: Create time-dependent Reflective Solar Band netCDF4 LUT used for
 * reprocessing.
 *
 *************************************************************************/
 
int VcstLutNetCDF4::create_rsb_dynamic_lut() {
    int status = VCST_SUCCESS;
 
    string dirPath = VL1_get_group(VIIRS_SDR_F_PREDICTED_LUT);
 
    status = collect_lut_files("SDR-F-PREDICTED-LUT", dirPath);
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure collecting LUT files for "
                + VIIRS_SDR_F_PREDICTED_LUT + "." << endl;
        return VCST_FAIL;
    }
 
    string path = VL1_get_group(VIIRS_NETCDF_LUT_PATH);
    string filepath = path;
 
    string startDate = lut_files_.begin()->first;
    string endDate = lut_files_.rbegin()->first;
 
    if (lut_files_.size() > 1) {
        filepath += "/VIIRS_" + platform_str_ + "_CAL_RSB_DYNAMIC_LUT_" +
                startDate + "_" + endDate + "_version_source.nc";
    } else {
        filepath += "/VIIRS_" + platform_str_ + "_CAL_RSB_LUT_" + startDate +
                + "_version_source.nc";
    }
 
    NcFile* nc_output;
 
    try {
        nc_output = new NcFile(filepath, NcFile::replace);
    } catch (NcException& e) {
        e.what();
        cerr
                << "VcstLutNetCDF4:: Failure creating RSB_DYNAMIC netCDF4 LUT file: "
                + filepath + "." << endl;
 
        return VCST_FAIL;
    }
 
    nc_output->putAtt("title",
            "VIIRS Reflective Solar Bands Time-Dependent LUTs");
 
    write_global_attributes(nc_output);
 
    // Add RSB LUT dimensions
    td_luts_dim_rsbf_ = nc_output->addDim("Time_Dependent_RSB_F_LUTs");
    td_luts_dim_rsbrsr_ = nc_output->addDim("Time_Dependent_RSB_RSR_LUTs");
    scalar_dim_ = nc_output->addDim("Scalar", 1);
    num_viirs_bands_dim_ = nc_output->addDim("Number_of_VIIRS_Bands",
            NUM_VIIRS_BAND);
    max_num_detectors_dim_ = nc_output->addDim("Max_Number_of_Detectors",
            MAX_NUM_DETECTOR);
    max_num_gains_dim_ = nc_output->addDim("Max_Number_of_Gain_States",
            MAX_NUM_GAIN);
    num_mirror_sides_dim_ = nc_output->addDim("Number_of_Mirror_Sides",
            NUM_MIRROR_SIDES);
    num_refl_dnb_bands_dim_ = nc_output->addDim(
            "Number_Reflective_Plus_DNB_Bands", NUM_REFL_PLUS_DNB_BANDS);
    max_rsr_dim_ = nc_output->addDim( "Max_RSR_Values", MAX_RSR_VALUES );
 
    VcstCalLutInputItem* lut_item;
    std::string fileName = "";
 
    // VIIRS_SDR_F_PREDICTED_LUT
 
    if (lut_files_.size() > 1) {
        status = write_all_SDR_F_PREDICTED_LUT(nc_output);
    } else {
        lut_item = read_cal_lut(VIIRS_SDR_F_PREDICTED_LUT,
                sizeof (proSdrViirsCalFPredictedTableLUT));
 
        if (lut_item != 0) {
            TableFPredicted_ =
                    static_cast<proSdrViirsCalFPredictedTableLUT*> (lut_item->getDataPtr());
            fileName = lut_item->getFileName();
 
            status = write_SDR_F_PREDICTED_LUT(nc_output, TableFPredicted_,
                    fileName);
        } else {
            status = VCST_FAIL;
        }
 
        delete lut_item;
    }
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing "
                + VIIRS_SDR_F_PREDICTED_LUT + " to netCDF4 LUT file "
                << endl;
    }
 
    // VIIRS_SDR_SOLAR_SPECTRAL_IRAD_LUT
 
    dirPath = VL1_get_group(VIIRS_SDR_RELATIVE_SPECTRAL_RESPONSE_LUT);
 
    status = collect_lut_files("SDR-RELATIVE-SPECTRAL-RESPONSE-LUT", dirPath);
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure collecting LUT files for "
                + VIIRS_SDR_RELATIVE_SPECTRAL_RESPONSE_LUT + "."
                << endl;
        delete nc_output;
        return VCST_FAIL;
    }
 
    if (lut_files_.size() > 1) {
        status = write_all_SDR_SOLAR_SPECTRAL_IRAD_LUT(nc_output);
    } else {
        lut_item = read_cal_lut(VIIRS_SDR_RELATIVE_SPECTRAL_RESPONSE_LUT,
                sizeof (ProSdrViirsCalRelativeSpectralResponseLUT));
 
        if (lut_item != 0) {
            rsrLUT_ =
                    static_cast<ProSdrViirsCalRelativeSpectralResponseLUT*> (lut_item->getDataPtr());
            fileName = lut_item->getFileName();
 
            status = write_SDR_SOLAR_SPECTRAL_IRAD_LUT(nc_output, rsrLUT_,
                    fileName);
 
            delete lut_item;
        } else {
            status = VCST_FAIL;
        }
    }
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing "
                + VIIRS_SDR_SOLAR_SPECTRAL_IRAD_LUT
                + " to netCDF4 LUT file " << endl;
        delete nc_output;
        return VCST_FAIL;
    }
 
    delete nc_output;
 
    return VCST_SUCCESS;
}
 
/**************************************************************************
 * NAME: create_dnb_dynamic_lut()
 *
 * DESCRIPTION: Create time-dependent Day-Night Band netCDF4 LUT used for
 * reprocessing.
 *
 *************************************************************************/
 
int VcstLutNetCDF4::create_dnb_dynamic_lut() {
    int status = VCST_SUCCESS;
 
    string dirPath = VL1_get_group(VIIRS_SDR_DNB_LGS_GAINS_LUT);
 
    status = collect_lut_files("SDR-DNB-LGS-GAINS-LUT", dirPath);
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure collecting LUT files for "
                + VIIRS_SDR_DNB_LGS_GAINS_LUT + "." << endl;
        return VCST_FAIL;
    }
 
    string path = VL1_get_group(VIIRS_NETCDF_LUT_PATH);
    std::string filepath = path;
 
    std::string startDate = lut_files_.begin()->first;
    std::string endDate = lut_files_.rbegin()->first;
 
    if (lut_files_.size() > 1) {
        filepath += "/VIIRS_" + platform_str_ + "_CAL_DNB_DYNAMIC_LUT_" +
                startDate + "_" + endDate + "_version_source.nc";
    } else {
        filepath += "/VIIRS_" + platform_str_ + "_CAL_DNB_LUT_" + startDate +
                "_version_source.nc";
    }
 
    NcFile* nc_output;
 
    try {
        nc_output = new NcFile(filepath, NcFile::replace);
    } catch (NcException& e) {
        e.what();
        cerr << "VcstLutNetCDF4:: Failure creating DNB_DYNAMIC netCDF4 LUT file: "
                + filepath + "." << endl;
        return VCST_FAIL;
    }
 
    nc_output->putAtt("title", "VIIRS Day-Night Band Time-Dependent LUTs");
 
    write_global_attributes(nc_output);
 
    // Add DNB LUT dimensions
    scalar_dim_ = nc_output->addDim("Scalar", 1);
    td_luts_dim_dnbdn0_ = nc_output->addDim("Time_Dependent_DNB_DN0_LUTs");
    td_luts_dim_dnbgr_ = nc_output->addDim("Time_Dependent_DNB_GR_LUTs");
    td_luts_dim_dnblgs_ = nc_output->addDim("Time_Dependent_DNB_LGS_LUTs");
    num_dnb_agg_seq_dim_ = nc_output->addDim("Number_of_DNB_Agg_Sequences",
            NUM_AGG_SEQ);
    num_dnb_detectors_dim_ = nc_output->addDim("Number_of_DNB_Detectors",
            NUM_DETECTORS_DNB);
    num_dnb_gain_ratios_dim_ = nc_output->addDim("Number_of_DNB_Gain_Ratios",
            NUM_GAIN_RATIOS);
    num_dnb_gain_ratio_coeff_dim_ = nc_output->addDim(
            "Number_of_DNB_Gain_Ratio_Coeffs", NUM_DNB_GAIN_RATIO_COEFFS);
    num_dnb_ev_frames_dim_ = nc_output->addDim("Number_of_DNB_EV_Frames",
            EV_DNB_FRAMES);
    num_dnb_gains_dim_ = nc_output->addDim("Number_of_DNB_Gain_States",
            MAX_NUM_GAIN);
    num_mirror_sides_dim_ = nc_output->addDim("Number_of_Mirror_Sides",
            NUM_MIRROR_SIDES);
 
    VcstCalLutInputItem* lut_item;
    std::string fileName = "";
 
    // VIIRS_SDR_DNB_LGS_GAINS_LUT
 
    if (lut_files_.size() > 1) {
        status = write_all_SDR_DNB_LGS_GAINS_LUT(nc_output);
    } else {
        lut_item = read_cal_lut(VIIRS_SDR_DNB_LGS_GAINS_LUT,
                sizeof (ProSdrViirsCalDnbLgsGainsLUT));
 
        if (lut_item != 0) {
            TableDnbLgsGains_ =
                    static_cast<ProSdrViirsCalDnbLgsGainsLUT*> (lut_item->getDataPtr());
            fileName = lut_item->getFileName();
 
            status = write_SDR_DNB_LGS_GAINS_LUT(nc_output, TableDnbLgsGains_,
                    fileName);
 
            delete lut_item;
        } else {
            status = VCST_FAIL;
        }
    }
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing "
                + VIIRS_SDR_DNB_LGS_GAINS_LUT + " to netCDF4 LUT file "
                << endl;
        delete nc_output;
        return VCST_FAIL;
    }
 
    // VIIRS_SDR_DNB_GAIN_RATIOS_LUT
 
    dirPath = VL1_get_group(VIIRS_SDR_DNB_GAIN_RATIOS_LUT);
 
    status = collect_lut_files("SDR-DNB-GAIN-RATIOS-LUT", dirPath);
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure collecting LUT files for "
                + VIIRS_SDR_DNB_GAIN_RATIOS_LUT + "." << endl;
        delete nc_output;
        return VCST_FAIL;
    }
 
    if (lut_files_.size() > 1) {
        status = write_all_SDR_DNB_GAIN_RATIOS_LUT(nc_output);
    } else {
        lut_item = read_cal_lut(VIIRS_SDR_DNB_GAIN_RATIOS_LUT,
                sizeof (ProSdrViirsCalDnbGainRatiosLUT));
 
        if (lut_item != 0) {
            TableDnbGainRatios_ =
                    static_cast<ProSdrViirsCalDnbGainRatiosLUT*> (lut_item->getDataPtr());
            fileName = lut_item->getFileName();
 
            status = write_SDR_DNB_GAIN_RATIOS_LUT(nc_output,
                    TableDnbGainRatios_, fileName);
 
            delete lut_item;
        } else {
            status = VCST_FAIL;
        }
    }
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing "
                + VIIRS_SDR_DNB_GAIN_RATIOS_LUT
                + " to netCDF4 LUT file " << endl;
        delete nc_output;
        return VCST_FAIL;
    }
 
    // VIIRS_SDR_DNB_DN0_LUT
 
    dirPath = VL1_get_group(VIIRS_SDR_DNB_DN0_LUT);
 
    status = collect_lut_files("SDR-DNB-DN0-LUT", dirPath);
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure collecting LUT files for "
                + VIIRS_SDR_DNB_DN0_LUT + "." << endl;
        delete nc_output;
        return VCST_FAIL;
    }
 
    if (lut_files_.size() > 1) {
        status = write_all_SDR_DNB_DN0_LUT(nc_output);
    } else {
        lut_item = read_cal_lut(VIIRS_SDR_DNB_DN0_LUT,
                sizeof (proSdrViirsDnbDn0Type));
 
        if (lut_item != 0) {
            dnbDn0_ =
                    static_cast<proSdrViirsDnbDn0Type*> (lut_item->getDataPtr());
            fileName = lut_item->getFileName();
 
            status = write_SDR_DNB_DN0_LUT(nc_output, dnbDn0_, fileName);
 
            delete lut_item;
        } else {
            status = VCST_FAIL;
        }
    }
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing " + VIIRS_SDR_DNB_DN0_LUT
                + " to netCDF4 LUT file " << endl;
        delete nc_output;
        return VCST_FAIL;
    }
 
    delete nc_output;
 
    return VCST_SUCCESS;
}
 
/**************************************************************************
 * NAME: create_straylight_dynamic_lut()
 *
 * DESCRIPTION: Create DNB stray light time-dependent netCDF4 LUT used for
 * reprocessing.
 *
 *************************************************************************/
 
int VcstLutNetCDF4::create_straylight_dynamic_lut() {
    int status = VCST_SUCCESS;
 
    string dirPath = VL1_get_group(VIIRS_DNB_STRAY_LIGHT_CORRECTION_LUT);
 
    status = collect_lut_files("VIIRS-SDR-DNB-STRAY-LIGHT-CORRECTION-LUT",
            dirPath);
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure collecting LUT files for "
                + VIIRS_DNB_STRAY_LIGHT_CORRECTION_LUT + "." << endl;
        return VCST_FAIL;
    }
 
    string path = VL1_get_group(VIIRS_NETCDF_LUT_PATH);
    std::string filepath = path;
 
    std::string startDate = lut_files_.begin()->first;
    std::string endDate = lut_files_.rbegin()->first;
 
    if (lut_files_.size() > 1) {
        filepath += "/VIIRS_" + platform_str_ + "_CAL_STRAYLIGHT_DYNAMIC_LUT_" +
                startDate + "_" + endDate + "_version_source.nc";
    } else {
        filepath += "/VIIRS_" + platform_str_ + "_CAL_STRAYLIGHT_LUT_" +
                startDate + "_version_source.nc";
    }
 
    NcFile* nc_output;
 
    try {
        nc_output = new NcFile(filepath, NcFile::replace);
    } catch (NcException& e) {
        e.what();
        cerr << "VcstLutNetCDF4:: Failure creating STRAYLIGHT netCDF4 LUT file: "
                + filepath + "." << endl;
        return VCST_FAIL;
    }
 
    nc_output->putAtt("title",
            "VIIRS Day-Night Band Stray Light Time-Dependent LUTs");
 
    write_global_attributes(nc_output);
 
    // Add Straylight LUT dimensions
    scalar_dim_ = nc_output->addDim("Scalar", 1);
    num_hemispheres_dim_ = nc_output->addDim("Number_of_Hemispheres",
            NUM_HEMISPHERES);
    num_sza_bins_dim_ = nc_output->addDim("Number_of_SZA_Bins", NUM_SZA_BINS);
    num_dnb_ev_frames_dim_ = nc_output->addDim(
            "Number_of_Decimated_DNB_EV_Frames", SHORT_DNB_FRAMES);
    num_dnb_detectors_dim_ = nc_output->addDim("Number_of_DNB_Detectors",
            NUM_DETECTORS_DNB);
    num_mirror_sides_dim_ = nc_output->addDim("Number_of_Mirror_Sides",
            NUM_MIRROR_SIDES);
 
    if (lut_files_.size() > 1) {
        td_luts_dim_slc_ = nc_output->addDim("Time_Dependent_SLC_LUTs");
 
        status = write_all_SDR_DNB_STRAY_LIGHT_CORRECTION_LUT(nc_output);
    } else {
        VcstCalLutInputItem* lut_item;
        std::string fileName = "";
 
        lut_item = read_cal_lut(VIIRS_DNB_STRAY_LIGHT_CORRECTION_LUT,
                sizeof (proSdrViirsCalDnbStrayLightLUT));
 
        if (lut_item != 0) {
            strayLight_ =
                    static_cast<proSdrViirsCalDnbStrayLightLUT*> (lut_item->getDataPtr());
            fileName = lut_item->getFileName();
        } else {
            status = VCST_FAIL;
        }
 
        status = write_SDR_DNB_STRAY_LIGHT_CORRECTION_LUT(nc_output,
                strayLight_, fileName);
 
        delete lut_item;
    }
 
    if (status != VCST_SUCCESS) {
        cerr
                << "VcstLutNetCDF4:: Failure writing "
                + VIIRS_DNB_STRAY_LIGHT_CORRECTION_LUT
                + " to netCDF4 LUT file " << endl;
    }
 
    delete nc_output;
 
    return VCST_SUCCESS;
}
 
/**************************************************************************
 * NAME: write_global_attributes()
 *
 * DESCRIPTION: Write global attributes to specified netCDF file ID
 *
 **************************************************************************/
 
int VcstLutNetCDF4::write_global_attributes(NcFile* nc_output) {
    nc_output->putAtt("processing_version", processing_version_);
    nc_output->putAtt("Conventions", Conventions_);
    nc_output->putAtt("institution", institution_);
    nc_output->putAtt("license", license_);
    nc_output->putAtt("naming_authority", naming_authority_);
    nc_output->putAtt("date_created", date_created_);
    nc_output->putAtt("keywords_vocabulary", keywords_vocabulary_);
    nc_output->putAtt("stdname_vocabulary", stdname_vocabulary_);
    nc_output->putAtt("creator_name", creator_name_);
    nc_output->putAtt("creator_email", creator_email_);
    nc_output->putAtt("creator_url", creator_url_);
    nc_output->putAtt("project", project_);
    nc_output->putAtt("publisher_name", publisher_name_);
    nc_output->putAtt("publisher_url", publisher_url_);
    nc_output->putAtt("publisher_email", publisher_email_);
    nc_output->putAtt("processing_level", processing_level_);
    nc_output->putAtt("cdm_data_type", cdm_data_type_);
    nc_output->putAtt("orbit_number", ncInt, orbit_number_);
    nc_output->putAtt("history", history_);
    nc_output->putAtt("time_coverage_start", time_coverage_start_);
    nc_output->putAtt("time_coverage_end", time_coverage_end_);
 
    return VCST_SUCCESS;
}
 
/**************************************************************************
 * NAME: read_cmngeo_lut()
 *
 * DESCRIPTION: Read a single LUT and create data input item on map.
 * Return a pointer to the LUT item created.
 *
 *************************************************************************/
 
VcstCmnLutInputItem* VcstLutNetCDF4::read_cmngeo_lut(std::string groupName,
        int size) {
    int status;
 
    VcstCmnLutInputItem* lutItem = new VcstCmnLutInputItem(groupName, size);
 
    status = lutItem->getData();
 
    if (status != VCST_SUCCESS) {
        std::cerr
                << "VcstLutNetCDF4::read_cmngeo_lut() Error reading LUT data for group name "
                << groupName << std::endl;
 
        delete lutItem;
 
        return 0L;
    }
 
    return lutItem;
}
 
/**************************************************************************
 * NAME: read_cal_lut()
 *
 * DESCRIPTION: Read a single LUT and create data input item on map.
 * Return a pointer to the LUT item created.
 *
 *************************************************************************/
 
VcstCalLutInputItem* VcstLutNetCDF4::read_cal_lut(std::string groupName,
        int size) {
 
    VcstCalLutInputItem* lutItem = new VcstCalLutInputItem(groupName, size);
 
    int status = lutItem->getData();
 
    if (status != VCST_SUCCESS) {
        std::cerr
                << "VcstLutNetCDF4::read_cal_lut() Error reading LUT data for group name "
                << groupName << std::endl;
 
        delete lutItem;
 
        return 0L;
    }
 
    return lutItem;
}
 
/**************************************************************************
 * NAME: read_geo_lut()
 *
 * DESCRIPTION: Read a single LUT and create data input item on map.
 * Return a pointer to the LUT item created.
 *
 *************************************************************************/
 
VcstGeoLutInputItem* VcstLutNetCDF4::read_geo_lut(std::string groupName,
        int size) {
    int status;
 
    VcstGeoLutInputItem* lutItem = new VcstGeoLutInputItem(groupName, size);
 
    status = lutItem->getData();
 
    if (status != VCST_SUCCESS) {
        std::cerr
                << "VcstLutNetCDF4::read_geo_lut() Error reading LUT data for group name "
                << groupName << std::endl;
 
        delete lutItem;
 
        return 0L;
    }
 
    return lutItem;
}
 
/**************************************************************************
 * NAME: isPlatformLittleEndian()
 *
 * DESCRIPTION: Determine if target platform is little endian. Return true if
 * platform is little endian.
 *
 *************************************************************************/
 
bool VcstLutNetCDF4::isPlatformLittleEndian() {
    unsigned short checkValue = 0xAABB;
    unsigned char* bytePtr = reinterpret_cast<unsigned char*> (&checkValue);
 
    if (bytePtr[0] == 0xAA) // big-endian
    {
        return false;
    } else // little-endian
    {
        return true;
    }
}
 
/******************************************************************************
 * NAME: write_***************_LUT()
 *
 * DESCRIPTION: Write LUT to netCDF4 file.
 *
 ******************************************************************************/
 
int VcstLutNetCDF4::write_CMNGEO_PLATFORM_LUT(NcFile* nc_output) {
 
    int tel_start_enc_nominal = TEL_START_ENC_NOMINAL_NPP;
    int ham_start_enc_nominal[2] = {HAM_START_ENC_NOMINAL_0_NPP,
        HAM_START_ENC_NOMINAL_1_NPP};
    int scan_encdr_start_max = SCAN_ENCDR_START_MAX_NPP;
 
    if (platform_ == NPP) {
    } else if (platform_ == J1) {
        tel_start_enc_nominal = TEL_START_ENC_NOMINAL_J1;
        ham_start_enc_nominal[0] = HAM_START_ENC_NOMINAL_0_J1;
        ham_start_enc_nominal[1] = HAM_START_ENC_NOMINAL_1_J1;
        scan_encdr_start_max = SCAN_ENCDR_START_MAX_J1;
    } else if (platform_ == J2) {
        tel_start_enc_nominal = TEL_START_ENC_NOMINAL_J2;
        ham_start_enc_nominal[0] = HAM_START_ENC_NOMINAL_0_J2,
        ham_start_enc_nominal[1] = HAM_START_ENC_NOMINAL_1_J2;
        scan_encdr_start_max = SCAN_ENCDR_START_MAX_J2;
    }
 
    NcGroup lut_grp = nc_output->addGroup(CMNGEO_PLATFORM_LUT);
 
    NcVar var = lut_grp.addVar("tel_start_enc_nominal", ncInt, scalar_dim_);
    var.putVar(&tel_start_enc_nominal);
 
    var = lut_grp.addVar("ham_start_enc_nominal", ncInt, two_values_dim_);
    var.putVar(ham_start_enc_nominal);
 
    var = lut_grp.addVar("scan_encdr_start_max", ncInt, scalar_dim_);
    var.putVar(&scan_encdr_start_max);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_CMNGEO_JPL_EPHEM(NcFile* nc_output,
        JPLEphemLutType* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(CMNGEO_JPL_EPHEM);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > jpl_ipt_dims;
    jpl_ipt_dims.push_back(num_jpl_ipt_rows_dim_);
    jpl_ipt_dims.push_back(num_jpl_ipt_cols_dim_);
 
    vector < NcDim > jpl_ephem_dims;
    jpl_ephem_dims.push_back(num_jpl_ephem_rows_dim_);
    jpl_ephem_dims.push_back(num_jpl_ephem_cols_dim_);
 
    var = lut_grp.addVar("tjdStart", ncDouble, scalar_dim_);
    var.putAtt("long_name", "");
    var.putAtt("units", "none");
    var.putVar(&lut->tjdStart);
 
    var = lut_grp.addVar("tjdEnd", ncDouble, scalar_dim_);
    var.putAtt("long_name", "");
    var.putAtt("units", "none");
    var.putVar(&lut->tjdEnd);
 
    var = lut_grp.addVar("span", ncDouble, scalar_dim_);
    var.putAtt("long_name", "");
    var.putAtt("units", "none");
    var.putVar(&lut->span);
 
    var = lut_grp.addVar("au", ncDouble, scalar_dim_);
    var.putAtt("long_name", "");
    var.putAtt("units", "none");
    var.putVar(&lut->au);
 
    var = lut_grp.addVar("emrat", ncDouble, scalar_dim_);
    var.putAtt("long_name", "");
    var.putAtt("units", "none");
    var.putVar(&lut->emrat);
 
    var = lut_grp.addVar("ipt", ncInt, jpl_ipt_dims);
    var.putAtt("long_name", "");
    var.putAtt("units", "none");
    var.putVar(lut->ipt);
 
    var = lut_grp.addVar("coeffs", ncDouble, jpl_ephem_dims);
    var.putAtt("long_name", "");
    var.putAtt("units", "none");
    var.putVar(lut->coeffs);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_CMNGEO_SAA_COEFF(NcFile* nc_output, SAALutType* lut,
        std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(CMNGEO_SAA_COEFF);
    lut_grp.putAtt("file_name", fileName);
 
    var = lut_grp.addVar("centerLat", ncDouble, scalar_dim_);
    var.putVar(&lut->centerLat);
 
    var = lut_grp.addVar("centerLon", ncDouble, scalar_dim_);
    var.putVar(&lut->centerLon);
 
    var = lut_grp.addVar("maxIndex", ncDouble, scalar_dim_);
    var.putVar(&lut->maxIndex);
 
    var = lut_grp.addVar("latHeight", ncDouble, scalar_dim_);
    var.putVar(&lut->latHeight);
 
    var = lut_grp.addVar("lonWidth", ncDouble, scalar_dim_);
    var.putVar(&lut->lonWidth);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_CMNGEO_PARAM_LUT(NcFile* nc_output,
        CmnGeoParamLutType* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(CMNGEO_PARAM_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    var = lut_grp.addVar("OrbitConsistency", ncDouble, scalar_dim_);
    var.putVar(&lut->OrbitConsistency);
 
    var = lut_grp.addVar("AngularMomentumLimit", ncDouble, min_max_dim_);
    var.putVar(lut->AngularMomentumLimit);
 
    var = lut_grp.addVar("AngularMomentumZLimit", ncDouble, min_max_dim_);
    var.putVar(lut->AngularMomentumZLimit);
 
    var = lut_grp.addVar("PositionAbsLimit", ncDouble, min_max_dim_);
    var.putVar(lut->PositionAbsLimit);
 
    var = lut_grp.addVar("PositionMagLimit", ncDouble, min_max_dim_);
    var.putVar(lut->PositionMagLimit);
 
    var = lut_grp.addVar("VelocityAbsLimit", ncDouble, min_max_dim_);
    var.putVar(lut->VelocityAbsLimit);
 
    var = lut_grp.addVar("VelocityMagLimit", ncDouble, min_max_dim_);
    var.putVar(lut->VelocityMagLimit);
 
    var = lut_grp.addVar("AttitudeAbsLimit", ncDouble, min_max_dim_);
    var.putVar(lut->AttitudeAbsLimit);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SOLAR_DIFF_VOLT_LUT(NcFile* nc_output,
        SolarDiffVoltLutType* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SOLAR_DIFF_VOLT_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > sdsm_volt_dims;
    sdsm_volt_dims.push_back(num_sdsm_samples_dim_);
    sdsm_volt_dims.push_back(num_sdsm_det_dim_);
    sdsm_volt_dims.push_back(num_sdsm_coef_dim_);
 
    vector < NcDim > sdsm_limit_dims;
    sdsm_limit_dims.push_back(num_sdsm_samples_dim_);
    sdsm_limit_dims.push_back(num_sdsm_det_dim_);
 
    var = lut_grp.addVar("voltLowerLimit", ncInt, sdsm_limit_dims);
    var.putVar(lut->voltLowerLimit);
 
    var = lut_grp.addVar("voltUpperLimit", ncInt, sdsm_limit_dims);
    var.putVar(lut->voltUpperLimit);
 
    var = lut_grp.addVar("voltCoef", ncFloat, sdsm_volt_dims);
    var.putVar(lut->voltCoef);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SOLAR_DIFF_ROT_MATRIX_LUT(NcFile* nc_output,
        SolarDiffRotationMatrixLutType* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SOLAR_DIFF_ROT_MATRIX_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > matrix_dims;
    matrix_dims.push_back(matrix_rows_dim_);
    matrix_dims.push_back(matrix_cols_dim_);
 
    var = lut_grp.addVar("sdMatrix", ncFloat, matrix_dims);
    var.putVar(lut->sdMatrix);
 
    var = lut_grp.addVar("sdsmMatrix", ncFloat, matrix_dims);
    var.putVar(lut->sdsmMatrix);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_DG_ANOMALY_DN_LIMITS_LUT(NcFile* nc_output,
        proSdrViirsCalDgAnDnLmtLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_DG_ANOMALY_DN_LIMITS_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > dg_anom_dims;
    dg_anom_dims.push_back(num_refl_750m_dg_bands_dim_);
    dg_anom_dims.push_back(num_750m_det_dim_);
    dg_anom_dims.push_back(min_max_dim_);
 
    var = lut_grp.addVar("data", ncFloat, dg_anom_dims);
    var.putVar(lut->data);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_DNB_RVS_LUT(NcFile* nc_output,
        proSdrViirsCaldnbRVSLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_DNB_RVS);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > dnb_rvs_dims;
    dnb_rvs_dims.push_back(num_dnb_ev_frames_dim_);
    dnb_rvs_dims.push_back(num_dnb_detectors_dim_);
    dnb_rvs_dims.push_back(num_mirror_sides_dim_);
 
    var = lut_grp.addVar("dnbrvs", ncFloat, dnb_rvs_dims);
    var.putVar(lut->dnbrvs);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_DNB_FRAME_TO_ZONE_LUT(NcFile* nc_output,
        proSdrViirsCalDnbFrameToZoneLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_DNB_FRAME_TO_ZONE);
    lut_grp.putAtt("file_name", fileName);
 
    var = lut_grp.addVar("FrameToZone", ncInt, num_dnb_ev_frames_dim_);
    var.putVar(lut->FrameToZone);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_GAIN_LUT(NcFile* nc_output,
        proSdrViirsCalGainTableLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_GAIN_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    var = lut_grp.addVar("data", ncDouble, num_viirs_bands_dim_);
    var.putVar(lut->data);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_HAM_ER_TABLE_LUT(NcFile* nc_output,
        proSdrViirsCalHAMERLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_HAM_ER_TABLE);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > hamer_file_dims;
    hamer_file_dims.push_back(num_hamer_files_dim_);
    hamer_file_dims.push_back(two_values_dim_);
 
    var = lut_grp.addVar("HAM_ER_indices", ncInt, hamer_file_dims);
    var.putVar(lut->HAM_ER_indices);
 
    var = lut_grp.addVar("HAM_ER_tp", ncDouble, num_hamer_values_dim_);
    var.putVar(lut->HAM_ER_tp);
 
    var = lut_grp.addVar("HAM_ER_rad", ncDouble, num_hamer_values_dim_);
    var.putVar(lut->HAM_ER_rad);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_RTA_ER_TABLE_LUT(NcFile* nc_output,
        proSdrViirsCalRTAERLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_RTA_ER_TABLE);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > rtaer_file_dims;
    rtaer_file_dims.push_back(num_rtaer_files_dim_);
    rtaer_file_dims.push_back(two_values_dim_);
 
    var = lut_grp.addVar("RTA_ER_indices", ncInt, rtaer_file_dims);
    var.putVar(lut->RTA_ER_indices);
 
    var = lut_grp.addVar("RTA_ER_tp", ncDouble, num_rtaer_values_dim_);
    var.putVar(lut->RTA_ER_tp);
 
    var = lut_grp.addVar("RTA_ER_rad", ncDouble, num_rtaer_values_dim_);
    var.putVar(lut->RTA_ER_rad);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_OBC_ER_TABLE_LUT(NcFile* nc_output,
        proSdrViirsCalOBCERLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_OBC_ER_TABLE);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > obcer_file_dims;
    obcer_file_dims.push_back(num_obcer_files_dim_);
    obcer_file_dims.push_back(two_values_dim_);
 
    var = lut_grp.addVar("OBC_ER_indices", ncInt, obcer_file_dims);
    var.putVar(lut->OBC_ER_indices);
 
    var = lut_grp.addVar("OBC_ER_tp", ncDouble, num_obcer_values_dim_);
    var.putVar(lut->OBC_ER_tp);
 
    var = lut_grp.addVar("OBC_ER_rad", ncDouble, num_obcer_values_dim_);
    var.putVar(lut->OBC_ER_rad);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_OBC_RR_TABLE_LUT(NcFile* nc_output,
        proSdrViirsCalOBCRRLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_OBC_RR_TABLE);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > obcrr_file_dims;
    obcrr_file_dims.push_back(num_obcrr_files_dim_);
    obcrr_file_dims.push_back(two_values_dim_);
 
    var = lut_grp.addVar("OBC_RR_indices", ncInt, obcrr_file_dims);
    var.putVar(lut->OBC_RR_indices);
 
    var = lut_grp.addVar("OBC_RR_tp", ncDouble, num_obcrr_values_dim_);
    var.putVar(lut->OBC_RR_tp);
 
    var = lut_grp.addVar("OBC_RR_rad", ncDouble, num_obcrr_values_dim_);
    var.putVar(lut->OBC_RR_rad);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_EBBT_TABLE_LUT(NcFile* nc_output,
        proSdrViirsCalLtoEBBTLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_EBBT_TABLE);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > ebbt_file_dims;
    ebbt_file_dims.push_back(num_ebbt_files_dim_);
    ebbt_file_dims.push_back(two_values_dim_);
 
    var = lut_grp.addVar("EBBT_indices", ncInt, ebbt_file_dims);
    var.putVar(lut->EBBT_indices);
 
    var = lut_grp.addVar("L_to_EBBT_tp", ncDouble, num_ebbt_values_dim_);
    var.putVar(lut->L_to_EBBT_tp);
 
    var = lut_grp.addVar("L_to_EBBT_rad", ncDouble, num_ebbt_values_dim_);
    var.putVar(lut->L_to_EBBT_rad);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_TELE_COEFFS_LUT(NcFile* nc_output,
        proSdrViirsCalTeleCoeffLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_TELE_COEFFS);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > therm_dims;
    therm_dims.push_back(num_thermistors_dim_);
    therm_dims.push_back(num_temp_coeffs_dim_);
 
    var = lut_grp.addVar("teleCoeffs", ncFloat, therm_dims);
    var.putVar(lut->teleCoeffs);
 
    var = lut_grp.addVar("filterThreshold", ncFloat, num_thermistors_dim_);
    var.putVar(lut->filterThreshold);
 
    var = lut_grp.addVar("defaultValue", ncFloat, num_thermistors_dim_);
    var.putVar(lut->defaultValue);
 
    var = lut_grp.addVar("bbTempOffsetDef", ncFloat, scalar_dim_);
    var.putVar(&lut->bbTempOffsetDef);
 
    var = lut_grp.addVar("bbTempGainDef", ncFloat, scalar_dim_);
    var.putVar(&lut->bbTempGainDef);
 
    var = lut_grp.addVar("bbTempAdditive", ncFloat, scalar_dim_);
    var.putVar(&lut->bbTempAdditive);
 
    var = lut_grp.addVar("bbTempSpare", ncFloat, num_tref_mux_dim_);
    var.putVar(lut->bbTempSpare);
 
    var = lut_grp.addVar("evCtPrecTrefMux1Ca", ncFloat, num_tref_mux_dim_);
    var.putVar(lut->evCtPrecTrefMux1Ca);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_SOLAR_IRAD_LUT(NcFile* nc_output,
        proSdrViirsCalSolarIradLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_SOLAR_IRAD_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    var = lut_grp.addVar("x", ncDouble, num_solar_irad_values_dim_);
    var.putVar(lut->x);
 
    var = lut_grp.addVar("y", ncDouble, num_solar_irad_values_dim_);
    var.putVar(lut->y);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_OBS_TO_PIXELS_LUT(NcFile* nc_output,
        proSdrViirsCalObsToPixelsLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_OBS_TO_PIXELS);
    lut_grp.putAtt("file_name", fileName);
 
    var = lut_grp.addVar("pixels", ncInt, num_dg_ev_frames_dim_);
    var.putVar(lut->pixels);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_RADIOMETRIC_PARAMETERS_LUT(NcFile* nc_output,
        proSdrViirsCalRMParametersLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_RADIOMETRIC_PARAMETERS);
    lut_grp.putAtt("file_name", fileName);
 
    var = lut_grp.addVar("Telec_Therm_Indexes", ncInt, num_telec_therm_dim_);
    var.putVar(lut->Telec_Therm_Indexes);
    var = lut_grp.addVar("Telec_Therm_Weights", ncFloat, num_telec_therm_dim_);
    var.putVar(lut->Telec_Therm_Weights);
 
    var = lut_grp.addVar("Tsh_Indexes", ncInt, num_therm_weights_dim_);
    var.putVar(lut->Tsh_Indexes);
    var = lut_grp.addVar("Tsh_Weights", ncFloat, num_therm_weights_dim_);
    var.putVar(lut->Tsh_Weights);
 
    var = lut_grp.addVar("Ttele_Indexes", ncInt, num_therm_weights_dim_);
    var.putVar(lut->Ttele_Indexes);
    var = lut_grp.addVar("Ttele_Weights", ncFloat, num_therm_weights_dim_);
    var.putVar(lut->Ttele_Weights);
 
    var = lut_grp.addVar("Ttele_Offset", ncFloat, scalar_dim_);
    var.putVar(&lut->Ttele_Offset);
 
    var = lut_grp.addVar("Trta_Indexes", ncInt, num_therm_weights_dim_);
    var.putVar(lut->Trta_Indexes);
    var = lut_grp.addVar("Trta_Weights", ncFloat, num_therm_weights_dim_);
    var.putVar(lut->Trta_Weights);
 
    var = lut_grp.addVar("Trta_Offset", ncFloat, scalar_dim_);
    var.putVar(&lut->Trta_Offset);
 
    var = lut_grp.addVar("Tcav_Indexes", ncInt, num_therm_weights_dim_);
    var.putVar(lut->Tcav_Indexes);
    var = lut_grp.addVar("Tcav_Weights", ncFloat, num_therm_weights_dim_);
    var.putVar(lut->Tcav_Weights);
 
    var = lut_grp.addVar("Tmir_Indexes", ncInt, num_therm_weights_dim_);
    var.putVar(lut->Tmir_Indexes);
    var = lut_grp.addVar("Tmir_Weights", ncFloat, num_therm_weights_dim_);
    var.putVar(lut->Tmir_Weights);
 
    var = lut_grp.addVar("Tfpsm_Indexes", ncInt, num_therm_weights_dim_);
    var.putVar(lut->Tfpsm_Indexes);
    var = lut_grp.addVar("Tfpsm_Weights", ncFloat, num_therm_weights_dim_);
    var.putVar(lut->Tfpsm_Weights);
 
    var = lut_grp.addVar("Tfplw_Indexes", ncInt, num_therm_weights_dim_);
    var.putVar(lut->Tfplw_Indexes);
    var = lut_grp.addVar("Tfplw_Weights", ncFloat, num_therm_weights_dim_);
    var.putVar(lut->Tfplw_Weights);
 
    var = lut_grp.addVar("Tomm_Thermister_Indexes", ncInt, num_tomm_therm_dim_);
    var.putVar(lut->Tomm_Thermister_Indexes);
    var = lut_grp.addVar("Tomm_Thermister_Weights", ncFloat,
            num_tomm_therm_dim_);
    var.putVar(lut->Tomm_Thermister_Weights);
 
    var = lut_grp.addVar("Ttel_Tsh_Tcav_Weights", ncFloat, num_ttel_therm_dim_);
    var.putVar(lut->Ttel_Tsh_Tcav_Weights);
 
    var = lut_grp.addVar("Tmax", ncFloat, scalar_dim_);
    var.putVar(&lut->Tmax);
    var = lut_grp.addVar("Tmin", ncFloat, scalar_dim_);
    var.putVar(&lut->Tmin);
    var = lut_grp.addVar("Tomm_for_Tfpsm_Switch", ncInt, scalar_dim_);
    var.putVar(&lut->Tomm_for_Tfpsm_Switch);
    var = lut_grp.addVar("Tomm_for_Tfplw_Switch", ncInt, scalar_dim_);
    var.putVar(&lut->Tomm_for_Tfplw_Switch);
 
    var = lut_grp.addVar("bbNominalTemp_Tolerances", ncFloat,
            num_ttel_therm_dim_);
    var.putVar(lut->bbNominalTemp_Tolerances);
 
    var = lut_grp.addVar("lwirNominalTolerance", ncFloat, scalar_dim_);
    var.putVar(&lut->lwirNominalTolerance);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_QA_LUT(NcFile* nc_output,
        proSdrViirsCalQALUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_QA_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > quality_flag_dims;
    quality_flag_dims.push_back(num_viirs_detectors_dim_);
    quality_flag_dims.push_back(num_qual_flag_values_dim_);
 
    vector < NcDim > moon_dims;
    moon_dims.push_back(num_viirs_bands_dim_);
    moon_dims.push_back(num_moon_offset_dim_);
 
    var = lut_grp.addVar("Detector_Quality_Flag_Values", ncByte,
            quality_flag_dims);
    var.putVar(lut->Detector_Quality_Flag_Values);
 
    var = lut_grp.addVar("moon_offset_limits", ncFloat, moon_dims);
    var.putVar(lut->moon_offset_limits);
 
    var = lut_grp.addVar("saa_threshold", ncFloat, scalar_dim_);
    var.putVar(&lut->saa_threshold);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_EMISSIVE_LUT(NcFile* nc_output,
        proSdrViirsCalEmissiveLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_EMISSIVE_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    var = lut_grp.addVar("SV_DN_first_frame_to_use", ncShort, scalar_dim_);
    var.putVar(&lut->SV_DN_first_frame_to_use);
 
    var = lut_grp.addVar("SV_DN_number_of_frames_to_use", ncShort, scalar_dim_);
    var.putVar(&lut->SV_DN_number_of_frames_to_use);
 
    var = lut_grp.addVar("SV_DN_moon_include_frames", ncShort, scalar_dim_);
    var.putVar(&lut->SV_DN_moon_include_frames);
 
    var = lut_grp.addVar("BB_DN_first_frame_to_use", ncShort, scalar_dim_);
    var.putVar(&lut->BB_DN_first_frame_to_use);
 
    var = lut_grp.addVar("BB_DN_number_of_frames_to_use", ncShort, scalar_dim_);
    var.putVar(&lut->BB_DN_number_of_frames_to_use);
 
    var = lut_grp.addVar("T_mir_function_flag", ncInt, num_tm_therm_dim_);
    var.putVar(lut->T_mir_function_flag);
 
    var = lut_grp.addVar("t_mir_default", ncFloat, scalar_dim_);
    var.putVar(&lut->t_mir_default);
 
    var = lut_grp.addVar("BB_Weight", ncFloat, num_bb_therm_dim_);
    var.putVar(lut->BB_Weight);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_REFLECTIVE_LUT(NcFile* nc_output,
        proSdrViirsCalReflectiveLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_REFLECTIVE_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    var = lut_grp.addVar("DN_obc_avg_first_frame", ncShort, scalar_dim_);
    var.putVar(&lut->DN_obc_avg_first_frame);
 
    var = lut_grp.addVar("DN_obc_avg_num_frames", ncShort, scalar_dim_);
    var.putVar(&lut->DN_obc_avg_num_frames);
 
    var = lut_grp.addVar("RSB_SV_DN_moon_include_frames", ncShort, scalar_dim_);
    var.putVar(&lut->RSB_SV_DN_moon_include_frames);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_RVS_LUT(NcFile* nc_output,
        proSdrViirsCalRVSLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_RVS_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > img_dims;
    img_dims.push_back(num_375m_bands_dim_);
    img_dims.push_back(num_375m_det_dim_);
    img_dims.push_back(num_375m_frms_dim_);
    img_dims.push_back(num_mirror_sides_dim_);
 
    vector < NcDim > mod_sg_dims;
    mod_sg_dims.push_back(num_750m_sg_bands_dim_);
    mod_sg_dims.push_back(num_750m_det_dim_);
    mod_sg_dims.push_back(num_sg_ev_frames_dim_);
    mod_sg_dims.push_back(num_mirror_sides_dim_);
 
    vector < NcDim > mod_dg_dims;
    mod_dg_dims.push_back(num_750m_dg_bands_dim_);
    mod_dg_dims.push_back(num_750m_det_dim_);
    mod_dg_dims.push_back(num_dg_ev_frames_dim_);
    mod_dg_dims.push_back(num_mirror_sides_dim_);
 
    vector < NcDim > img_sv_dims;
    img_sv_dims.push_back(num_375m_bands_dim_);
    img_sv_dims.push_back(num_375m_det_dim_);
    img_sv_dims.push_back(num_mirror_sides_dim_);
 
    vector < NcDim > mod_sg_sv_dims;
    mod_sg_sv_dims.push_back(num_750m_sg_bands_dim_);
    mod_sg_sv_dims.push_back(num_750m_det_dim_);
    mod_sg_sv_dims.push_back(num_mirror_sides_dim_);
 
    vector < NcDim > mod_dg_sv_dims;
    mod_dg_sv_dims.push_back(num_750m_dg_bands_dim_);
    mod_dg_sv_dims.push_back(num_750m_det_dim_);
    mod_dg_sv_dims.push_back(num_mirror_sides_dim_);
 
    var = lut_grp.addVar("RVS_375m", ncFloat, img_dims);
    var.putVar(lut->RVS_375m);
 
    var = lut_grp.addVar("RVS_750m_SG", ncFloat, mod_sg_dims);
    var.putVar(lut->RVS_750m_SG);
 
    var = lut_grp.addVar("RVS_750m_DG", ncFloat, mod_dg_dims);
    var.putVar(lut->RVS_750m_DG);
 
    var = lut_grp.addVar("RVS_375m_SV", ncFloat, img_sv_dims);
    var.putVar(lut->RVS_375m_SV);
 
    var = lut_grp.addVar("RVS_750m_SV_SG", ncFloat, mod_sg_sv_dims);
    var.putVar(lut->RVS_750m_SV_SG);
 
    var = lut_grp.addVar("RVS_750m_SV_DG", ncFloat, mod_dg_sv_dims);
    var.putVar(lut->RVS_750m_SV_DG);
 
    var = lut_grp.addVar("RVS_375m_BB", ncFloat, img_sv_dims);
    var.putVar(lut->RVS_375m_BB);
 
    var = lut_grp.addVar("RVS_750m_BB_SG", ncFloat, mod_sg_sv_dims);
    var.putVar(lut->RVS_750m_BB_SG);
 
    var = lut_grp.addVar("RVS_750m_BB_DG", ncFloat, mod_dg_sv_dims);
    var.putVar(lut->RVS_750m_BB_DG);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_BB_TEMP_COEFFS_LUT(NcFile* nc_output,
        proSdrViirsCalBBTempCoeffs* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_BB_TEMP_COEFFS);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > bb_dims;
    bb_dims.push_back(num_bb_therm_dim_);
    bb_dims.push_back(num_bb_coeff_dim_);
 
    var = lut_grp.addVar("Thermistor", ncDouble, bb_dims);
    var.putVar(lut->thermister);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_DELTA_C_LUT(NcFile* nc_output,
        proSdrViirsCalDeltaCTempLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_DELTA_C_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > array_dims;
    array_dims.push_back(num_electronics_sides_dim_);
    array_dims.push_back(num_viirs_bands_dim_);
    array_dims.push_back(max_num_detectors_dim_);
    array_dims.push_back(num_dg_gain_states_dim_);
    array_dims.push_back(num_mirror_sides_dim_);
    array_dims.push_back(num_c_coeffs_dim_);
    array_dims.push_back(num_thermistor_dim_);
 
    vector < NcDim > tele_dims;
    tele_dims.push_back(num_electronics_sides_dim_);
    tele_dims.push_back(num_tele_levels_dim_);
 
    vector < NcDim > tdet_dims;
    tdet_dims.push_back(num_electronics_sides_dim_);
    tdet_dims.push_back(num_focal_planes_dim_);
    tdet_dims.push_back(num_tdet_levels_dim_);
 
    var = lut_grp.addVar("DeltaC", ncDouble, array_dims);
    var.putVar(lut->DeltaC);
 
    var = lut_grp.addVar("Tele", ncDouble, tele_dims);
    var.putVar(lut->Tele);
 
    var = lut_grp.addVar("Tdet", ncDouble, tdet_dims);
    var.putVar(lut->Tdet);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_COEFF_A_LUT(NcFile* nc_output,
        proSdrViirsCalDetectorResponseLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_COEFF_A_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > array_dims;
    array_dims.push_back(num_electronics_sides_dim_);
    array_dims.push_back(num_viirs_bands_dim_);
    array_dims.push_back(max_num_detectors_dim_);
    array_dims.push_back(num_dg_gain_states_dim_);
    array_dims.push_back(num_mirror_sides_dim_);
    array_dims.push_back(num_tdet_levels_dim_);
    array_dims.push_back(four_values_dim_);
 
    var = lut_grp.addVar("data", ncDouble, array_dims);
    var.putVar(lut->data);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_COEFF_B_LUT(NcFile* nc_output,
        proSdrViirsCalInstrumentResponseLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_COEFF_B_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > array_dims;
    array_dims.push_back(num_electronics_sides_dim_);
    array_dims.push_back(num_viirs_bands_dim_);
    array_dims.push_back(max_num_detectors_dim_);
    array_dims.push_back(num_mirror_sides_dim_);
    array_dims.push_back(num_tele_levels_dim_);
    array_dims.push_back(four_values_dim_);
 
    var = lut_grp.addVar("data", ncDouble, array_dims);
    var.putVar(lut->data);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_RELATIVE_SPECTRAL_RESPONSE_LUT(NcFile* nc_output,
        ProSdrViirsCalRelativeSpectralResponseLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_RELATIVE_SPECTRAL_RESPONSE_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > array_dims;
    array_dims.push_back(num_refl_dnb_bands_dim_);
    array_dims.push_back(max_rsr_dim_);
 
    var = lut_grp.addVar("wavelength", ncDouble, array_dims);
    var.putVar(lut->wavelength);
 
    var = lut_grp.addVar("rsr", ncDouble, array_dims);
    var.putVar(lut->rsr);
 
    var = lut_grp.addVar("numRsr", ncDouble, num_refl_dnb_bands_dim_);
    var.putVar(lut->numRsr);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_SOLAR_SPECTRAL_IRAD_LUT(NcFile* nc_output,
        ProSdrViirsCalRelativeSpectralResponseLUT* rsrLUT,
        std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_SOLAR_SPECTRAL_IRAD_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > array_dims;
    array_dims.push_back(num_refl_dnb_bands_dim_);
 
    compute_solar_irradiance(rsrLUT);
 
    var = lut_grp.addVar("solar_spectral_irad", ncDouble, array_dims);
    var.putVar(solar_irad_);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_GEO_PARAM_LUT(NcFile* nc_output,
        GEO_param_struct* lut, std::string str_geo_params_name,
        std::string fileName) {
    NcGroup lut_grp;
 
    lut_grp = nc_output->addGroup(str_geo_params_name);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > det_pos_dims;
    det_pos_dims.push_back(max_band_num_plus_one_dim_);
    det_pos_dims.push_back(num_mirror_sides_dim_);
 
    vector < NcDim > dnb_agg_dims;
    dnb_agg_dims.push_back(num_dnb_aggzone_dim_);
    dnb_agg_dims.push_back(num_mirror_sides_dim_);
 
    vector < NcDim > dnb_aggzone_dims;
    dnb_aggzone_dims.push_back(dnb_aggzone_bounds_dim_);
    dnb_aggzone_dims.push_back(dnb_aggzone_bound_cols_dim_);
 
    vector < NcDim > matrix_dims;
    matrix_dims.push_back(matrix_rows_dim_);
    matrix_dims.push_back(matrix_cols_dim_);
 
    vector < NcDim > thermistor_id_dims;
    thermistor_id_dims.push_back(max_thermistor_id_dim_);
    thermistor_id_dims.push_back(num_thermistors_dim_);
 
    vector < NcDim > thermistor_coef_dims;
    thermistor_coef_dims.push_back(num_thermistors_dim_);
    thermistor_coef_dims.push_back(num_thermistor_coeffs_dim_);
 
    vector < NcDim > poly_coef_dims;
    poly_coef_dims.push_back(num_electronics_sides_dim_);
    poly_coef_dims.push_back(max_poly_degree_plus_one_dim_);
 
    NcGroup sub_grp;
    NcVar var;
 
    var = lut_grp.addVar("revision", ncUbyte, revision_char_dim_);
    var.putVar(lut->revision);
 
    //  focal_plane_geometry_struct     geometry_params;
 
    sub_grp = lut_grp.addGroup("focal_plane_geometry");
 
    var = sub_grp.addVar("band_number", ncInt, scalar_dim_);
    var.putVar(&lut->geometry_params.band_number);
 
    var = sub_grp.addVar("latch_to_center", ncDouble, scalar_dim_);
    var.putVar(&lut->geometry_params.latch_to_center);
 
    var = sub_grp.addVar("t_reset", ncDouble, scalar_dim_);
    var.putVar(&lut->geometry_params.t_reset);
 
    var = sub_grp.addVar("N_samp", ncUshort, max_band_num_plus_one_dim_);
    var.putVar(lut->geometry_params.N_samp);
 
    var = sub_grp.addVar("focal_length", ncDouble, max_band_num_plus_one_dim_);
    var.putVar(lut->geometry_params.focal_length);
 
    var = sub_grp.addVar("det_space_track", ncDouble,
            max_band_num_plus_one_dim_);
    var.putVar(lut->geometry_params.det_space_track);
 
    var = sub_grp.addVar("det_space_scan", ncDouble,
            max_band_num_plus_one_dim_);
    var.putVar(lut->geometry_params.det_space_scan);
 
    var = sub_grp.addVar("DNB_space_track", ncDouble, num_dnb_aggzone_dim_);
    var.putVar(lut->geometry_params.DNB_space_track);
 
    var = sub_grp.addVar("DNB_space_scan", ncDouble, num_dnb_aggzone_dim_);
    var.putVar(lut->geometry_params.DNB_space_scan);
 
    var = sub_grp.addVar("det_position", ncDouble, det_pos_dims);
    var.putVar(lut->geometry_params.det_position);
 
    var = sub_grp.addVar("band_position", ncDouble, max_band_num_plus_one_dim_);
    var.putVar(lut->geometry_params.band_position);
 
    var = sub_grp.addVar("earth_view_delay", ncDouble, scalar_dim_);
    var.putVar(&lut->geometry_params.earth_view_delay);
 
    var = sub_grp.addVar("detector_sampling_rate", ncDouble, scalar_dim_);
    var.putVar(&lut->geometry_params.detector_sampling_rate);
 
    var = sub_grp.addVar("scan_length", ncDouble, scalar_dim_);
    var.putVar(&lut->geometry_params.scan_length);
 
    var = sub_grp.addVar("agg_zone_bounds", ncInt, num_aggzones_dim_);
    var.putVar(lut->geometry_params.agg_zone_bounds);
 
    var = sub_grp.addVar("DNB_aggregation", ncInt, dnb_agg_dims);
    var.putVar(lut->geometry_params.DNB_aggregation);
 
    var = sub_grp.addVar("DNB_ag_zone_bounds", ncInt, dnb_aggzone_dims);
    var.putVar(lut->geometry_params.DNB_ag_zone_bounds);
 
    var = sub_grp.addVar("scan_ang_coef_tel", ncDouble, scalar_dim_);
    var.putVar(&lut->geometry_params.scan_ang_coef_tel);
 
    var = sub_grp.addVar("scan_ang_coef_mirr", ncDouble, scalar_dim_);
    var.putVar(&lut->geometry_params.scan_ang_coef_mirr);
 
    var = sub_grp.addVar("scan_ang_offsets", ncDouble, num_mirror_sides_dim_);
    var.putVar(lut->geometry_params.scan_ang_offsets);
 
    //  mirror_preparation_struct
 
    sub_grp = lut_grp.addGroup("mirror_preparation");
 
    var = sub_grp.addVar("enc_scale", ncDouble, scalar_dim_);
    var.putVar(&lut->mirror_prep_params.enc_scale);
 
    var = sub_grp.addVar("mirr_abs_limit", ncDouble, max_limit_check_dim_);
    var.putVar(lut->mirror_prep_params.mirr_abs_limit);
 
    var = sub_grp.addVar("mirr_del_limit", ncDouble, scalar_dim_);
    var.putVar(&lut->mirror_prep_params.mirr_del_limit);
 
    var = sub_grp.addVar("tel_abs_limit", ncDouble, max_limit_check_dim_);
    var.putVar(lut->mirror_prep_params.tel_abs_limit);
 
    var = sub_grp.addVar("tel_del_limit", ncDouble, scalar_dim_);
    var.putVar(&lut->mirror_prep_params.tel_del_limit);
 
    var = sub_grp.addVar("sample_impulse_mirr", ncInt, scalar_dim_);
    var.putVar(&lut->mirror_prep_params.sample_impulse_mirr);
 
    var = sub_grp.addVar("sample_impulse_tel", ncInt, scalar_dim_);
    var.putVar(&lut->mirror_prep_params.sample_impulse_tel);
 
    var = sub_grp.addVar("A_bit_adj", ncInt, max_limit_check_dim_);
    var.putVar(lut->mirror_prep_params.A_bit_adj);
 
    var = sub_grp.addVar("B_HAM_adj", ncInt, num_mirror_sides_dim_);
    var.putVar(lut->mirror_prep_params.B_HAM_adj);
 
    var = sub_grp.addVar("t_encoder", ncDouble, scalar_dim_);
    var.putVar(&lut->mirror_prep_params.t_encoder);
 
    // mirror_model_struct
 
    sub_grp = lut_grp.addGroup("mirror_model");
 
    var = sub_grp.addVar("mirr_side1_range", ncDouble, num_mirror_sides_dim_);
    var.putVar(lut->mirror_model.mirr_side1_range);
 
    var = sub_grp.addVar("alpha", ncDouble, scalar_dim_);
    var.putVar(&lut->mirror_model.alpha);
 
    var = sub_grp.addVar("beta", ncDouble, scalar_dim_);
    var.putVar(&lut->mirror_model.beta);
 
    var = sub_grp.addVar("gammaa", ncDouble, scalar_dim_);
    var.putVar(&lut->mirror_model.gammaa);
 
    // internal_coord_trans_struct
 
    sub_grp = lut_grp.addGroup("internal_coord_transforms");
 
    var = sub_grp.addVar("T_inst2sc", ncDouble, matrix_dims);
    var.putVar(lut->coord_trans.T_inst2sc);
 
    var = sub_grp.addVar("T_mirr2inst", ncDouble, matrix_dims);
    var.putVar(lut->coord_trans.T_mirr2inst);
 
    var = sub_grp.addVar("T_aft2inst", ncDouble, matrix_dims);
    var.putVar(lut->coord_trans.T_aft2inst);
 
    var = sub_grp.addVar("T_inst2SD", ncDouble, matrix_dims);
    var.putVar(lut->coord_trans.T_inst2SD);
 
    var = sub_grp.addVar("T_tel2inst", ncDouble, matrix_dims);
    var.putVar(lut->coord_trans.T_tel2inst);
 
    //  thermistor_parameter_struct
 
    sub_grp = lut_grp.addGroup("thermistor_parameters");
 
    var = sub_grp.addVar("num_thermistor", ncInt, scalar_dim_);
    var.putVar(&lut->thermistor_params.num_thermistor);
 
    var = sub_grp.addVar("thermistor_id", ncUbyte, thermistor_id_dims);
    var.putVar(lut->thermistor_params.thermistor_id);
 
    var = sub_grp.addVar("thermistor_coeffs", ncDouble, thermistor_coef_dims);
    var.putVar(lut->thermistor_params.thermistor_coeffs);
 
    // other
 
    var = lut_grp.addVar("Mag", ncDouble, matrix_dims);
    var.putVar(lut->Mag);
 
    var = lut_grp.addVar("basis_in", ncDouble, matrix_dims);
    var.putVar(lut->basis_in);
 
    var = lut_grp.addVar("basis_out", ncDouble, matrix_dims);
    var.putVar(lut->basis_out);
 
    var = lut_grp.addVar("poly_coef_mirr", ncDouble,
            max_poly_degree_plus_one_dim_);
    var.putVar(lut->poly_coef_mirr);
 
    var = lut_grp.addVar("poly_coef_tel", ncDouble, poly_coef_dims);
    var.putVar(lut->poly_coef_tel);
 
    var = lut_grp.addVar("tel_ref", ncDouble, scalar_dim_);
    var.putVar(&lut->tel_ref);
 
    var = lut_grp.addVar("min_cos_view", ncDouble, scalar_dim_);
    var.putVar(&lut->min_cos_view);
 
    var = lut_grp.addVar("band_type", ncInt, scalar_dim_);
    var.putVar(&lut->band_type);
 
    var = lut_grp.addVar("num_detectors", ncInt, scalar_dim_);
    var.putVar(&lut->num_detectors);
 
    var = lut_grp.addVar("poly_degree", ncInt, scalar_dim_);
    var.putVar(&lut->poly_degree);
 
    var = lut_grp.addVar("N_frame", ncUshort, scalar_dim_);
    var.putVar(&lut->N_frame);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_DNB_STRAY_LIGHT_CORRECTION_LUT(NcFile* nc_output,
        proSdrViirsCalDnbStrayLightLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    shortViirsCalDnbStrayLightLUT* lut_short = new shortViirsCalDnbStrayLightLUT;
 
    compress_StrayLight_LUT(lut, lut_short);
 
    lut_grp = nc_output->addGroup(VIIRS_DNB_STRAY_LIGHT_CORRECTION_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > dnb_straylight_offset_dims;
    dnb_straylight_offset_dims.push_back(num_hemispheres_dim_);
    dnb_straylight_offset_dims.push_back(num_sza_bins_dim_);
    dnb_straylight_offset_dims.push_back(num_dnb_ev_frames_dim_);
    dnb_straylight_offset_dims.push_back(num_dnb_detectors_dim_);
    dnb_straylight_offset_dims.push_back(num_mirror_sides_dim_);
 
    vector < NcDim > dnb_straylight_grid_dims;
    dnb_straylight_grid_dims.push_back(num_hemispheres_dim_);
    dnb_straylight_grid_dims.push_back(num_sza_bins_dim_);
 
    var = lut_grp.addVar("MAX_RADIANCE_STRAY", ncFloat, scalar_dim_);
    var.putVar(&lut_short->MAX_RADIANCE_STRAY);
 
    var = lut_grp.addVar("VIIRS_DNB_SDR_STRAY_OFFSET", ncFloat,
            dnb_straylight_offset_dims);
    var.putVar(lut_short->VIIRS_DNB_SDR_STRAY_OFFSET);
 
    var = lut_grp.addVar("VIIRS_STRAY_SZA_GRID", ncFloat,
            dnb_straylight_grid_dims);
    var.putVar(lut_short->VIIRS_STRAY_SZA_GRID);
 
    delete lut_short;
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_F_PREDICTED_LUT(NcFile* nc_output,
        proSdrViirsCalFPredictedTableLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_F_PREDICTED_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > f_factor_dims;
    f_factor_dims.push_back(num_viirs_bands_dim_);
    f_factor_dims.push_back(max_num_detectors_dim_);
    f_factor_dims.push_back(max_num_gains_dim_);
    f_factor_dims.push_back(num_mirror_sides_dim_);
 
    var = lut_grp.addVar("Fit_type", ncByte, num_viirs_bands_dim_);
    var.putVar(lut->Fit_type);
 
    var = lut_grp.addVar("T_ref", ncInt64, scalar_dim_);
    var.putVar(&lut->T_ref);
 
    var = lut_grp.addVar("F_ref", ncDouble, f_factor_dims);
    var.putVar(lut->F_ref);
 
    var = lut_grp.addVar("F_param_1", ncDouble, f_factor_dims);
    var.putVar(lut->F_param_1);
 
    var = lut_grp.addVar("F_param_2", ncDouble, f_factor_dims);
    var.putVar(lut->F_param_2);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_DNB_LGS_GAINS_LUT(NcFile* nc_output,
        ProSdrViirsCalDnbLgsGainsLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_DNB_LGS_GAINS_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > lgs_gains_dims;
    lgs_gains_dims.push_back(num_dnb_agg_seq_dim_);
    lgs_gains_dims.push_back(num_dnb_detectors_dim_);
    lgs_gains_dims.push_back(num_mirror_sides_dim_);
 
    lut->Fit_type = 1;
    var = lut_grp.addVar("Fit_type", ncByte, scalar_dim_);
    var.putVar(&lut->Fit_type);
 
    var = lut_grp.addVar("T_ref", ncInt64, scalar_dim_);
    var.putVar(&lut->T_ref);
 
    var = lut_grp.addVar("F_ref", ncDouble, lgs_gains_dims);
    var.putVar(lut->F_ref);
 
    var = lut_grp.addVar("F_param_1", ncDouble, lgs_gains_dims);
    var.putVar(lut->F_param_1);
 
    var = lut_grp.addVar("F_param_2", ncDouble, lgs_gains_dims);
    var.putVar(lut->F_param_2);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_DNB_GAIN_RATIOS_LUT(NcFile* nc_output,
        ProSdrViirsCalDnbGainRatiosLUT* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_DNB_GAIN_RATIOS_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > dnb_gain_ratio_dims;
    dnb_gain_ratio_dims.push_back(num_dnb_agg_seq_dim_);
    dnb_gain_ratio_dims.push_back(num_dnb_detectors_dim_);
    dnb_gain_ratio_dims.push_back(num_dnb_gain_ratios_dim_);
    dnb_gain_ratio_dims.push_back(num_dnb_gain_ratio_coeff_dim_);
 
    var = lut_grp.addVar("DnbGainRatios", ncDouble, dnb_gain_ratio_dims);
    var.putVar(lut->DnbGainRatios);
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_SDR_DNB_DN0_LUT(NcFile* nc_output,
        proSdrViirsDnbDn0Type* lut, std::string fileName) {
    NcGroup lut_grp;
    NcVar var;
 
    lut_grp = nc_output->addGroup(VIIRS_SDR_DNB_DN0_LUT);
    lut_grp.putAtt("file_name", fileName);
 
    vector < NcDim > dnb_dn0_dims;
    dnb_dn0_dims.push_back(num_dnb_ev_frames_dim_);
    dnb_dn0_dims.push_back(num_dnb_detectors_dim_);
    dnb_dn0_dims.push_back(num_dnb_gains_dim_);
    dnb_dn0_dims.push_back(num_mirror_sides_dim_);
 
    var = lut_grp.addVar("data", ncFloat, dnb_dn0_dims);
    var.putVar(lut->data);
 
    return VCST_SUCCESS;
}
 
/**************************************************************************
 * NAME: compress_StrayLight_LUT()
 *
 * DESCRIPTION: Compress DNB Stray Light LUT by removing linearly-interpolated values.
 *
 *************************************************************************/
 
int VcstLutNetCDF4::compress_StrayLight_LUT(
        proSdrViirsCalDnbStrayLightLUT* long_lut,
        shortViirsCalDnbStrayLightLUT* short_lut) {
    memset(short_lut, 0.0, sizeof (shortViirsCalDnbStrayLightLUT));
 
    short_lut->MAX_RADIANCE_STRAY = long_lut->MAX_RADIANCE_STRAY;
 
    for (int iHem = 0; iHem < NUM_HEMISPHERES; iHem++) {
        for (int iSza = 0; iSza < NUM_SZA_BINS; iSza++) {
            short_lut->VIIRS_STRAY_SZA_GRID[iHem][iSza] =
                    long_lut->VIIRS_STRAY_SZA_GRID[iHem][iSza];
 
            for (int iDet = 0; iDet < NUM_DETECTORS_DNB; iDet++) {
                for (int iMS = 0; iMS < NUM_MIRROR_SIDES; iMS++) {
                    short_lut->VIIRS_DNB_SDR_STRAY_OFFSET[iHem][iSza][0][iDet][iMS] =
                            long_lut->VIIRS_DNB_SDR_STRAY_OFFSET[iHem][iSza][0][iDet][iMS];
 
                    for (int i = 0; i < (SHORT_DNB_FRAMES - 2); i++) {
                        short_lut->VIIRS_DNB_SDR_STRAY_OFFSET[iHem][iSza][1 + i][iDet][iMS] =
                                long_lut->VIIRS_DNB_SDR_STRAY_OFFSET[iHem][iSza][47
                                + i * 32][iDet][iMS];
                    }
 
                    short_lut->VIIRS_DNB_SDR_STRAY_OFFSET[iHem][iSza][SHORT_DNB_FRAMES
                            - 1][iDet][iMS] =
                            long_lut->VIIRS_DNB_SDR_STRAY_OFFSET[iHem][iSza][EV_DNB_FRAMES
                            - 1][iDet][iMS];
                }
            }
        }
    }
 
    return VCST_SUCCESS;
}
 
/**************************************************************************
 * NAME: write_all_xxxx()
 *
 * DESCRIPTION: Write time-dependent netCDF4 LUT.
 *
 *************************************************************************/
 
int VcstLutNetCDF4::write_all_SDR_DNB_STRAY_LIGHT_CORRECTION_LUT(
        NcFile* nc_output) {
    int status = VCST_SUCCESS;
 
    NcGroup lut_grp = nc_output->addGroup(VIIRS_DNB_STRAY_LIGHT_CORRECTION_LUT);
 
    vector < NcDim > dnb_straylight_grid_dims;
    dnb_straylight_grid_dims.push_back(num_hemispheres_dim_);
    dnb_straylight_grid_dims.push_back(num_sza_bins_dim_);
 
    vector < NcDim > dnb_straylight_offset_dims;
    dnb_straylight_offset_dims.push_back(td_luts_dim_slc_);
    dnb_straylight_offset_dims.push_back(num_hemispheres_dim_);
    dnb_straylight_offset_dims.push_back(num_sza_bins_dim_);
    dnb_straylight_offset_dims.push_back(num_dnb_ev_frames_dim_);
    dnb_straylight_offset_dims.push_back(num_dnb_detectors_dim_);
    dnb_straylight_offset_dims.push_back(num_mirror_sides_dim_);
 
    vector < NcDim > t_ref_dims;
    t_ref_dims.push_back(td_luts_dim_slc_);
    t_ref_dims.push_back(scalar_dim_);
 
    NcVar tref_var = lut_grp.addVar("T_ref", ncInt64, t_ref_dims);
    NcVar max_var = lut_grp.addVar("MAX_RADIANCE_STRAY", ncFloat, scalar_dim_);
    NcVar grid_var = lut_grp.addVar("VIIRS_STRAY_SZA_GRID", ncFloat,
            dnb_straylight_grid_dims);
    NcVar stray_var = lut_grp.addVar("VIIRS_DNB_SDR_STRAY_OFFSET", ncFloat,
            dnb_straylight_offset_dims);
 
    vector<size_t> tstartp, tcountp;
    tstartp.push_back(0);
    tstartp.push_back(0);
    tcountp.push_back(1);
    tcountp.push_back(1);
 
    vector<size_t> fstartp, fcountp;
    fstartp.push_back(0);
    fstartp.push_back(0);
    fstartp.push_back(0);
    fstartp.push_back(0);
    fstartp.push_back(0);
    fstartp.push_back(0);
    fcountp.push_back(1);
    fcountp.push_back(NUM_HEMISPHERES);
    fcountp.push_back(NUM_SZA_BINS);
    fcountp.push_back(SHORT_DNB_FRAMES);
    fcountp.push_back(NUM_DETECTORS_DNB);
    fcountp.push_back(NUM_MIRROR_SIDES);
 
    VcstCalLutInputItem* lut_item;
    lut_item = new VcstCalLutInputItem(VIIRS_DNB_STRAY_LIGHT_CORRECTION_LUT,
            sizeof (proSdrViirsCalDnbStrayLightLUT));
    proSdrViirsCalDnbStrayLightLUT* lut;
 
    shortViirsCalDnbStrayLightLUT* short_lut = new shortViirsCalDnbStrayLightLUT;
 
    std::map<std::string, std::string>::iterator lut_iter;
    int i = 0;
 
    for (lut_iter = lut_files_.begin(); lut_iter != lut_files_.end();
            lut_iter++, i++) {
        std::string filePath = lut_iter->second;
        size_t pos = filePath.rfind("/");
        std::string fileName = filePath.substr(pos);
 
        long long iet = compute_iet_from_filename(fileName);
 
        if (iet < 0) {
            continue;
        }
 
        lut_item->setFilePath(filePath);
        lut_item->getData();
        lut =
                static_cast<proSdrViirsCalDnbStrayLightLUT*> (lut_item->getDataPtr());
 
        compress_StrayLight_LUT(lut, short_lut);
 
        tstartp[0] = i;
        fstartp[0] = i;
        tref_var.putVar(tstartp, tcountp, &iet);
        stray_var.putVar(fstartp, fcountp,
                short_lut->VIIRS_DNB_SDR_STRAY_OFFSET);
    }
 
    max_var.putVar(&short_lut->MAX_RADIANCE_STRAY);
    grid_var.putVar(short_lut->VIIRS_STRAY_SZA_GRID);
 
    delete short_lut;
    delete lut_item;
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_all_SDR_F_PREDICTED_LUT(NcFile* nc_output) {
    int status = VCST_SUCCESS;
 
    NcGroup lut_grp;
    lut_grp = nc_output->addGroup(VIIRS_SDR_F_PREDICTED_LUT);
 
    vector < NcDim > f_factor_dims;
    f_factor_dims.push_back(td_luts_dim_rsbf_);
    f_factor_dims.push_back(num_viirs_bands_dim_);
    f_factor_dims.push_back(max_num_detectors_dim_);
    f_factor_dims.push_back(max_num_gains_dim_);
    f_factor_dims.push_back(num_mirror_sides_dim_);
 
    vector < NcDim > t_ref_dims;
    t_ref_dims.push_back(td_luts_dim_rsbf_);
    t_ref_dims.push_back(scalar_dim_);
 
    NcVar tref_var = lut_grp.addVar("T_ref", ncInt64, t_ref_dims);
    NcVar fref_var = lut_grp.addVar("F_ref", ncDouble, f_factor_dims);
    NcVar fparam1_var = lut_grp.addVar("F_param_1", ncDouble, f_factor_dims);
    NcVar fparam2_var = lut_grp.addVar("F_param_2", ncDouble, f_factor_dims);
 
    vector<size_t> tstartp, tcountp;
    tstartp.push_back(0);
    tstartp.push_back(0);
    tcountp.push_back(1);
    tcountp.push_back(1);
 
    vector<size_t> fstartp, fcountp;
    fstartp.push_back(0);
    fstartp.push_back(0);
    fstartp.push_back(0);
    fstartp.push_back(0);
    fstartp.push_back(0);
    fcountp.push_back(1);
    fcountp.push_back(NUM_VIIRS_BAND);
    fcountp.push_back(MAX_NUM_DETECTOR);
    fcountp.push_back(MAX_NUM_GAIN);
    fcountp.push_back(NUM_MIRROR_SIDES);
 
    VcstCalLutInputItem* lut_item;
    lut_item = new VcstCalLutInputItem(VIIRS_SDR_F_PREDICTED_LUT,
            sizeof (proSdrViirsCalFPredictedTableLUT));
    proSdrViirsCalFPredictedTableLUT* lut;
 
    std::map<std::string, std::string>::iterator lut_iter;
    int i = 0;
 
    for (lut_iter = lut_files_.begin(); lut_iter != lut_files_.end();
            lut_iter++, i++) {
        lut_item->setFilePath(lut_iter->second);
        lut_item->getData();
        lut =
                static_cast<proSdrViirsCalFPredictedTableLUT*> (lut_item->getDataPtr());
 
        tstartp[0] = i;
        fstartp[0] = i;
        tref_var.putVar(tstartp, tcountp, &lut->T_ref);
        fref_var.putVar(fstartp, fcountp, lut->F_ref);
        fparam1_var.putVar(fstartp, fcountp, lut->F_param_1);
        fparam2_var.putVar(fstartp, fcountp, lut->F_param_2);
    }
 
    delete lut_item;
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_all_SDR_RELATIVE_SPECTRAL_RESPONSE_LUT(
        NcFile* nc_output) {
    int status = VCST_SUCCESS;
 
    NcGroup lut_grp;
    lut_grp = nc_output->addGroup(VIIRS_SDR_RELATIVE_SPECTRAL_RESPONSE_LUT);
 
    vector < NcDim > td_array_dims;
    td_array_dims.push_back(td_luts_dim_rsbrsr_);
    td_array_dims.push_back(num_refl_dnb_bands_dim_);
    td_array_dims.push_back(max_rsr_dim_);
 
    vector < NcDim > array_dims;
    array_dims.push_back(num_refl_dnb_bands_dim_);
    array_dims.push_back(max_rsr_dim_);
 
    vector < NcDim > t_ref_dims;
    t_ref_dims.push_back(td_luts_dim_rsbrsr_);
    t_ref_dims.push_back(scalar_dim_);
 
    NcVar tref_var = lut_grp.addVar("T_ref", ncInt64, t_ref_dims);
    NcVar rsr_var = lut_grp.addVar("rsr", ncDouble, td_array_dims);
    NcVar wl_var = lut_grp.addVar("wavelength", ncDouble, array_dims);
    NcVar numrsr_var = lut_grp.addVar("numRsr", ncInt, num_refl_dnb_bands_dim_);
 
    vector<size_t> tstartp, tcountp;
    tstartp.push_back(0);
    tstartp.push_back(0);
    tcountp.push_back(1);
    tcountp.push_back(1);
 
    vector<size_t> fstartp, fcountp;
    fstartp.push_back(0);
    fstartp.push_back(0);
    fstartp.push_back(0);
    fcountp.push_back(1);
    fcountp.push_back(NUM_REFL_PLUS_DNB_BANDS);
    fcountp.push_back(MAX_RSR_VALUES);
 
    VcstCalLutInputItem* lut_item;
    lut_item = new VcstCalLutInputItem(VIIRS_SDR_RELATIVE_SPECTRAL_RESPONSE_LUT,
            sizeof (ProSdrViirsCalRelativeSpectralResponseLUT));
    ProSdrViirsCalRelativeSpectralResponseLUT* lut;
 
    std::map<std::string, std::string>::iterator lut_iter;
    int i = 0;
 
    for (lut_iter = lut_files_.begin(); lut_iter != lut_files_.end();
            lut_iter++, i++) {
        std::string filePath = lut_iter->second;
        size_t pos = filePath.rfind("/");
        std::string fileName = filePath.substr(pos);
 
        long long iet = compute_iet_from_filename(fileName);
 
        if (iet < 0) {
            continue;
        }
 
        lut_item->setFilePath(lut_iter->second);
        lut_item->getData();
        lut =
                static_cast<ProSdrViirsCalRelativeSpectralResponseLUT*> (lut_item->getDataPtr());
 
        tstartp[0] = i;
        fstartp[0] = i;
        tref_var.putVar(tstartp, tcountp, &iet);
        rsr_var.putVar(fstartp, fcountp, lut->rsr);
    }
 
    wl_var.putVar(lut->wavelength);
    numrsr_var.putVar(lut->numRsr);
 
    delete lut_item;
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_all_SDR_SOLAR_SPECTRAL_IRAD_LUT(NcFile* nc_output) {
    int status = VCST_SUCCESS;
 
    NcGroup lut_grp;
    lut_grp = nc_output->addGroup(VIIRS_SDR_SOLAR_SPECTRAL_IRAD_LUT);
 
    vector < NcDim > td_array_dims;
    td_array_dims.push_back(td_luts_dim_rsbrsr_);
    td_array_dims.push_back(num_refl_dnb_bands_dim_);
 
    vector < NcDim > t_ref_dims;
    t_ref_dims.push_back(td_luts_dim_rsbrsr_);
    t_ref_dims.push_back(scalar_dim_);
 
    NcVar tref_var = lut_grp.addVar("T_ref", ncInt64, t_ref_dims);
    NcVar sol_spectral_irad_var = lut_grp.addVar("solar_spectral_irad",
            ncDouble, td_array_dims);
 
    vector<size_t> tstartp, tcountp;
    tstartp.push_back(0);
    tstartp.push_back(0);
    tcountp.push_back(1);
    tcountp.push_back(1);
 
    vector<size_t> fstartp, fcountp;
    fstartp.push_back(0);
    fstartp.push_back(0);
    fcountp.push_back(1);
    fcountp.push_back(NUM_REFL_PLUS_DNB_BANDS);
 
    VcstCalLutInputItem* lut_item;
    lut_item = new VcstCalLutInputItem(VIIRS_SDR_RELATIVE_SPECTRAL_RESPONSE_LUT,
            sizeof (ProSdrViirsCalRelativeSpectralResponseLUT));
    ProSdrViirsCalRelativeSpectralResponseLUT* rsrLUT;
 
    std::map<std::string, std::string>::iterator lut_iter;
    int i = 0;
 
    for (lut_iter = lut_files_.begin(); lut_iter != lut_files_.end();
            lut_iter++, i++) {
        std::string filePath = lut_iter->second;
        size_t pos = filePath.rfind("/");
        std::string fileName = filePath.substr(pos);
 
        long long iet = compute_iet_from_filename(fileName);
 
        if (iet < 0) {
            continue;
        }
 
        lut_item->setFilePath(lut_iter->second);
        lut_item->getData();
        rsrLUT =
                static_cast<ProSdrViirsCalRelativeSpectralResponseLUT*> (lut_item->getDataPtr());
 
        compute_solar_irradiance(rsrLUT);
 
        tstartp[0] = i;
        fstartp[0] = i;
        tref_var.putVar(tstartp, tcountp, &iet);
        sol_spectral_irad_var.putVar(fstartp, fcountp, solar_irad_);
    }
 
    delete lut_item;
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_all_SDR_DNB_LGS_GAINS_LUT(NcFile* nc_output) {
    int status = VCST_SUCCESS;
 
    NcGroup lut_grp;
    lut_grp = nc_output->addGroup(VIIRS_SDR_DNB_LGS_GAINS_LUT);
 
    vector < NcDim > lgs_gains_dims;
    lgs_gains_dims.push_back(td_luts_dim_dnblgs_);
    lgs_gains_dims.push_back(num_dnb_agg_seq_dim_);
    lgs_gains_dims.push_back(num_dnb_detectors_dim_);
    lgs_gains_dims.push_back(num_mirror_sides_dim_);
 
    vector < NcDim > t_ref_dims;
    t_ref_dims.push_back(td_luts_dim_dnblgs_);
    t_ref_dims.push_back(scalar_dim_);
 
    NcVar tref_var = lut_grp.addVar("T_ref", ncInt64, t_ref_dims);
    NcVar fref_var = lut_grp.addVar("F_ref", ncDouble, lgs_gains_dims);
    NcVar fparam1_var = lut_grp.addVar("F_param_1", ncDouble, lgs_gains_dims);
    NcVar fparam2_var = lut_grp.addVar("F_param_2", ncDouble, lgs_gains_dims);
 
    vector<size_t> tstartp, tcountp;
    tstartp.push_back(0);
    tstartp.push_back(0);
    tcountp.push_back(1);
    tcountp.push_back(1);
 
    vector<size_t> fstartp, fcountp;
    fstartp.push_back(0);
    fstartp.push_back(0);
    fstartp.push_back(0);
    fstartp.push_back(0);
    fcountp.push_back(1);
    fcountp.push_back(NUM_AGG_SEQ);
    fcountp.push_back(NUM_DETECTORS_DNB);
    fcountp.push_back(NUM_MIRROR_SIDES);
 
    VcstCalLutInputItem* lut_item;
    lut_item = new VcstCalLutInputItem(VIIRS_SDR_DNB_LGS_GAINS_LUT,
            sizeof (ProSdrViirsCalDnbLgsGainsLUT));
    ProSdrViirsCalDnbLgsGainsLUT* lut;
 
    std::map<std::string, std::string>::iterator lut_iter;
    int i = 0;
 
    for (lut_iter = lut_files_.begin(); lut_iter != lut_files_.end();
            lut_iter++, i++) {
        lut_item->setFilePath(lut_iter->second);
        lut_item->getData();
        lut =
                static_cast<ProSdrViirsCalDnbLgsGainsLUT*> (lut_item->getDataPtr());
 
        tstartp[0] = i;
        fstartp[0] = i;
        tref_var.putVar(tstartp, tcountp, &lut->T_ref);
        fref_var.putVar(fstartp, fcountp, lut->F_ref);
        fparam1_var.putVar(fstartp, fcountp, lut->F_param_1);
        fparam2_var.putVar(fstartp, fcountp, lut->F_param_2);
    }
 
    delete lut_item;
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_all_SDR_DNB_GAIN_RATIOS_LUT(NcFile* nc_output) {
    int status = VCST_SUCCESS;
 
    NcGroup lut_grp;
    lut_grp = nc_output->addGroup(VIIRS_SDR_DNB_GAIN_RATIOS_LUT);
 
    vector < NcDim > dnb_gain_ratio_dims;
    dnb_gain_ratio_dims.push_back(td_luts_dim_dnbgr_);
    dnb_gain_ratio_dims.push_back(num_dnb_agg_seq_dim_);
    dnb_gain_ratio_dims.push_back(num_dnb_detectors_dim_);
    dnb_gain_ratio_dims.push_back(num_dnb_gain_ratios_dim_);
    dnb_gain_ratio_dims.push_back(num_dnb_gain_ratio_coeff_dim_);
 
    vector < NcDim > t_ref_dims;
    t_ref_dims.push_back(td_luts_dim_dnbgr_);
    t_ref_dims.push_back(scalar_dim_);
 
    NcVar tref_var = lut_grp.addVar("T_ref", ncInt64, t_ref_dims);
    NcVar dgr_var = lut_grp.addVar("DnbGainRatios", ncDouble,
            dnb_gain_ratio_dims);
 
    vector<size_t> tstartp, tcountp;
    tstartp.push_back(0);
    tstartp.push_back(0);
    tcountp.push_back(1);
    tcountp.push_back(1);
 
    vector<size_t> fstartp, fcountp;
    fstartp.push_back(0);
    fstartp.push_back(0);
    fstartp.push_back(0);
    fstartp.push_back(0);
    fstartp.push_back(0);
    fcountp.push_back(1);
    fcountp.push_back(NUM_AGG_SEQ);
    fcountp.push_back(NUM_DETECTORS_DNB);
    fcountp.push_back(NUM_GAIN_RATIOS);
    fcountp.push_back(NUM_DNB_GAIN_RATIO_COEFFS);
 
    VcstCalLutInputItem* lut_item;
    lut_item = new VcstCalLutInputItem(VIIRS_SDR_DNB_GAIN_RATIOS_LUT,
            sizeof (ProSdrViirsCalDnbGainRatiosLUT));
    ProSdrViirsCalDnbGainRatiosLUT* lut;
 
    std::map<std::string, std::string>::iterator lut_iter;
    int i = 0;
 
    for (lut_iter = lut_files_.begin(); lut_iter != lut_files_.end();
            lut_iter++, i++) {
        std::string filePath = lut_iter->second;
        size_t pos = filePath.rfind("/");
        std::string fileName = filePath.substr(pos);
 
        long long iet = compute_iet_from_filename(fileName);
 
        if (iet < 0) {
            continue;
        }
 
        lut_item->setFilePath(filePath);
        lut_item->getData();
        lut =
                static_cast<ProSdrViirsCalDnbGainRatiosLUT*> (lut_item->getDataPtr());
 
        tstartp[0] = i;
        fstartp[0] = i;
        tref_var.putVar(tstartp, tcountp, &iet);
        dgr_var.putVar(fstartp, fcountp, lut->DnbGainRatios);
    }
 
    delete lut_item;
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::write_all_SDR_DNB_DN0_LUT(NcFile* nc_output) {
    int status = VCST_SUCCESS;
 
    NcGroup lut_grp;
    lut_grp = nc_output->addGroup(VIIRS_SDR_DNB_DN0_LUT);
 
    vector < NcDim > dnb_dn0_dims;
    dnb_dn0_dims.push_back(td_luts_dim_dnbdn0_);
    dnb_dn0_dims.push_back(num_dnb_ev_frames_dim_);
    dnb_dn0_dims.push_back(num_dnb_detectors_dim_);
    dnb_dn0_dims.push_back(num_dnb_gains_dim_);
    dnb_dn0_dims.push_back(num_mirror_sides_dim_);
 
    vector < NcDim > t_ref_dims;
    t_ref_dims.push_back(td_luts_dim_dnbdn0_);
    t_ref_dims.push_back(scalar_dim_);
 
    NcVar tref_var = lut_grp.addVar("T_ref", ncInt64, t_ref_dims);
    NcVar dn0_var = lut_grp.addVar("data", ncFloat, dnb_dn0_dims);
 
    vector<size_t> tstartp, tcountp;
    tstartp.push_back(0);
    tstartp.push_back(0);
    tcountp.push_back(1);
    tcountp.push_back(1);
 
    vector<size_t> fstartp, fcountp;
    fstartp.push_back(0);
    fstartp.push_back(0);
    fstartp.push_back(0);
    fstartp.push_back(0);
    fstartp.push_back(0);
    fcountp.push_back(1);
    fcountp.push_back(EV_DNB_FRAMES);
    fcountp.push_back(NUM_DETECTORS_DNB);
    fcountp.push_back(MAX_NUM_GAIN);
    fcountp.push_back(NUM_MIRROR_SIDES);
 
    VcstCalLutInputItem* lut_item;
    lut_item = new VcstCalLutInputItem(VIIRS_SDR_DNB_DN0_LUT,
            sizeof (proSdrViirsDnbDn0Type));
    proSdrViirsDnbDn0Type* lut;
 
    std::map<std::string, std::string>::iterator lut_iter;
    int i = 0;
 
    for (lut_iter = lut_files_.begin(); lut_iter != lut_files_.end();
            lut_iter++, i++) {
        std::string filePath = lut_iter->second;
        size_t pos = filePath.rfind("/");
        std::string fileName = filePath.substr(pos);
 
        long long iet = compute_iet_from_filename(fileName);
 
        if (iet < 0) {
            continue;
        }
 
        lut_item->setFilePath(filePath);
        lut_item->getData();
        lut = static_cast<proSdrViirsDnbDn0Type*> (lut_item->getDataPtr());
 
        tstartp[0] = i;
        fstartp[0] = i;
        tref_var.putVar(tstartp, tcountp, &iet);
        dn0_var.putVar(fstartp, fcountp, lut->data);
    }
 
    delete lut_item;
 
    return VCST_SUCCESS;
}
 
int VcstLutNetCDF4::collect_lut_files(std::string lutString, std::string path) {
    int status = VCST_SUCCESS;
 
    struct stat st;
 
    // Check to determine whether input path is valid
    if (stat(path.c_str(), &st) != 0) {
        cerr
                << "VcstLutNetCDF4::collect_lut_files() PCF path string " + path
                + " is invalid. " << endl;
        return VCST_FAIL;
    }
 
    if (S_ISREG(st.st_mode)) {
        size_t pos = path.rfind("/");
        path = path.substr(0, pos);
    }
 
    if (!((stat(path.c_str(), &st) == 0) && S_ISDIR(st.st_mode))) {
        cerr
                << "VcstLutNetCDF4::collect_lut_files() PCF path string " + path
                + " is not a valid directory. " << endl;
        return VCST_FAIL;
    }
 
    DIR* directory = 0;
    struct dirent* ent = 0;
 
    directory = opendir(path.c_str());
 
    if (directory != 0) {
        lut_files_.clear();
 
        while ((ent = readdir(directory)) != 0) {
            std::string filename = string(ent->d_name);
            std::string filepath = path + "/" + filename;
 
            if (stat(filepath.c_str(), &st) != 0) {
                continue;
            }
            if (!S_ISREG(st.st_mode)) {
                continue;
            }
            size_t pos = filename.find(lutString);
 
            if (pos == std::string::npos) {
                continue;
            }
 
            pos = filename.find("_20");
 
            if (pos == std::string::npos) {
                continue;
            }
 
            std::string dateString = filename.substr(pos + 1, 8);
 
            lut_files_.insert(make_pair(dateString, filepath));
        }
 
        closedir(directory);
    } else {
        cerr
                << "VcstLutNetCDF4::collect_lut_files() Unable to open directory "
                + path + ". " << endl;
        return VCST_FAIL;
    }
 
    if (lut_files_.empty()) {
        cerr
                << "VcstLutNetCDF4::collect_lut_files() No LUT files for "
                + lutString + " in directory " + path + ". " << endl;
        return VCST_FAIL;
    }
    return VCST_SUCCESS;
}
 
long long VcstLutNetCDF4::compute_iet_from_filename(std::string fileName) {
 
    double tai = 0.0;
 
    VcstTime* timeAPI = VcstTime::getInstance();
    timeAPI->initialize();
 
    size_t pos = fileName.find("_20");
 
    if (pos == std::string::npos) {
        return -1l;
    }
 
    std::string str_year = fileName.substr(pos + 1, 4);
    std::string str_month = fileName.substr(pos + 5, 2);
    std::string str_day = fileName.substr(pos + 7, 2);
 
    TimGdtStruct gdt;
 
    gdt.year = atoi(str_year.c_str());
    gdt.month = atoi(str_month.c_str());
    gdt.day = atoi(str_day.c_str());
    gdt.hour = 0;
    gdt.min = 0;
    gdt.sec = 0;
    gdt.mill = 0;
    gdt.msec = 0;
    gdt.wkday = 0;
    gdt.numday = 0;
 
    timeAPI->gdt2Tai(&gdt, &tai);
 
    return tai * TAI2IET;
}
 
/**************************************************************************
 * NAME: compute_solar_irradiance()
 *
 * DESCRIPTION: Compute solar spectral irradiance for all RSB bands
 *
 *************************************************************************/
 
int VcstLutNetCDF4::compute_solar_irradiance(
        const ProSdrViirsCalRelativeSpectralResponseLUT* rsrLUT) {
    int x_low;
    int x_high;
    int rsr_pts;
    int solar_irad_pts;
 
    double rsr_interp[SOLAR_IRAD_SIZE];
    double product[SOLAR_IRAD_SIZE];
    double wl_sol_diff;
    double rsr_step_diff;
    double wl_step_diff;
    double resultnum;
    double resultdenom;
 
    VcstCalLutInputItem* lut_solar;
    proSdrViirsCalSolarIradLUT* solarIradLUT;
 
    lut_solar = read_cal_lut(VIIRS_SDR_SOLAR_IRAD_LUT,
            sizeof (proSdrViirsCalSolarIradLUT));
 
    if (lut_solar != 0) {
        solarIradLUT =
                static_cast<proSdrViirsCalSolarIradLUT*> (lut_solar->getDataPtr());
    } else {
        return VCST_FAIL;
    }
 
    for (int iRefB = 0; iRefB < 14; iRefB++) {
        rsr_pts = rsrLUT->numRsr[iRefB];
 
        x_low = 0;
 
        while (solarIradLUT->x[x_low] < rsrLUT->wavelength[iRefB][0]) {
            ++x_low;
        }
 
        x_high = 0;
 
        while (solarIradLUT->x[x_high] < rsrLUT->wavelength[iRefB][rsr_pts - 1]) {
            ++x_high;
        }
 
        --x_high;
 
        solar_irad_pts = x_high - x_low;
 
        //  interpolate the esun-RSR values
 
        for (int iSol = 0; iSol < solar_irad_pts; iSol++) {
            for (int iRsr = 0; iRsr < rsr_pts; iRsr++) {
                if (rsrLUT->wavelength[iRefB][iRsr]
                        >= solarIradLUT->x[x_low + iSol]) {
 
                    wl_step_diff = rsrLUT->wavelength[iRefB][iRsr]
                            - rsrLUT->wavelength[iRefB][iRsr - 1];
 
                    //  test for division by epsilon
                    if (fabs(wl_step_diff)
                            < std::numeric_limits<double>::epsilon()) {
                        return VCST_FAIL;
                    }
 
                    wl_sol_diff = rsrLUT->wavelength[iRefB][iRsr]
                            - solarIradLUT->x[x_low + iSol];
                    rsr_step_diff = (rsrLUT->rsr[iRefB][iRsr]
                            - rsrLUT->rsr[iRefB][iRsr - 1]);
 
                    rsr_interp[iSol] = rsrLUT->rsr[iRefB][iRsr]
                            - wl_sol_diff * rsr_step_diff / wl_step_diff;
 
                    break; //  go to next element
                }
            }
        }
 
        //  multiply interpolated RSR values by those solar irradiance values
        //        that have the same wavelength
 
        for (int iSol = 0; iSol < solar_irad_pts; iSol++) {
            product[iSol] = rsr_interp[iSol] * solarIradLUT->y[x_low + iSol];
        }
 
        //  integrate numerator
 
        resultnum = 0.0;
 
        for (int iSol = 0; iSol <= (solar_irad_pts - 2); iSol++) {
            resultnum += (product[iSol + 1] + product[iSol])
                    * (solarIradLUT->x[x_low + iSol + 1]
                    - solarIradLUT->x[x_low + iSol]) * .5;
        }
 
        //  integrate denominator
 
        resultdenom = 0.0;
 
        for (int iSol = 0; iSol <= (solar_irad_pts - 2); iSol++) {
            resultdenom += (rsr_interp[iSol + 1] + rsr_interp[iSol])
                    * (solarIradLUT->x[x_low + iSol + 1]
                    - solarIradLUT->x[x_low + iSol]) * .5;
        }
 
        if (fabs(resultdenom) < std::numeric_limits<double>::epsilon()) {
            return VCST_FAIL;
        }
 
        solar_irad_[iRefB] = resultnum / resultdenom / AU_TO_METERS
                / AU_TO_METERS;
 
    }
 
    delete lut_solar;
 
    return VCST_SUCCESS;
}