AfrtOptions.cpp

Go to the documentation of this file.

 
/**************************************************************************
*
* NAME: AfrtOptions.cpp
*
* DESCRIPTION: The AfrtOptions class sets up the items
*              that are in the program configuration file.
*              The class provides primitives to read the configurable
*              information and provide it to other classes as required.
*
*  Created on: April, 2018
*      Author: Sam Anderson, Afrt
*
**************************************************************************/
 
#include <iostream>
#include <string>
#include <cstdlib>
#include <algorithm>
#include <libgen.h>
#include <vector>
#include <map>
 
#include <AfrtConstants.h>
#include <AfrtOptions.h>
 
using namespace std;
 
//---------------------------------------------------------------------------
// Static constants
//---------------------------------------------------------------------------
 
const std::string INPUT_PHS_NC4   = "nc4_phs";
const std::string INPUT_PHS       = "ifile_phs";
const std::string INPUT_OCN       = "ifile_ocn";
const std::string INPUT_RT1       = "ifile_rt1";
const std::string INPUT_RT2       = "ifile_rt2";
const std::string INPUT_OZONE_RT1 = "ozone_rt1";
const std::string INPUT_ATM_RT1   = "atm_rt1";
const std::string INPUT_COEFF_RT1 = "coeff_rt1";
const std::string ODIR_PHS        = "odir_phs";
const std::string ODIR_OCN        = "odir_ocn";
const std::string ODIR_RT1        = "odir_rt1";
const std::string ODIR_RT2        = "odir_rt2";
const std::string ODIR_NC4        = "odir_nc4";
const std::string OFILE_PHS        = "ofile_phs";
const std::string OFILE_OCN        = "ofile_ocn";
const std::string OFILE_RT1        = "ofile_rt1";
const std::string OFILE_RT2        = "ofile_rt2";
const std::string OFILE_ALL        = "ofile_all";
const std::string OFILE_NC4        = "ofile";
 
const std::string INPUT_WL_INDEX    = "wave_id";
const std::string INPUT_SD_INDEX    = "model_id";
const std::string INPUT_TAU_INDEX   = "tau_id";
const std::string INPUT_WIND_INDEX  = "wind_id";
 
const std::string INPUT_SEA_SLOPE_STDEV = "sea_slope_stdev";
const std::string INPUT_WIND_SPEED  = "wind_speed";
const std::string INPUT_DELTA_TAU   = "delta_tau";
const std::string INPUT_SURF_PRESSURE = "surface_pressure";
const std::string INPUT_DUST_HEIGHT = "dust_height";
const std::string INPUT_DUST_SIGMA  = "dust_sigma";
const std::string INPUT_CLOUD_TOP   = "cloud_top";
const std::string INPUT_CLOUD_BOTTOM = "cloud_bottom";
const std::string INPUT_AOD         = "optical_thickness";
const std::string INPUT_HUMIDITY    = "humidity";
 
const std::string INPUT_WAVELENGTHS = "wavelengths";
const std::string INPUT_HUMIDITIES  = "humidities";
const std::string INPUT_WINDSPEEDS  = "rms_slopes";
const std::string INPUT_ANGLES      = "theta_angles";
const std::string INPUT_OPTDEPTHS   = "optical_depths";
 
const std::string INPUT_DELTA_THETA = "dtheta";
const std::string INPUT_DELTA_PHI   = "dphi";
const std::string INPUT_SEA_NR      = "sea_nr";
const std::string INPUT_SEA_NI      = "sea_ni";
const std::string INPUT_SALINITY    = "salinity";
const std::string INPUT_THETA_CELL  = "theta_cell";
const std::string INPUT_PHI_CELL    = "phi_cell";
 
const std::string INPUT_PSUDO       = "psudo";
const std::string INPUT_RAYLEIGH    = "rayleigh";
const std::string INPUT_AEROSOLS    = "aerosols";
const std::string INPUT_GASES       = "gases";
const std::string INPUT_IAIR        = "iair";
const std::string INPUT_KSET        = "kset";
const std::string INPUT_IREF        = "iref";
const std::string INPUT_ISET        = "iset";
const std::string INPUT_PRIN        = "prin";
const std::string INPUT_ITRANS      = "trans";
const std::string INPUT_POL         = "pol";
const std::string INPUT_CRFT        = "crft";
const std::string INPUT_ACTFLX      = "actflx";
const std::string INPUT_SURF        = "surf";
const std::string INPUT_GLINT       = "glint";   //apply glint correction
const std::string INPUT_IOCN        = "ocn";
const std::string INPUT_FOAM        = "foam";
const std::string INPUT_WATR        = "watr";
const std::string INPUT_CONC        = "conc";
const std::string INPUT_IPROB       = "iprob";
 
// global variable to hold the command line parameters
static clo_optionList_t* afrt_global_optionList = NULL;
 
void afrt_set_optionList(clo_optionList_t* list) {
    afrt_global_optionList = list;
}
 
clo_optionList_t* afrt_get_optionList() {
    if(afrt_global_optionList == NULL) {
        cerr << "afrt_get_optionList: optionList pointer needs to be set before accessing." << endl;
        exit(EXIT_FAILURE);
    }
    return afrt_global_optionList;
}
 
std::string  afrt_get_option(const std::string& name) {
    if(afrt_global_optionList == NULL) {
        cerr << "afrt_get_option: optionList pointer needs to be set before accessing." << endl;
        exit(EXIT_FAILURE);
    }
    clo_option_t* option = clo_findOption(afrt_global_optionList, name.c_str());
    if(option == NULL || !clo_isOptionSet(option))
        return "";
    string result(clo_getOptionString(option));
    char *ocdataroot_str = getenv("OCDATAROOT");
    if (ocdataroot_str == 0x0) {
        printf("Environment variable OCDATAROOT not defined.\n");
        exit(1);
    }
 
    if (result.compare(0, 10, "$OCDATAROOT") == 0)
        result.replace(0, 10, ocdataroot_str);
    return result;
}
 
int*  afrt_get_option_ints(const std::string& name, int& count) {
    if(afrt_global_optionList == NULL) {
        cerr << "afrt_get_option: optionList pointer needs to be set before accessing." << endl;
        exit(EXIT_FAILURE);
    }
    clo_option_t* option = clo_findOption(afrt_global_optionList, name.c_str());
    if(option == NULL || !clo_isOptionSet(option))
        return 0L;
    int* ptr(clo_getOptionInts(option, &count));
    return ptr;
}
 
double*  afrt_get_option_doubles(const std::string& name, int& count) {
    if(afrt_global_optionList == NULL) {
        cerr << "afrt_get_option: optionList pointer needs to be set before accessing." << endl;
        exit(EXIT_FAILURE);
    }
    clo_option_t* option = clo_findOption(afrt_global_optionList, name.c_str());
    if(option == NULL || !clo_isOptionSet(option))
        return 0L;
    double* ptr(clo_getOptionDoubles(option, &count));
    return ptr;
}
 
double  afrt_get_option_double(const std::string& name) {
    if(afrt_global_optionList == NULL) {
        cerr << "afrt_get_option: optionList pointer needs to be set before accessing." << endl;
        exit(EXIT_FAILURE);
    }
    clo_option_t* option = clo_findOption(afrt_global_optionList, name.c_str());
    if(option == NULL || !clo_isOptionSet(option))
        return -999.9;
    double result(clo_getOptionDouble(option));
    return result;
}
 
int  afrt_get_option_int(const std::string& name) {
    if(afrt_global_optionList == NULL) {
        cerr << "afrt_get_option: optionList pointer needs to be set before accessing." << endl;
        exit(EXIT_FAILURE);
    }
    clo_option_t* option = clo_findOption(afrt_global_optionList, name.c_str());
    if(option == NULL || !clo_isOptionSet(option))
        return -999;
    int result(clo_getOptionInt(option));
    return result;
}
 
bool  afrt_get_option_bool(const std::string& name) {
    if(afrt_global_optionList == NULL) {
        cerr << "afrt_get_option: optionList pointer needs to be set before accessing." << endl;
        exit(EXIT_FAILURE);
    }
    clo_option_t* option = clo_findOption(afrt_global_optionList, name.c_str());
    if(option == NULL)
        return false;
    bool result(clo_getOptionBool(option));
    return result;
}
 
void afrt_add_options(clo_optionList_t* list) {
    if(afrt_global_optionList == NULL)
        afrt_global_optionList = list;
 
    clo_addOption(list, INPUT_PHS_NC4.c_str(), CLO_TYPE_STRING, NULL, "nc4 infile PHS");
    clo_addOption(list, INPUT_PHS.c_str(), CLO_TYPE_STRING, NULL, "infile PHS");
    clo_addOption(list, INPUT_OCN.c_str(), CLO_TYPE_STRING, NULL, "infile OCN");
    clo_addOption(list, INPUT_RT1.c_str(), CLO_TYPE_STRING, NULL, "infile RT1");
    clo_addOption(list, INPUT_RT2.c_str(), CLO_TYPE_STRING, NULL, "infile RT2");
    clo_addOption(list, INPUT_OZONE_RT1.c_str(), CLO_TYPE_STRING, NULL, "infile ozone RT1");
    clo_addOption(list, INPUT_ATM_RT1.c_str(), CLO_TYPE_STRING, NULL, "infile ATM RT1");
    clo_addOption(list, INPUT_COEFF_RT1.c_str(), CLO_TYPE_STRING, NULL, "infile coeff RT1");
    clo_addOption(list, ODIR_PHS.c_str(), CLO_TYPE_STRING, NULL, "directory PHS");
    clo_addOption(list, ODIR_OCN.c_str(), CLO_TYPE_STRING, NULL, "directory OCN");
    clo_addOption(list, ODIR_RT1.c_str(), CLO_TYPE_STRING, NULL, "directory RT1");
    clo_addOption(list, ODIR_RT2.c_str(), CLO_TYPE_STRING, NULL, "directory RT2");
    clo_addOption(list, ODIR_NC4.c_str(), CLO_TYPE_STRING, NULL, "output directory NC4");
    clo_addOption(list, OFILE_PHS.c_str(), CLO_TYPE_STRING, NULL, "output NC4 PHS");
    clo_addOption(list, OFILE_OCN.c_str(), CLO_TYPE_STRING, NULL, "output NC4 OCN");
    clo_addOption(list, OFILE_RT1.c_str(), CLO_TYPE_STRING, NULL, "output NC4 RT1");
    clo_addOption(list, OFILE_RT2.c_str(), CLO_TYPE_STRING, NULL, "output NC4 RT2");
    clo_addOption(list, OFILE_ALL.c_str(), CLO_TYPE_STRING, NULL, "output NC4 RT2");
    clo_addOption(list, OFILE_NC4.c_str(), CLO_TYPE_STRING, NULL, "output NC4 file");
 
    clo_addOption(list, INPUT_WL_INDEX.c_str(), CLO_TYPE_INT, NULL, "input parameter");
    clo_addOption(list, INPUT_SD_INDEX.c_str(), CLO_TYPE_INT, NULL, "input parameter");
    clo_addOption(list, INPUT_TAU_INDEX.c_str(), CLO_TYPE_INT, NULL, "input parameter");
    clo_addOption(list, INPUT_WIND_INDEX.c_str(), CLO_TYPE_INT, NULL, "input parameter");
    clo_addOption(list, INPUT_DELTA_THETA.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_DELTA_PHI.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_SEA_NR.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_SEA_NI.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_THETA_CELL.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_PHI_CELL.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_SEA_SLOPE_STDEV.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_WIND_SPEED.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_DELTA_TAU.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_SURF_PRESSURE.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_DUST_HEIGHT.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_DUST_SIGMA.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_CLOUD_TOP.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_CLOUD_BOTTOM.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_AOD.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_HUMIDITY.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
 
    clo_addOption(list, INPUT_WAVELENGTHS.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_HUMIDITIES.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_WINDSPEEDS.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_ANGLES.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
    clo_addOption(list, INPUT_OPTDEPTHS.c_str(), CLO_TYPE_DOUBLE, NULL, "input parameter");
 
    clo_addOption(list, INPUT_IREF.c_str(), CLO_TYPE_INT, NULL, "input parameter");
    clo_addOption(list, INPUT_ISET.c_str(), CLO_TYPE_INT, NULL, "input parameter");
    clo_addOption(list, INPUT_IAIR.c_str(), CLO_TYPE_INT, NULL, "input parameter");
    clo_addOption(list, INPUT_KSET.c_str(), CLO_TYPE_INT, NULL, "input parameter");
    clo_addOption(list, INPUT_PRIN.c_str(), CLO_TYPE_BOOL, NULL, "afrt input");
    clo_addOption(list, INPUT_PSUDO.c_str(), CLO_TYPE_BOOL, NULL, "afrt input");
    clo_addOption(list, INPUT_ITRANS.c_str(), CLO_TYPE_BOOL, NULL, "afrt input");
    clo_addOption(list, INPUT_POL.c_str(), CLO_TYPE_BOOL, NULL, "afrt input");
    clo_addOption(list, INPUT_CRFT.c_str(), CLO_TYPE_BOOL, NULL, "afrt input");
    clo_addOption(list, INPUT_ACTFLX.c_str(), CLO_TYPE_BOOL, NULL, "afrt input");
    clo_addOption(list, INPUT_SURF.c_str(), CLO_TYPE_BOOL, NULL, "afrt input");
    clo_addOption(list, INPUT_GLINT.c_str(), CLO_TYPE_BOOL, NULL, "afrt input");
    clo_addOption(list, INPUT_IOCN.c_str(), CLO_TYPE_BOOL, NULL, "afrt input");
    clo_addOption(list, INPUT_FOAM.c_str(), CLO_TYPE_BOOL, NULL, "afrt input");
    clo_addOption(list, INPUT_WATR.c_str(), CLO_TYPE_BOOL, NULL, "afrt input");
    clo_addOption(list, INPUT_CONC.c_str(), CLO_TYPE_BOOL, NULL, "afrt input");
    clo_addOption(list, INPUT_RAYLEIGH.c_str(), CLO_TYPE_BOOL, NULL, "afrt input");
    clo_addOption(list, INPUT_AEROSOLS.c_str(), CLO_TYPE_BOOL, NULL, "afrt input");
    clo_addOption(list, INPUT_GASES.c_str(), CLO_TYPE_BOOL, NULL, "afrt input");
 
    clo_addOption(list, INPUT_IPROB.c_str(), CLO_TYPE_INT, "1", "1=HG relationship, 2=Cox-Munk wind independent, 3=Cox-Munk wind dependent");
 
    clo_addOption(list, "pversion", CLO_TYPE_STRING, "Unspecified", "processing version string");
    
    clo_addOption(list, "PGEVersion", CLO_TYPE_STRING, NULL, "PGE version");
    clo_addOption(list, "PGE_Name", CLO_TYPE_STRING, NULL, "PGE name");
 
    string desc = "\n";
    desc += "This program can also accept a PCF file.  The PCF file option names take\n";
    desc += "precedence over the standard option parameters even if the standard option\n";
    desc += "is on the command line.  To over ride an option in a PCF file, use the PCF\n";
    desc += "option name on the command line.\n";
    clo_addOption(list, "pcf_help", CLO_TYPE_HELP, NULL, desc.c_str());
}
 
string afrt_get_source() {
    vector<string> sourcesList;
 
    string source;
    
    for(vector<string>::iterator it = sourcesList.begin(); it < sourcesList.end(); it++) {
        string str = afrt_get_option(*it);
        if(!str.empty()) {
            source.append(",");
            source.append(basename((char*)str.c_str()));
        }
    }
    return source;
}
 
string afrt_get_history(int argc, char* argv[]) {
    string history = basename(argv[0]);
    for (int i=1; i<argc; i++) {
        history.append(" ");
        history.append(basename(argv[i]));
    }
    return history;
}