l1c_input.cpp

Go to the documentation of this file.

//******************************************
//l1c_input.cpp
//  Created by Martin Montes on 10/21/20.
//****************************************
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <netcdf>
#include <unistd.h>
#include <string>
#include <vector>
#include <boost/algorithm/string.hpp>
#include <clo.h>
#include <filetype.h>
 
using namespace std;
using namespace netCDF;
using namespace netCDF::exceptions;
 
#include "l1c_input.h"
#include "genutils.h"
#include "passthebuck.h"
#include "sensorInfo.h"
#include "ncfileinfo.h"
 
#include "l1c_filehandle.h"
 
 
// store the name of program we are running.
static char mainProgramName[50];
 
 
namespace l1c{
 
   static char *l1cgen_optionKeys[] = {
    "-help",
    "-version",
    "-dump_options",
    "-dump_options_paramfile",
    "-dump_options_xmlfile",
    "par",
    "pversion",
    "suite",
    "l2prod",
    "ifile",
    "ofile",
    "oformat",
    "fqfile",
    "parfile",
    "spixl",
    "epixl",
    "sline",
    "eline",
    "calfile",
    "xcalfile",
    "gain",
    "offset",
    "sl_pixl",
    "sl_frac",
    "l1c_pflag",//l1c processing flag, 0: no processing, 1: full orbit (1 day),2: specific swath, 3: L1C grid creation, 4: granule processing
    "binlatmin",
    "binlatmax",
    "binlonmin",
    "binlonmax",
    "selgran",//selected granules up to 10 files, they are ids not indexes!! 
    "selyear",//selected year
    "selmon",//selected month
    "selday", //selected day
    "swtnum",//swath # for the processing day
    "gres",//grid resolution in km
    "nbinx",
    "sensor",//SPEX 1, OCI 2 and HARP 3
    "fileix",
    "gransize",
    "l1c_proj",//projection type,"swath_grid":0 (default-Fred) or "socea=1"
    "terrain_correct",//terrain distortion correction , 1: yes 
    "cloud_correct",//cloud distortion correction , 1: yes 
    //multi  attributes (view, pol, bands) 
    "overlap_vflag",//tells if we want merged views
    "overlap_pflag",//tells if we want merged polarizations
    "overlap_bflag",//tells if we want merged spectral bands
    //uncertainty params l1c merged products
    "unc_meth",//uncertainity calculation method
    "unc_thres_v", //uncertainity threshold of angular merged products as %
    "unc_thres_p",//same but for polarization
    "unc_thres_b",//sam
    NULL
};
 
 
   L1C_input::L1C_input(){};//constructor
   L1C_input::~L1C_input(){};
 
 
 
int32_t L1C_input::l1c_usage(const char *prog,const char *ver) {
    clo_optionList_t* list;
 
    list = clo_createList();
    l1c_init_options(list, prog,ver);
    clo_printUsage(list);
 
    return 0;
}
 
 
int32_t L1C_input::l1c_init_options(clo_optionList_t* list, const char* prog, const char* version) {
    char tmpStr[2048];
    clo_option_t* option;
 
    if(strcmp(prog, "l1cgen")) clo_setSelectOptionKeys(l1cgen_optionKeys);
 
    // set the min program name
    strcpy(mainProgramName, prog);
 
    sprintf(tmpStr, "Usage: %s argument-list\n\n", prog);
    strcat(tmpStr, "  The argument-list is a set of keyword=value pairs. The arguments can\n");
    strcat(tmpStr, "  be specified on the commandline, or put into a parameter file, or the\n");
    strcat(tmpStr, "  two methods can be used together, with commandline over-riding.\n\n");
    strcat(tmpStr, "  return value: 0=OK, 1=error, 110=north,south,east,west does not intersect\n");
    strcat(tmpStr, "  file data.\n\n");
    strcat(tmpStr, "The list of valid keywords follows:\n");
    clo_setHelpStr(tmpStr);
 
    // add the parfile alias for backward compatibility
    clo_addOption(list, "parfile", CLO_TYPE_IFILE, NULL, "inititil settings");
    clo_addAlias(list, "par", "parfile");
 
    strcpy(tmpStr, "input L1b file name");
    option = clo_addOption(list, "ifile", CLO_TYPE_IFILE, NULL, tmpStr);
    clo_addOptionAlias(option, "infile");
 
    clo_addOption(list, "ofile", CLO_TYPE_OFILE, "output", "output file name");
//    clo_addOption(list, "fileuse", CLO_TYPE_OFILE, NULL, "write the filenames of the the input files used to this file");
 
    clo_addOption(list, "suite", CLO_TYPE_STRING, NULL, "suite for default parameters");
    //clo_addOption(list, "qual_prod", CLO_TYPE_STRING, NULL, "quality product field name");
 
//    clo_addOption(list, "deflate", CLO_TYPE_INT, "5", "deflation level.  0=off or 1=low through 9=high");
 
    clo_addOption(list, "verbose", CLO_TYPE_BOOL, "off", "Allow more verbose screen messages");
//    clo_addOption(list, "night", CLO_TYPE_BOOL, "off", "set to 1 for SST night processing");
    //clo_addOption(list, "qual_max", CLO_TYPE_INT, "2", "maximum acceptable quality");
    clo_addOption(list, "rowgroup", CLO_TYPE_INT, "-1", "# of bin rows to process at once.");
    clo_addOption(list, "sday", CLO_TYPE_INT, "1970001", "start datadate (YYYYDDD) [ignored for \"regional\" prodtype]");
    clo_addOption(list, "eday", CLO_TYPE_INT, "2038018", "end datadate (YYYYDDD) [ignored for \"regional\" prodtype]");
    //clo_addOption(list, "latnorth", CLO_TYPE_FLOAT, "90", "northern most latitude");
    //clo_addOption(list, "latsouth", CLO_TYPE_FLOAT, "-90", "southern most latitude");
    //clo_addOption(list, "loneast", CLO_TYPE_FLOAT, "0", "eastern most longitude");
    //clo_addOption(list, "lonwest", CLO_TYPE_FLOAT, "0", "western most longitude");
    //clo_addOption(list, "minobs", CLO_TYPE_FLOAT, "0", "minimum observation to use.");
 
    strcpy(tmpStr, "bin resolution\n");
    strcat(tmpStr, "         H: 0.5km\n");
    strcat(tmpStr, "         Q: 250m\n");
    strcat(tmpStr, "        HQ: 100m\n");
    strcat(tmpStr, "        HH: 50m\n");
    strcat(tmpStr, "         1: 1.1km\n");
    strcat(tmpStr, "         2: 2.3km\n");
    strcat(tmpStr, "         4: 4.6km\n");
    strcat(tmpStr, "         9: 9.2km\n");
    strcat(tmpStr, "        18: 18.5km\n");
    strcat(tmpStr, "        36: 36km\n");
    strcat(tmpStr, "        1D: 1 degree\n");
    strcat(tmpStr, "        HD: 0.5 degree\n");
    strcat(tmpStr, "        QD: 0.25 degree");
    option = clo_addOption(list, "resolution", CLO_TYPE_STRING, "H", tmpStr);
    clo_addOptionAlias(option, "resolve");
//    clo_addOption(list, "prodtype", CLO_TYPE_STRING, "day", "product type (Set to \"regional\" to bin all scans.)");
//    clo_addOption(list, "pversion", CLO_TYPE_STRING, "unspecified", "production version");
 
//    clo_addOption(list, "composite_scheme", CLO_TYPE_STRING, NULL, "composite scheme (min/max)");
//    clo_addOption(list, "composite_prod", CLO_TYPE_STRING, NULL, "composite product fieldname");
    strcpy(tmpStr, "flags masked [see /SENSOR/l2bin_defaults.par]");
 //   clo_addOption(list, "flaguse", CLO_TYPE_STRING, DEF_FLAG, tmpStr);
 
    strcpy(tmpStr, "l2prod = bin products [default=all products]\n");
    strcat(tmpStr, "    Set to \"ALL\" or \"all\" for all L2 products in 1st input file.\n");
    strcat(tmpStr, "    Use ':' or ',' or ' ' as delimiters.\n");
    strcat(tmpStr, "    Use ';' or '=' to delineate minimum values.\n");
    clo_addOption(list, "l2prod", CLO_TYPE_STRING, "ALL", tmpStr);
 
//    clo_addOption(list, "area_weighting", CLO_TYPE_INT, "0", "Enable area weighting\n        0: off\n        1: pixel box\n        2: pixel bounding box\n        3: pixel polygon");
 
 
//l1c options--------------------------
    //**************L1C options *****************************************
    strcpy(tmpStr, "L1C processing flag\n");
    strcat(tmpStr, "        1: L1C grid creation from L1B granules\n");
    strcat(tmpStr, "        2: SBS binning\n");
    strcat(tmpStr, "        3: weighted binning\n");
    strcat(tmpStr, "        4: L2 processing\n");
    strcat(tmpStr, "        5: L1C grid creation from HKT telemetry\n");
 
    clo_addOption(list, "l1c_pflag", CLO_TYPE_INT, "0", tmpStr);
 
    strcpy(tmpStr, "L1C grid min binning latitude\n");
    clo_addOption(list, "binlatmin", CLO_TYPE_FLOAT, "-90", tmpStr);
    strcpy(tmpStr, "L1C grid max binning latitude\n");
    clo_addOption(list, "binlatmax", CLO_TYPE_FLOAT, "+90", tmpStr);
    strcpy(tmpStr, "L1C grid min binning longitude\n");
    clo_addOption(list, "binlonmin", CLO_TYPE_FLOAT, "-180", tmpStr);
    strcpy(tmpStr, "L1C grid max binning longitude\n");
    clo_addOption(list, "binlonmax", CLO_TYPE_FLOAT, "+180", tmpStr);
 
    strcpy(tmpStr, "L1C processing of granules\n");
    strcpy(tmpStr, "granule id (1 to 10) note: not indexes!\n");
    clo_addOption(list, "selgran", CLO_TYPE_INT, "[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]", tmpStr);
 
    strcpy(tmpStr, "Index L1C product [0,0,0]\n");
    strcat(tmpStr, "        0: pc\n");
    strcat(tmpStr, "        1: vsf\n");
     strcat(tmpStr, "       2: dpr\n");
    clo_addOption(list, "ix_l1cprod", CLO_TYPE_INT, "[0,0,0]", tmpStr);
 
    strcpy(tmpStr, "Day of the year for processing L1C swath\n");
    strcat(tmpStr, "           units in day number (1-365/366)\n");
    clo_addOption(list, "selday", CLO_TYPE_INT, "-1", tmpStr);
 
    strcpy(tmpStr, "Month of the year for processing L1C swath\n");
    strcat(tmpStr, "           units in month number (1-12)\n");
    clo_addOption(list, "selmon", CLO_TYPE_INT, "-1", tmpStr);
 
    strcpy(tmpStr, "Year for processing L1C swath\n");
    strcat(tmpStr, "           units in year\n");
    clo_addOption(list, "selyear", CLO_TYPE_INT, "-1", tmpStr);
 
    strcpy(tmpStr, "Swath id\n");
    strcat(tmpStr, "           units in swath number\n");
    clo_addOption(list, "swtnum", CLO_TYPE_INT, "1", tmpStr);
//******************************************************************
    strcpy(tmpStr, "Common grid resolution\n");
    strcat(tmpStr, "           units in km\n");
    clo_addOption(list, "gres", CLO_TYPE_FLOAT, "5.2", tmpStr);
 
    strcpy(tmpStr, "Common grid across bins\n");
    strcat(tmpStr, "     OCI: 514, SPEXone: 40, HARP: 600\n");
    clo_addOption(list, "nbinx", CLO_TYPE_INT, "514", tmpStr);
 
    strcpy(tmpStr, "PACE sensor to be gridded\n");
    strcat(tmpStr, "     SPEXone: 1, OCI: 2, HARP: 3\n");
    clo_addOption(list, "sensor", CLO_TYPE_INT, "514", tmpStr);
 
    strcpy(tmpStr, "file index L1A--HKT\n");
    strcat(tmpStr, "    0-unlimited\n");
    clo_addOption(list, "fileix", CLO_TYPE_INT, "0", tmpStr);
 
    strcpy(tmpStr, "granule size for telemetry-derived L1C files\n");
    strcat(tmpStr, "    in minutes--5' by default\n");
    clo_addOption(list, "gransize", CLO_TYPE_INT, "0", tmpStr);
 
    strcpy(tmpStr, "Projection type\n");
    strcat(tmpStr,  "      0: SOCEA\n");
    strcat(tmpStr,  "      1: SOCEA-2\n");
    clo_addOption(list, "l1c_proj", CLO_TYPE_INT, "0", tmpStr);
 
    strcpy(tmpStr, "Terrain correct flag\n");
    strcat(tmpStr, "        DEM correction\n");
    strcat(tmpStr, "        0: off\n");
    strcat(tmpStr, "        1: on\n");
    clo_addOption(list, "terrain_correct", CLO_TYPE_INT, "0", tmpStr);
 
    strcpy(tmpStr, "Cloud correct flag\n");
    strcat(tmpStr, "        Cloud height correction\n");
    strcat(tmpStr, "        0: off\n");
    strcat(tmpStr, "        1: on\n");
    clo_addOption(list, "cloud_correct", CLO_TYPE_INT, "0", tmpStr);
 
    strcpy(tmpStr, "overlap views flag\n");
    strcat(tmpStr, "        0: off\n");
    strcat(tmpStr, "        1: on\n");
    clo_addOption(list, "overlap_vflag", CLO_TYPE_INT, "0", tmpStr);
 
    strcpy(tmpStr, "overlap polarizations flag\n");
    strcat(tmpStr, "        0: off\n");
    strcat(tmpStr, "        1: on\n");
    clo_addOption(list, "overlap_pflag", CLO_TYPE_INT, "0", tmpStr);
 
    strcpy(tmpStr, "overlap spectral bands flag\n");
    strcat(tmpStr, "        0: off\n");
    strcat(tmpStr, "        1: on\n");
    clo_addOption(list, "overlap_bflag", CLO_TYPE_INT, "0", tmpStr);
 
 
    strcpy(tmpStr, "Uncertainty calculation method\n");
    strcat(tmpStr, "        0: error propagation\n");
    strcat(tmpStr, "        1: Monte Carlo\n");
    clo_addOption(list, "unc_meth", CLO_TYPE_INT, "0", tmpStr);
 
    strcpy(tmpStr, "Uncertainty threshold for angular merged product\n");
    strcat(tmpStr, "        as percentage\n");
    clo_addOption(list, "unc_thres_v", CLO_TYPE_FLOAT, "10", tmpStr);
 
    strcpy(tmpStr, "Uncertainty threshold for polarization  merged product\n");
    strcat(tmpStr, "        as percentage\n");
    clo_addOption(list, "unc_thres_p", CLO_TYPE_FLOAT, "10", tmpStr);
 
    strcpy(tmpStr, "Uncertainty threshold for spectral bands  merged product\n");
    strcat(tmpStr, "        as percentage\n");
    clo_addOption(list, "unc_thres_b", CLO_TYPE_FLOAT, "10", tmpStr);
 
   //*************************************************************************-
 
                                                                
    clo_setVersion(version);
    return 0;
}
 
 
//copy input info from list into instr structure
int32_t L1C_input::l1c_load_input(clo_optionList_t* list,L1C_input *l1ccli) {
    char *tmp_str;
    char keyword[50];
    char *parm_str;
    char tmp_file[FILENAME_MAX];
    int numOptions, optionId;
    clo_option_t *option;
//    L1C_input *l1ccli;
    int *iArray;
    int count=-1;
 
    numOptions = clo_getNumOptions(list);
    for (optionId = 0; optionId < numOptions; optionId++) {
        option = clo_getOption(list, optionId);
 
        // ignore options of type CLO_TYPE_HELP
        if (option->dataType == CLO_TYPE_HELP)
            continue;
 
        strcpy(keyword, option->key);
 
        /* change keyword to lower case */
        tmp_str = keyword;
        while (*tmp_str != '\0') {
            if (isupper(*tmp_str)) *tmp_str = tolower(*tmp_str);
            tmp_str++;
        }
 
        if (strcmp(keyword, "help") == 0) {
        }
        else if (strcmp(keyword, "version") == 0) {
        }
        else if (strncmp(keyword, "dump_options", 12) == 0) {
        }
        else if (strncmp(keyword, "par", 3) == 0) {
        }
        else if (strcmp(keyword, "ifile") == 0) {
            if (clo_isOptionSet(option)) {
                parm_str = clo_getOptionString(option);
                parse_file_name(parm_str, tmp_file);
                strcpy(l1ccli->infile, tmp_file);
            }
        } else if (strcmp(keyword, "ofile") == 0) {
            if (clo_isOptionSet(option)) {
                parm_str = clo_getOptionString(option);
                parse_file_name(parm_str, tmp_file);
                strcpy(l1ccli->ofile, tmp_file);
            }
        } 
 
/*       else if (strcmp(keyword, "fileuse") == 0) {
            if (clo_isOptionSet(option)) {
                parm_str = clo_getOptionString(option);
                parse_file_name(parm_str, tmp_file);
                strcpy(input->fileuse, tmp_file);
            }
        } 
*/
         else if (strcmp(keyword, "sday") == 0) {
            if (clo_isOptionSet(option))
                l1ccli->sday = clo_getOptionInt(option);
 
        } else if (strcmp(keyword, "eday") == 0) {
            if (clo_isOptionSet(option))
                l1ccli->eday = clo_getOptionInt(option);
 
        } else if (strcmp(keyword, "resolution") == 0) {
            parm_str = clo_getOptionString(option);
            parse_file_name(parm_str, tmp_file);
            strcpy(l1ccli->resolve, tmp_file);
 
        } else if (strcmp(keyword, "rowgroup") == 0) {
            l1ccli->rowgroup = clo_getOptionInt(option);
 
        } 
/*
        else if (strcmp(keyword, "flaguse") == 0) {
           string flags = clo_getOptionRawString(option);
              boost::replace_all(flags, "default", DEF_FLAG);
               strcpy(input->flaguse, flags.c_str());
        }
    */   
        else if (strcmp(keyword, "l2prod") == 0) {
            parm_str = clo_getOptionRawString(option);
            strcpy(l1ccli->l2prod, parm_str);
 
        }
        
        /*
          else if (strcmp(keyword, "prodtype") == 0) {
            parm_str = clo_getOptionString(option);
            strcpy(input->prodtype, parm_str);
        }
          else if (strcmp(keyword, "pversion") == 0) {
            parm_str = clo_getOptionString(option);
            strcpy(input->pversion, parm_str);
 
        } 
        */
         else if (strcmp(keyword, "suite") == 0) {
            if (clo_isOptionSet(option)) {
                parm_str = clo_getOptionString(option);
                strcpy(l1ccli->suite, parm_str);
            }
         }
        /* 
        else if (strcmp(keyword, "latsouth") == 0) {
            input->latsouth = clo_getOptionFloat(option);
 
        } else if (strcmp(keyword, "latnorth") == 0) {
            input->latnorth = clo_getOptionFloat(option);
 
        } else if (strcmp(keyword, "lonwest") == 0) {
            input->lonwest = clo_getOptionFloat(option);
 
        } else if (strcmp(keyword, "loneast") == 0) {
            input->loneast = clo_getOptionFloat(option);
 
        } else if (strcmp(keyword, "meminfo") == 0) {
            input->meminfo = clo_getOptionInt(option);
 
        } else if (strcmp(keyword, "dcinfo") == 0) {
            input->dcinfo = clo_getOptionInt(option);
 
        } else if (strcmp(keyword, "night") == 0) {
            input->night = clo_getOptionBool(option);
 
        } 
*/
        else if (strcmp(keyword, "verbose") == 0) {
            l1ccli->verbose = clo_getOptionBool(option);
 
        } 
    /*    else if (strcmp(keyword, "minobs") == 0) {
            input->minobs = clo_getOptionFloat(option);
 
        } else if (strcmp(keyword, "deflate") == 0) {
            input->deflate = clo_getOptionInt(option);
 
        } else if (strcmp(keyword, "qual_max") == 0) {
            input->qual_max = (uint8_t) clo_getOptionInt(option);
 
        } else if (strcmp(keyword, "qual_prod") == 0) {
            if (clo_isOptionSet(option)) {
                parm_str = clo_getOptionString(option);
                parse_file_name(parm_str, tmp_file);
                strcpy(input->qual_prod, tmp_file);
            }
 
        } else if (strcmp(keyword, "composite_prod") == 0) {
            if (clo_isOptionSet(option)) {
                parm_str = clo_getOptionString(option);
                parse_file_name(parm_str, tmp_file);
                strcpy(input->composite_prod, tmp_file);
            }
        } else if (strcmp(keyword, "composite_scheme") == 0) {
            if (clo_isOptionSet(option)) {
                parm_str = clo_getOptionString(option);
                parse_file_name(parm_str, tmp_file);
                strcpy(input->composite_scheme, tmp_file);
            }
        } else if (strcmp(keyword, "area_weighting") == 0) {
            if (clo_isOptionSet(option)) {
                input->area_weighting = clo_getOptionInt(option);
            } else {
                input->area_weighting = 0;                
            }
        } 
   */
      //L1C new options-----------------------------------------  
       else if (strcmp(keyword, "l1c_pflag") == 0) {
            l1ccli->l1c_pflag = clo_getOptionInt(option);
        }
       else if (strcmp(keyword, "binlatmin") == 0) {
            l1ccli->binlatmin = clo_getOptionFloat(option);
        }
       else if (strcmp(keyword, "binlatmax") == 0) {
            l1ccli->binlatmax = clo_getOptionFloat(option);
        }
       else if (strcmp(keyword, "binlonmin") == 0) {
            l1ccli->binlonmin = clo_getOptionFloat(option);
        }
       else if (strcmp(keyword, "binlonmax") == 0) {
            l1ccli->binlonmax = clo_getOptionFloat(option);
        }
       else if (strcmp(keyword, "selgran") == 0) {
            iArray = clo_getOptionInts(option, &count);
            if (count<=10){
              for (int i = 0; i < count; i++){
                 if(iArray[i]<=10)  l1ccli->selgran[i] = iArray[i];
                 else{  printf("-E- %s: Granule Id cant be larger than 10.\n", __FILE__);exit(1);}
                }  
               }                
            else{ printf("-E- %s: Max number of granules to be processed is 10.\n", __FILE__);exit(1);}
        }
       else if (strcmp(keyword, "ix_l1cprod") == 0) {
            iArray = clo_getOptionInts(option, &count);
            for (int i = 0; i < count; i++)
                l1ccli->ix_l1cprod[i] = iArray[i];
        }
 
        else if (strcmp(keyword, "gres") == 0) {
            l1ccli->gres = clo_getOptionFloat(option);
        }
         else if (strcmp(keyword, "nbinx") == 0) {
            l1ccli->nbinx = clo_getOptionInt(option);
        }
        else if (strcmp(keyword, "fileix") == 0) {
            l1ccli->fileix = clo_getOptionInt(option);
        } 
        else if (strcmp(keyword, "sensor") == 0) {
            l1ccli->sensor = clo_getOptionInt(option);
        } 
        else if (strcmp(keyword, "gransize") == 0) {
            l1ccli->gransize = clo_getOptionInt(option);
        }
 
        else if (strcmp(keyword, "selday") == 0) {
            l1ccli->selday = clo_getOptionInt(option);
        }
        else if (strcmp(keyword, "selmon") == 0) {
            l1ccli->selmon = clo_getOptionInt(option);
        }
       else if (strcmp(keyword, "selyear") == 0) {
            l1ccli->selyear = clo_getOptionInt(option);
        }
       else if (strcmp(keyword, "swtnum") == 0) {
            l1ccli->swtnum = clo_getOptionInt(option);
        }
 
        else if (strcmp(keyword, "l1c_proj") == 0) {
            l1ccli->l1c_proj = clo_getOptionInt(option);
        }
        else if (strcmp(keyword, "terrain_correct") == 0) {
            l1ccli->terrain_correct = clo_getOptionInt(option);
        }
        else if (strcmp(keyword, "cloud_correct") == 0) {
            l1ccli->cloud_correct = clo_getOptionInt(option);
        }
        else if (strcmp(keyword, "overlap_vflag") == 0) {
            l1ccli->overlap_vflag = clo_getOptionInt(option);
        }
        else if (strcmp(keyword, "overlap_pflag") == 0) {
            l1ccli->overlap_pflag = clo_getOptionInt(option);
        }
        else if (strcmp(keyword, "overlap_bflag") == 0) {
            l1ccli->overlap_bflag = clo_getOptionInt(option);
        }
        else if (strcmp(keyword, "unc_meth") == 0) {
            l1ccli->unc_meth = clo_getOptionInt(option);
        }
        else if (strcmp(keyword, "unc_thres_v") == 0) {
            l1ccli->unc_thres_v = clo_getOptionFloat(option);
        }
        else if (strcmp(keyword, "unc_thres_p") == 0) {
            l1ccli->unc_thres_p = clo_getOptionFloat(option);
        }
        else if (strcmp(keyword, "unc_thres_b") == 0) {
            l1ccli->unc_thres_b = clo_getOptionFloat(option);
        }
        else {
            printf("-E- Invalid argument \"%s\"\n", keyword);
            clo_dumpOption(option);
            exit(1);
        }
 
    }//end for
 
    return 0;
 
// delete l1ccli;
 
 
 
 
}
 
 
 
//it is called by l1c_input method
//init defaults, makes sense?
int32_t L1C_input::l1c_input_init(L1C_input *l1ccli) {
  //  L1C_input *l1ccli; 
 
    l1ccli->infile[0] = '\0';
    l1ccli->ofile[0] = '\0';
//    l1ccli->pfile[0] = '\0';
 
//    input_str->fileuse[0] = '\0';
//    input_str->qual_prod[0] = '\0';
//    input_str->composite_prod[0] = '\0';
//    input_str->composite_scheme[0] = '\0';
 
//    strcpy(input_str->pversion, "Unspecified");
//    strcpy(input_str->prodtype, "day");
 
//    strcpy(l1ccli->l3bprod, "ALL");
 
    l1ccli->sday = 1970001;
    l1ccli->eday = 2038018;
 
    l1ccli->resolve[0] = '\0';
 
    l1ccli->rowgroup = -1;
 
//    input_str->night = 0;
    l1ccli->verbose = 0;
//    input_str->minobs = 0;
 
//    input_str->meminfo = 0;
//    input_str->dcinfo = 0;
 
//    input_str->latsouth = -90.0;
//    input_str->latnorth = +90.0;
//    input_str->lonwest = 0.0;
//    input_str->loneast = 0.0;
 
//    input_str->qual_max = 255;
 
//    l1ccli->deflate = 0;
 
     strcpy(l1ccli->suite, "");
     strcpy(l1ccli->l2prod, "");
    
//    l1ccli->area_weighting = 0;
     //l1c additional input parameters--
 
    //all_l1cprod[MAXPRODl1c][50]={"","",""};//string length rather than number of strings
    for (int i=0;i<3;i++) {
        l1ccli->ix_l1cprod[i]=0;
    } //3x1 array with selected l1c products, 1: selected
    l1ccli->l1c_pflag=0;//l1c processing flag, 0: no, 1: yes
    l1ccli->binlatmin=-90;//latitude in degrees
    l1ccli->binlatmax=90;
    l1ccli->binlonmin=-180;
    l1ccli->binlonmax=180;
 
    for (int i=0;i<10;i++) {
    l1ccli->selgran[i]=-1;//first file of the list
    }
    l1ccli->swtnum=1;
    l1ccli->gres=5.2;//grid resolution in km
    l1ccli->nbinx=514;
    l1ccli->sensor=2;//1 SPEX, 2 OCI and 3 HARP
    l1ccli->fileix=0;
    l1ccli->gransize=5;//in minutes
    l1ccli->selyear=-1;
    l1ccli->selmon=-1;
    l1ccli->selday=-1;
    l1ccli->lat0=0.0;//reference latitude pole rotation SOCEA
    l1ccli->l1c_proj=-1;//projection type,"swath_grid":0 or "socea=1"
    l1ccli->terrain_correct=0;//terrain distortion correction , 1: yes 
    l1ccli->cloud_correct=0;//cloud distortion correction , 1: yes 
    //multi  attributes (view, pol, bands) 
    l1ccli->overlap_vflag=0;//tells if we want merged views
    l1ccli->overlap_pflag=0;//tells if we want merged polarizations
    l1ccli->overlap_bflag=0;//tells if we want merged spectral bands
    //uncertainty params l1c merged products
    l1ccli->unc_meth=0;//uncertainity calculation method
    l1ccli->unc_thres_v=-999.0; //uncertainity threshold of angular merged products as %
    l1ccli->unc_thres_p=-999.0;//same but for polarization
    l1ccli->unc_thres_b=-999.0;//same but for multispectral products, same view and polarization
  
  return 0;
}
 
 
 
/*-----------------------------------------------------------------------------
    Function:  l1c_input
 
    Returns:   int (status)
        The return code is a negative value if any error occurs, otherwise,
        returns 0.
 
    Description:
        Convert the arguments from the command line into a structure input
        variable.
 
    Parameters: (in calling order)
        Type      Name         I/O   Description
        ----      ----         ---   -----------
        int       argc          I   number of arguments
        char      **argv        I   list of arguments
        instr     input         O   structure variable for inputs
 
----------------------------------------------------------------------------*/
 
int32_t L1C_input::l1c_inputmain(int argc, char **argv, L1C_input *l1cinput,l1c_filehandle *l1cfile,const char* prog, const char* version) {
 
//    char str_buf[4096];
    char *dataRoot;
 //   int sensorId;
//    int subsensorId = -1;
//    char localSuite[FILENAME_MAX];
    char localIfile[FILENAME_MAX];
    char *ifile;
    string ifile_str;
 
 
    /* hold all of the command line options */
    clo_optionList_t* list;
 
    list = clo_createList();
 
    /* initialize the option list with descriptions and default values */
    l1c_init_options(list, prog, version);
 
    if (argc == 1) {
        clo_printUsage(list);
        exit(1);
    }
   
    // disable the dump option until we have read all of the files
    clo_setEnableDumpOptions(0);
    clo_readArgs(list, argc, argv);
 
   if (l1c_input_init(l1cinput) != 0) {
        printf("-E- %s: Error initializing l1c input structure.\n", __FILE__);
        return (-1);
    }
 
 
 
    // get list of input files
    strcpy(localIfile, clo_getString(list, "ifile"));
    l1cinput->files = ncfiles(localIfile); //files stored in a vector container in input struc
    if (l1cinput->files.size() == 0) {
        printf("No NetCDF input files found in %s.\n", localIfile);
        exit(EXIT_FAILURE);
    }
 
    cout<<"l1cinput->files[0].."<<l1cinput->files[0]<<endl;
 
    ifile_str = l1cinput->files[0];
    ifile=&ifile_str[0];
 
    //strcpy(l1cfile->name,ifile_str.c_str());
 
 
    cout<<"ifile.."<<ifile<<endl;
    file_format format = getFormat(ifile);//reading from a nc file ---
 
    printf("format.type....%d..",format.type);
    printf("sensor id.....%d..",format.sensor_id);
 
    //harp
 //   format.type=FT_HARP;
    l1cfile->format=format.type;
 //   format.sensor_id=34; 
 
    cout<<"sensor id.."<<format.sensor_id<<"sensor name.."<<sensorId2SensorName(format.sensor_id)<<endl;
 
   //  printf("so far so good after getformat in l2gen_read_options");
    if (format.type == FT_INVALID) {
        printf("-E- %s Line %d: Could not find type for file %s.\n", __FILE__, __LINE__, ifile);
    //    cout<<"forcing to be HARP2 when HARP2 L1B is beta from Meng/Richard"<<endl;
    //    format.type=FT_HARP2;
    //    return 0;
        return (-1);
    }
 
    if (format.sensor_id == -1) {
        printf("-E- Can not look up sensor ID for PLEASE PROVIDE PLATFORM FOR OCIS--!! %s.\n ", localIfile);
         cout<<"forcing to be HARP2 when HARP2 L1B is beta from Meng/Richard"<<endl;
    //    format.sensor_id=33;
    //    return 0;
        return (1);
    }
 
    if ((dataRoot = getenv("OCDATAROOT")) == NULL) {
        printf("OCDATAROOT environment variable is not defined.\n");
        return (1);
    }
 
 
    // re-load the command line and par file
 
    clo_setEnableDumpOptions(1);
    clo_readArgs(list, argc, argv);
 
    // re-load the command line and par file
    if (want_verbose) printf("Loading command line parameters for L1C processing\n\n");   
    // load input struct with command line arguments
    if (l1c_load_input(list,l1cinput) != 0) {
        printf("-E- %s: Error loading options into input structure.\n", __FILE__);
        return (-1);
    }
 
    
    
    //metadata off for now
    
    
    /*                                                                  */
    /* Build string of parameters for metadata                          */
    /*
    
    sprintf(str_buf, "infile = %s\n", input->infile);
    strcat(input->parms, str_buf);
    sprintf(str_buf, "ofile = %s\n", input->ofile);
    strcat(input->parms, str_buf);
    sprintf(str_buf, "fileuse = %s\n", input->fileuse);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "sday = %d\n", input->sday);
    strcat(input->parms, str_buf);
    sprintf(str_buf, "eday = %d\n", input->eday);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "latnorth = %f\n", input->latnorth);
    strcat(input->parms, str_buf);
    sprintf(str_buf, "latsouth = %f\n", input->latsouth);
    strcat(input->parms, str_buf);
    sprintf(str_buf, "loneast = %f\n", input->loneast);
    strcat(input->parms, str_buf);
    sprintf(str_buf, "lonwest = %f\n", input->lonwest);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "resolve = %s\n", input->resolve);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "rowgroup = %d\n", input->rowgroup);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "flaguse = %s\n", input->flaguse);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "l3bprod = %s\n", input->l3bprod);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "prodtype = %s\n", input->prodtype);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "pversion = %s\n", input->pversion);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "suite = %s\n", input->suite);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "night = %d\n", input->night);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "verbose = %d\n", input->verbose);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "minobs = %d\n", input->minobs);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "deflate = %d\n", input->deflate);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "qual_prod = %s\n", input->qual_prod);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "composite_prod = %s\n", input->composite_prod);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "composite_scheme = %s\n", input->composite_scheme);
    strcat(input->parms, str_buf);
 
    sprintf(str_buf, "qual_max = %d\n", input->qual_max);
    strcat(input->parms, str_buf);
 
    strcat(input->parms, str_buf);
     
     */
     
//   delete l1ccli;
    clo_deleteList(list);
 
    return 0;
}
 
}//close namespace