/* *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=* */ /* ** Copyright UCAR */ /* ** University Corporation for Atmospheric Research (UCAR) */ /* ** National Center for Atmospheric Research (NCAR) */ /* ** Boulder, Colorado, USA */ /* ** BSD licence applies - redistribution and use in source and binary */ /* ** forms, with or without modification, are permitted provided that */ /* ** the following conditions are met: */ /* ** 1) If the software is modified to produce derivative works, */ /* ** such modified software should be clearly marked, so as not */ /* ** to confuse it with the version available from UCAR. */ /* ** 2) Redistributions of source code must retain the above copyright */ /* ** notice, this list of conditions and the following disclaimer. */ /* ** 3) Redistributions in binary form must reproduce the above copyright */ /* ** notice, this list of conditions and the following disclaimer in the */ /* ** documentation and/or other materials provided with the distribution. */ /* ** 4) Neither the name of UCAR nor the names of its contributors, */ /* ** if any, may be used to endorse or promote products derived from */ /* ** this software without specific prior written permission. */ /* ** DISCLAIMER: THIS SOFTWARE IS PROVIDED 'AS IS' AND WITHOUT ANY EXPRESS */ /* ** OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */ /* ** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ /* *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=* */ //////////////////////////////////////////// // Params.cc // // TDRP C++ code file for class 'Params'. // // Code for program MdvtoGrib2 // // This file has been automatically // generated by TDRP, do not modify. // ///////////////////////////////////////////// /** * * @file Params.cc * * @class Params * * This class is automatically generated by the Table * Driven Runtime Parameters (TDRP) system * * @note Source is automatically generated from * paramdef file at compile time, do not modify * since modifications will be overwritten. * * * @author Automatically generated * */ #include "Params.hh" #include //////////////////////////////////////////// // Default constructor // Params::Params() { // zero out table memset(_table, 0, sizeof(_table)); // zero out members memset(&_start_, 0, &_end_ - &_start_); // class name _className = "Params"; // initialize table _init(); // set members tdrpTable2User(_table, &_start_); _exitDeferred = false; } //////////////////////////////////////////// // Copy constructor // Params::Params(const Params& source) { // sync the source object source.sync(); // zero out table memset(_table, 0, sizeof(_table)); // zero out members memset(&_start_, 0, &_end_ - &_start_); // class name _className = "Params"; // copy table tdrpCopyTable((TDRPtable *) source._table, _table); // set members tdrpTable2User(_table, &_start_); _exitDeferred = false; } //////////////////////////////////////////// // Destructor // Params::~Params() { // free up freeAll(); } //////////////////////////////////////////// // Assignment // void Params::operator=(const Params& other) { // sync the other object other.sync(); // free up any existing memory freeAll(); // zero out table memset(_table, 0, sizeof(_table)); // zero out members memset(&_start_, 0, &_end_ - &_start_); // copy table tdrpCopyTable((TDRPtable *) other._table, _table); // set members tdrpTable2User(_table, &_start_); _exitDeferred = other._exitDeferred; } //////////////////////////////////////////// // loadFromArgs() // // Loads up TDRP using the command line args. // // Check usage() for command line actions associated with // this function. // // argc, argv: command line args // // char **override_list: A null-terminated list of overrides // to the parameter file. // An override string has exactly the format of an entry // in the parameter file itself. // // char **params_path_p: // If this is non-NULL, it is set to point to the path // of the params file used. // // bool defer_exit: normally, if the command args contain a // print or check request, this function will call exit(). // If defer_exit is set, such an exit is deferred and the // private member _exitDeferred is set. // Use exidDeferred() to test this flag. // // Returns 0 on success, -1 on failure. // int Params::loadFromArgs(int argc, char **argv, char **override_list, char **params_path_p, bool defer_exit) { int exit_deferred; if (_tdrpLoadFromArgs(argc, argv, _table, &_start_, override_list, params_path_p, _className, defer_exit, &exit_deferred)) { return (-1); } else { if (exit_deferred) { _exitDeferred = true; } return (0); } } //////////////////////////////////////////// // loadApplyArgs() // // Loads up TDRP using the params path passed in, and applies // the command line args for printing and checking. // // Check usage() for command line actions associated with // this function. // // const char *param_file_path: the parameter file to be read in // // argc, argv: command line args // // char **override_list: A null-terminated list of overrides // to the parameter file. // An override string has exactly the format of an entry // in the parameter file itself. // // bool defer_exit: normally, if the command args contain a // print or check request, this function will call exit(). // If defer_exit is set, such an exit is deferred and the // private member _exitDeferred is set. // Use exidDeferred() to test this flag. // // Returns 0 on success, -1 on failure. // int Params::loadApplyArgs(const char *params_path, int argc, char **argv, char **override_list, bool defer_exit) { int exit_deferred; if (tdrpLoadApplyArgs(params_path, argc, argv, _table, &_start_, override_list, _className, defer_exit, &exit_deferred)) { return (-1); } else { if (exit_deferred) { _exitDeferred = true; } return (0); } } //////////////////////////////////////////// // isArgValid() // // Check if a command line arg is a valid TDRP arg. // bool Params::isArgValid(const char *arg) { return (tdrpIsArgValid(arg)); } //////////////////////////////////////////// // load() // // Loads up TDRP for a given class. // // This version of load gives the programmer the option to load // up more than one class for a single application. It is a // lower-level routine than loadFromArgs, and hence more // flexible, but the programmer must do more work. // // const char *param_file_path: the parameter file to be read in. // // char **override_list: A null-terminated list of overrides // to the parameter file. // An override string has exactly the format of an entry // in the parameter file itself. // // expand_env: flag to control environment variable // expansion during tokenization. // If TRUE, environment expansion is set on. // If FALSE, environment expansion is set off. // // Returns 0 on success, -1 on failure. // int Params::load(const char *param_file_path, char **override_list, int expand_env, int debug) { if (tdrpLoad(param_file_path, _table, &_start_, override_list, expand_env, debug)) { return (-1); } else { return (0); } } //////////////////////////////////////////// // loadFromBuf() // // Loads up TDRP for a given class. // // This version of load gives the programmer the option to // load up more than one module for a single application, // using buffers which have been read from a specified source. // // const char *param_source_str: a string which describes the // source of the parameter information. It is used for // error reporting only. // // char **override_list: A null-terminated list of overrides // to the parameter file. // An override string has exactly the format of an entry // in the parameter file itself. // // const char *inbuf: the input buffer // // int inlen: length of the input buffer // // int start_line_num: the line number in the source which // corresponds to the start of the buffer. // // expand_env: flag to control environment variable // expansion during tokenization. // If TRUE, environment expansion is set on. // If FALSE, environment expansion is set off. // // Returns 0 on success, -1 on failure. // int Params::loadFromBuf(const char *param_source_str, char **override_list, const char *inbuf, int inlen, int start_line_num, int expand_env, int debug) { if (tdrpLoadFromBuf(param_source_str, _table, &_start_, override_list, inbuf, inlen, start_line_num, expand_env, debug)) { return (-1); } else { return (0); } } //////////////////////////////////////////// // loadDefaults() // // Loads up default params for a given class. // // See load() for more detailed info. // // Returns 0 on success, -1 on failure. // int Params::loadDefaults(int expand_env) { if (tdrpLoad(NULL, _table, &_start_, NULL, expand_env, FALSE)) { return (-1); } else { return (0); } } //////////////////////////////////////////// // sync() // // Syncs the user struct data back into the parameter table, // in preparation for printing. // // This function alters the table in a consistent manner. // Therefore it can be regarded as const. // void Params::sync(void) const { tdrpUser2Table(_table, (char *) &_start_); } //////////////////////////////////////////// // print() // // Print params file // // The modes supported are: // // PRINT_SHORT: main comments only, no help or descriptions // structs and arrays on a single line // PRINT_NORM: short + descriptions and help // PRINT_LONG: norm + arrays and structs expanded // PRINT_VERBOSE: long + private params included // void Params::print(FILE *out, tdrp_print_mode_t mode) { tdrpPrint(out, _table, _className, mode); } //////////////////////////////////////////// // checkAllSet() // // Return TRUE if all set, FALSE if not. // // If out is non-NULL, prints out warning messages for those // parameters which are not set. // int Params::checkAllSet(FILE *out) { return (tdrpCheckAllSet(out, _table, &_start_)); } ////////////////////////////////////////////////////////////// // checkIsSet() // // Return TRUE if parameter is set, FALSE if not. // // int Params::checkIsSet(const char *paramName) { return (tdrpCheckIsSet(paramName, _table, &_start_)); } //////////////////////////////////////////// // freeAll() // // Frees up all TDRP dynamic memory. // void Params::freeAll(void) { tdrpFreeAll(_table, &_start_); } //////////////////////////////////////////// // usage() // // Prints out usage message for TDRP args as passed // in to loadFromArgs(). // void Params::usage(ostream &out) { out << "TDRP args: [options as below]\n" << " [ -params/--params path ] specify params file path\n" << " [ -check_params/--check_params] check which params are not set\n" << " [ -print_params/--print_params [mode]] print parameters\n" << " using following modes, default mode is 'norm'\n" << " short: main comments only, no help or descr\n" << " structs and arrays on a single line\n" << " norm: short + descriptions and help\n" << " long: norm + arrays and structs expanded\n" << " verbose: long + private params included\n" << " short_expand: short with env vars expanded\n" << " norm_expand: norm with env vars expanded\n" << " long_expand: long with env vars expanded\n" << " verbose_expand: verbose with env vars expanded\n" << " [ -tdrp_debug] debugging prints for tdrp\n" << " [ -tdrp_usage] print this usage\n"; } //////////////////////////////////////////// // arrayRealloc() // // Realloc 1D array. // // If size is increased, the values from the last array // entry is copied into the new space. // // Returns 0 on success, -1 on error. // int Params::arrayRealloc(const char *param_name, int new_array_n) { if (tdrpArrayRealloc(_table, &_start_, param_name, new_array_n)) { return (-1); } else { return (0); } } //////////////////////////////////////////// // array2DRealloc() // // Realloc 2D array. // // If size is increased, the values from the last array // entry is copied into the new space. // // Returns 0 on success, -1 on error. // int Params::array2DRealloc(const char *param_name, int new_array_n1, int new_array_n2) { if (tdrpArray2DRealloc(_table, &_start_, param_name, new_array_n1, new_array_n2)) { return (-1); } else { return (0); } } //////////////////////////////////////////// // _init() // // Class table initialization function. // // void Params::_init() { TDRPtable *tt = _table; // Parameter 'debug' // ctype is 'tdrp_bool_t' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = BOOL_TYPE; tt->param_name = tdrpStrDup("debug"); tt->descr = tdrpStrDup("Debug flag"); tt->help = tdrpStrDup(""); tt->val_offset = (char *) &debug - &_start_; tt->single_val.b = pFALSE; tt++; // Parameter 'instance' // ctype is 'char*' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = STRING_TYPE; tt->param_name = tdrpStrDup("instance"); tt->descr = tdrpStrDup("Process instance"); tt->help = tdrpStrDup("Used for registration with procmap."); tt->val_offset = (char *) &instance - &_start_; tt->single_val.s = tdrpStrDup("Test"); tt++; // Parameter 'Comment 0' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = COMMENT_TYPE; tt->param_name = tdrpStrDup("Comment 0"); tt->comment_hdr = tdrpStrDup("MDV INPUT PARAMETERS"); tt->comment_text = tdrpStrDup(""); tt++; // Parameter 'trigger_mode' // ctype is '_trigger_mode_t' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = ENUM_TYPE; tt->param_name = tdrpStrDup("trigger_mode"); tt->descr = tdrpStrDup("Input triggering mode"); tt->help = tdrpStrDup("In LATEST_DATA mode, the program waits for new data from the MDV location specified by the input_url parameter.\n \nIn TIME_LIST mode, the program operates on archive data as specified with the -start and -end args and input_url parameter.\nTIME_LIST mode is automatically invoked by -start and -end options on the command line\n \nIn FILE_LIST mode, the files listed on the command line using the -f command line option are processed.\nFILE_LIST mode is automatically invoked by -f option on the command line\n"); tt->val_offset = (char *) &trigger_mode - &_start_; tt->enum_def.name = tdrpStrDup("trigger_mode_t"); tt->enum_def.nfields = 4; tt->enum_def.fields = (enum_field_t *) tdrpMalloc(tt->enum_def.nfields * sizeof(enum_field_t)); tt->enum_def.fields[0].name = tdrpStrDup("LATEST_DATA"); tt->enum_def.fields[0].val = LATEST_DATA; tt->enum_def.fields[1].name = tdrpStrDup("TIME_LIST"); tt->enum_def.fields[1].val = TIME_LIST; tt->enum_def.fields[2].name = tdrpStrDup("FILE_LIST"); tt->enum_def.fields[2].val = FILE_LIST; tt->enum_def.fields[3].name = tdrpStrDup("LATEST_DATA_FCST"); tt->enum_def.fields[3].val = LATEST_DATA_FCST; tt->single_val.e = LATEST_DATA; tt++; // Parameter 'tolerance_seconds' // ctype is 'int' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = INT_TYPE; tt->param_name = tdrpStrDup("tolerance_seconds"); tt->descr = tdrpStrDup("Time tolerance"); tt->help = tdrpStrDup("Number of seconds allowed difference between latest data time and data time when mode = LATEST_DATA or LATEST_DATA_FCST"); tt->val_offset = (char *) &tolerance_seconds - &_start_; tt->single_val.i = 0; tt++; // Parameter 'input_url' // ctype is 'char*' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = STRING_TYPE; tt->param_name = tdrpStrDup("input_url"); tt->descr = tdrpStrDup("Input URL to use when using LATEST_DATA or TIME_LIST trigger"); tt->help = tdrpStrDup(""); tt->val_offset = (char *) &input_url - &_start_; tt->single_val.s = tdrpStrDup("mdvp:://localhost::mdv/input"); tt++; // Parameter 'Comment 1' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = COMMENT_TYPE; tt->param_name = tdrpStrDup("Comment 1"); tt->comment_hdr = tdrpStrDup("GRIB2 PARAMETERS"); tt->comment_text = tdrpStrDup(""); tt++; // Parameter 'output_dir' // ctype is 'char*' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = STRING_TYPE; tt->param_name = tdrpStrDup("output_dir"); tt->descr = tdrpStrDup("Output directory"); tt->help = tdrpStrDup("Output files names are based on the input mdv file name."); tt->val_offset = (char *) &output_dir - &_start_; tt->single_val.s = tdrpStrDup("./grib2/output"); tt++; // Parameter 'create_ldatainfo' // ctype is 'tdrp_bool_t' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = BOOL_TYPE; tt->param_name = tdrpStrDup("create_ldatainfo"); tt->descr = tdrpStrDup("Create LDataInfo file"); tt->help = tdrpStrDup(""); tt->val_offset = (char *) &create_ldatainfo - &_start_; tt->single_val.b = pFALSE; tt++; // Parameter 'production_status' // ctype is 'int' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = INT_TYPE; tt->param_name = tdrpStrDup("production_status"); tt->descr = tdrpStrDup("Production status of the data"); tt->help = tdrpStrDup("\t0 - Operational products\n\t1 - Operational test products\n\t2 - Research products\n\t3 - Re-analysis products\n"); tt->val_offset = (char *) &production_status - &_start_; tt->single_val.i = 2; tt++; // Parameter 'centre_id' // ctype is 'int' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = INT_TYPE; tt->param_name = tdrpStrDup("centre_id"); tt->descr = tdrpStrDup("Originating center"); tt->help = tdrpStrDup("See http://www.nco.ncep.noaa.gov/pmb/docs/on388/table0.html\nIt is advised to use 60 - NCAR.\n\t0 - WMO Secretariat\n\t7 - NCEP\n\t8 - NWS Telecommunications Gateway\n\t9 - NWS other\n\t59 - NOAA FSL\n\t60 - NCAR\n"); tt->val_offset = (char *) ¢re_id - &_start_; tt->single_val.i = 60; tt++; // Parameter 'sub_centre_id' // ctype is 'int' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = INT_TYPE; tt->param_name = tdrpStrDup("sub_centre_id"); tt->descr = tdrpStrDup("Origination centers sub center id"); tt->help = tdrpStrDup("Each project could have their own id here."); tt->val_offset = (char *) &sub_centre_id - &_start_; tt->single_val.i = 0; tt++; // Parameter 'background_process_id' // ctype is 'int' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = INT_TYPE; tt->param_name = tdrpStrDup("background_process_id"); tt->descr = tdrpStrDup("Originating sub centers background generating process identifier."); tt->help = tdrpStrDup("Each process could have its own id here."); tt->val_offset = (char *) &background_process_id - &_start_; tt->single_val.i = 0; tt++; // Parameter 'forecast_process_id' // ctype is 'int' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = INT_TYPE; tt->param_name = tdrpStrDup("forecast_process_id"); tt->descr = tdrpStrDup("Originating sub centers forecast generating process identifier."); tt->help = tdrpStrDup("Each process could have its own id here."); tt->val_offset = (char *) &forecast_process_id - &_start_; tt->single_val.i = 0; tt++; // Parameter 'discipline_number' // ctype is 'int' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = INT_TYPE; tt->param_name = tdrpStrDup("discipline_number"); tt->descr = tdrpStrDup("Discipline type of data in this GRIB file"); tt->help = tdrpStrDup("Only one discipline type can be used per file.\nSee http://www.nco.ncep.noaa.gov/pmb/docs/grib2/grib2_table4-2.shtml\n\t0 = Meteorological data\n\t1 = Hydrological data\n\t2 = Land surface data\n\t3 = Space data\n\t10 = Oceanographic data\n"); tt->val_offset = (char *) &discipline_number - &_start_; tt->single_val.i = 0; tt++; // Parameter 'record_mode' // ctype is '_record_mode_t' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = ENUM_TYPE; tt->param_name = tdrpStrDup("record_mode"); tt->descr = tdrpStrDup("Output grib record divisions type."); tt->help = tdrpStrDup("This param defines when to create grib record divisions.\n \nSINGLE_RECORD mode, (Best) Allows program to repeat sections of the grib record whenever possible.\nRECORD_BY_FIELD mode, Creates a new grib record when ever a new field is encountered.\nRECORD_BY_PLANE mode, Creates a new grib record for each field and vertical level (esentially no repeated sections).\n"); tt->val_offset = (char *) &record_mode - &_start_; tt->enum_def.name = tdrpStrDup("record_mode_t"); tt->enum_def.nfields = 3; tt->enum_def.fields = (enum_field_t *) tdrpMalloc(tt->enum_def.nfields * sizeof(enum_field_t)); tt->enum_def.fields[0].name = tdrpStrDup("SINGLE_RECORD"); tt->enum_def.fields[0].val = SINGLE_RECORD; tt->enum_def.fields[1].name = tdrpStrDup("RECORD_BY_FIELD"); tt->enum_def.fields[1].val = RECORD_BY_FIELD; tt->enum_def.fields[2].name = tdrpStrDup("RECORD_BY_PLANE"); tt->enum_def.fields[2].val = RECORD_BY_PLANE; tt->single_val.e = SINGLE_RECORD; tt++; // Parameter 'output_fields' // ctype is '_output_field_t' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = STRUCT_TYPE; tt->param_name = tdrpStrDup("output_fields"); tt->descr = tdrpStrDup("List of fields to read from MDV and write to the GRIB2 file."); tt->help = tdrpStrDup(" \nstr\tmdv_field_name - Field name of the field in the MDV file.\n\t Used only if mdv_field_num is -1.\n \nint\tmdv_field_num - Field number of the field in the MDV file.\n\t Set to -1 to use mdv_field_name instead.\n \nint\tprocess_type - Type of generating process.\n\t 0 - Analysis\n\t 1 - Initialization\n\t 2 - Forecast\n\t 3 - Bias Corrected Forecast\n\t 4 - Ensemble Forecast\n\t 5 - Probability Forecast\n\t 6 - Forecast Error\n\t 7 - Analysis Error\n\t 8 - Observation\n \nint\tparam_category - Parameter category number.\n A parameter category and parameter number must be chosen \n for each field. All numbers are predefined and should be\n looked up on the following web pages: \n http://www.nco.ncep.noaa.gov/pmb/docs/grib2/grib2_table4-2.shtml\n \nint\tparam_number - Parameter number within parameter category.\n Should be chosen from above web pages.\n Note: Data units must be as shown on web page.\n \nint\tdata_type - \n\t 0 - Analysis or forecast.\n\t 1 - Individual ensemble forecast.\n\t 2 - Derived forecast, based on all ensemble members.\n\t 5 - Probability forecast.\n\t 6 - Percentile forecast.\n\t 7 - Analysis or forecast error.\n\t 8 - Statistically processed value over a time interval.\n\t 9 - Probability forecast over a time interval.\n\t 10 - Percentile forecast over a time interval.\n\t 11 - Individual ensemble forecast over a time interval.\n\t 12 - Derived forecast based on ensemble members over a time.\n \nint\tcompress_method - Data encoding method.\n\t 0 - Simple packing method.\n\t 41 - PNG compression.\n\t 40 - Jpeg 2000 compression.\n \nfloat floating_point_precision - Number of decimal places to store\n\t data in the Grib2 file.\n \nbool\toverride_surface_type - The program will attempt to 'determine'\n\t vertical level information from the MDV file\n\t Set this to true to override those values.\n \nint\tfirst_surface_type - The surface level bottom type.\n\t The value is still read from the Mdv file.\n\t Used only if override_surface_type is set to true.\n \nint\tsecond_surface_type - The surface level top type.\n\t The value is still read from the Mdv file.\n\t Used only if override_surface_type is set to true.\n \nint\tprod_type - Used only if data_type is 1, 2, 5, 8, 9, 11 or 12\n\t 1, 11 - Individual Ensemble Forecast type\n\t\t0 - Unperturbed High-Resolution Control Forecast\n\t\t1 - Unperturbed Low-Resolution Control Forecast\n\t\t2 - Negatively Perturbed Forecast\n\t\t3 - Positively Perturbed Forecast\n\t\t255 - None\n\t 2, 12 - Derived Ensemble Forecast type\n\t\t0 - Unweighted Mean of All Members\n\t\t1 - Weighted Mean of All Members\n\t\t2 - Standard Deviation with respect to Cluster Mean\n\t\t3 - Standard Deviation with respect to Cluster Mean, Normalized\n\t\t4 - Spread of All Members\n\t\t5 - Large Anomaly Index of All Members\n\t\t6 - Unweighted Mean of the Cluster Members\n\t 5, 9 - Probability Forecast type\n\t\t0 - Probability of event below lower limit\n\t\t1 - Probability of event above upper limit\n\t\t2 - Probability of event between upper and lower limits\n\t\t3 - Probability of event above lower limit\n\t\t4 - Probability of event below upper limit\n \nint\tnum_forecasts - Number of associated Ensemble forecasts\n\t Used only if data_type is 1, 2, 5, 9, 11 or 12\n \nint\ttime_interval_type - Used only if data_type is 8, 9, 10, 11 or 12\n\t 0 - Average\n\t 1 - Accumulation\n\t 2 - Maximum\n\t 3 - Minimum\n\t 4 - Difference (end minus beginning)\n\t 5 - Root Mean Square\n\t 6 - Standard Deviation\n\t 7 - Covariance (temporal variance)\n\t 8 - Difference (beginning minus end)\n\t 9 - Ratio\n\t 255 - None\n \nint\ttime_interval - Data time interval in seconds\n\t Used only if data_type is 8, 9, 10, 11 or 12\n \nint\tuser_data_value - Used only if data_type is 1, 5, 6, 9, 10 or 11\n\t 1, 11 - This is the perturbation number\n\t 5, 9 - This is the probability number\n\t 6, 10 - This is the percentile value (from 100 - 0)\n \nfloat lower_limit / upper_limit - Used only if data_type is 5 or 9\n\t\tThis is the lower and/or upper limit of the forecast probability\n\tdata_convert_parameter - Parameter used in data conversion:\n\t\tDATA_CONVERT_NONE - parameter not used.\n\t\tDATA_CONVERT_MULTIPLY - the MDV values are multiplied by this value before being written to the GRIB file.\n\tdata_addend - This value will be added to the data values; the default addend is 0.\n"); tt->array_offset = (char *) &_output_fields - &_start_; tt->array_n_offset = (char *) &output_fields_n - &_start_; tt->is_array = TRUE; tt->array_len_fixed = FALSE; tt->array_elem_size = sizeof(output_field_t); tt->array_n = 1; tt->struct_def.name = tdrpStrDup("output_field_t"); tt->struct_def.nfields = 21; tt->struct_def.fields = (struct_field_t *) tdrpMalloc(tt->struct_def.nfields * sizeof(struct_field_t)); tt->struct_def.fields[0].ftype = tdrpStrDup("string"); tt->struct_def.fields[0].fname = tdrpStrDup("mdv_field_name"); tt->struct_def.fields[0].ptype = STRING_TYPE; tt->struct_def.fields[0].rel_offset = (char *) &_output_fields->mdv_field_name - (char *) _output_fields; tt->struct_def.fields[1].ftype = tdrpStrDup("int"); tt->struct_def.fields[1].fname = tdrpStrDup("mdv_field_num"); tt->struct_def.fields[1].ptype = INT_TYPE; tt->struct_def.fields[1].rel_offset = (char *) &_output_fields->mdv_field_num - (char *) _output_fields; tt->struct_def.fields[2].ftype = tdrpStrDup("int"); tt->struct_def.fields[2].fname = tdrpStrDup("process_type"); tt->struct_def.fields[2].ptype = INT_TYPE; tt->struct_def.fields[2].rel_offset = (char *) &_output_fields->process_type - (char *) _output_fields; tt->struct_def.fields[3].ftype = tdrpStrDup("int"); tt->struct_def.fields[3].fname = tdrpStrDup("param_category"); tt->struct_def.fields[3].ptype = INT_TYPE; tt->struct_def.fields[3].rel_offset = (char *) &_output_fields->param_category - (char *) _output_fields; tt->struct_def.fields[4].ftype = tdrpStrDup("int"); tt->struct_def.fields[4].fname = tdrpStrDup("param_number"); tt->struct_def.fields[4].ptype = INT_TYPE; tt->struct_def.fields[4].rel_offset = (char *) &_output_fields->param_number - (char *) _output_fields; tt->struct_def.fields[5].ftype = tdrpStrDup("int"); tt->struct_def.fields[5].fname = tdrpStrDup("data_type"); tt->struct_def.fields[5].ptype = INT_TYPE; tt->struct_def.fields[5].rel_offset = (char *) &_output_fields->data_type - (char *) _output_fields; tt->struct_def.fields[6].ftype = tdrpStrDup("int"); tt->struct_def.fields[6].fname = tdrpStrDup("compress_method"); tt->struct_def.fields[6].ptype = INT_TYPE; tt->struct_def.fields[6].rel_offset = (char *) &_output_fields->compress_method - (char *) _output_fields; tt->struct_def.fields[7].ftype = tdrpStrDup("int"); tt->struct_def.fields[7].fname = tdrpStrDup("floating_point_precision"); tt->struct_def.fields[7].ptype = INT_TYPE; tt->struct_def.fields[7].rel_offset = (char *) &_output_fields->floating_point_precision - (char *) _output_fields; tt->struct_def.fields[8].ftype = tdrpStrDup("boolean"); tt->struct_def.fields[8].fname = tdrpStrDup("override_surface_type"); tt->struct_def.fields[8].ptype = BOOL_TYPE; tt->struct_def.fields[8].rel_offset = (char *) &_output_fields->override_surface_type - (char *) _output_fields; tt->struct_def.fields[9].ftype = tdrpStrDup("int"); tt->struct_def.fields[9].fname = tdrpStrDup("first_surface_type"); tt->struct_def.fields[9].ptype = INT_TYPE; tt->struct_def.fields[9].rel_offset = (char *) &_output_fields->first_surface_type - (char *) _output_fields; tt->struct_def.fields[10].ftype = tdrpStrDup("int"); tt->struct_def.fields[10].fname = tdrpStrDup("second_surface_type"); tt->struct_def.fields[10].ptype = INT_TYPE; tt->struct_def.fields[10].rel_offset = (char *) &_output_fields->second_surface_type - (char *) _output_fields; tt->struct_def.fields[11].ftype = tdrpStrDup("int"); tt->struct_def.fields[11].fname = tdrpStrDup("prod_type"); tt->struct_def.fields[11].ptype = INT_TYPE; tt->struct_def.fields[11].rel_offset = (char *) &_output_fields->prod_type - (char *) _output_fields; tt->struct_def.fields[12].ftype = tdrpStrDup("int"); tt->struct_def.fields[12].fname = tdrpStrDup("num_forecasts"); tt->struct_def.fields[12].ptype = INT_TYPE; tt->struct_def.fields[12].rel_offset = (char *) &_output_fields->num_forecasts - (char *) _output_fields; tt->struct_def.fields[13].ftype = tdrpStrDup("int"); tt->struct_def.fields[13].fname = tdrpStrDup("time_interval_type"); tt->struct_def.fields[13].ptype = INT_TYPE; tt->struct_def.fields[13].rel_offset = (char *) &_output_fields->time_interval_type - (char *) _output_fields; tt->struct_def.fields[14].ftype = tdrpStrDup("int"); tt->struct_def.fields[14].fname = tdrpStrDup("time_interval"); tt->struct_def.fields[14].ptype = INT_TYPE; tt->struct_def.fields[14].rel_offset = (char *) &_output_fields->time_interval - (char *) _output_fields; tt->struct_def.fields[15].ftype = tdrpStrDup("int"); tt->struct_def.fields[15].fname = tdrpStrDup("user_data_value"); tt->struct_def.fields[15].ptype = INT_TYPE; tt->struct_def.fields[15].rel_offset = (char *) &_output_fields->user_data_value - (char *) _output_fields; tt->struct_def.fields[16].ftype = tdrpStrDup("float"); tt->struct_def.fields[16].fname = tdrpStrDup("lower_limit"); tt->struct_def.fields[16].ptype = FLOAT_TYPE; tt->struct_def.fields[16].rel_offset = (char *) &_output_fields->lower_limit - (char *) _output_fields; tt->struct_def.fields[17].ftype = tdrpStrDup("float"); tt->struct_def.fields[17].fname = tdrpStrDup("upper_limit"); tt->struct_def.fields[17].ptype = FLOAT_TYPE; tt->struct_def.fields[17].rel_offset = (char *) &_output_fields->upper_limit - (char *) _output_fields; tt->struct_def.fields[18].ftype = tdrpStrDup("data_convert_type_t"); tt->struct_def.fields[18].fname = tdrpStrDup("data_convert_type"); tt->struct_def.fields[18].ptype = ENUM_TYPE; tt->struct_def.fields[18].rel_offset = (char *) &_output_fields->data_convert_type - (char *) _output_fields; tt->struct_def.fields[18].enum_def.name = tdrpStrDup("data_convert_type_t"); tt->struct_def.fields[18].enum_def.nfields = 2; tt->struct_def.fields[18].enum_def.fields = (enum_field_t *) tdrpMalloc (tt->struct_def.fields[18].enum_def.nfields * sizeof(enum_field_t)); tt->struct_def.fields[18].enum_def.fields[0].name = tdrpStrDup("DATA_CONVERT_NONE"); tt->struct_def.fields[18].enum_def.fields[0].val = DATA_CONVERT_NONE; tt->struct_def.fields[18].enum_def.fields[1].name = tdrpStrDup("DATA_CONVERT_MULTIPLY"); tt->struct_def.fields[18].enum_def.fields[1].val = DATA_CONVERT_MULTIPLY; tt->struct_def.fields[19].ftype = tdrpStrDup("double"); tt->struct_def.fields[19].fname = tdrpStrDup("data_convert_parameter"); tt->struct_def.fields[19].ptype = DOUBLE_TYPE; tt->struct_def.fields[19].rel_offset = (char *) &_output_fields->data_convert_parameter - (char *) _output_fields; tt->struct_def.fields[20].ftype = tdrpStrDup("double"); tt->struct_def.fields[20].fname = tdrpStrDup("data_addend"); tt->struct_def.fields[20].ptype = DOUBLE_TYPE; tt->struct_def.fields[20].rel_offset = (char *) &_output_fields->data_addend - (char *) _output_fields; tt->n_struct_vals = 21; tt->struct_vals = (tdrpVal_t *) tdrpMalloc(tt->n_struct_vals * sizeof(tdrpVal_t)); tt->struct_vals[0].s = tdrpStrDup("CloudHeight"); tt->struct_vals[1].i = -1; tt->struct_vals[2].i = 0; tt->struct_vals[3].i = 3; tt->struct_vals[4].i = 6; tt->struct_vals[5].i = 0; tt->struct_vals[6].i = 40; tt->struct_vals[7].i = 2; tt->struct_vals[8].b = pFALSE; tt->struct_vals[9].i = 0; tt->struct_vals[10].i = 0; tt->struct_vals[11].i = 0; tt->struct_vals[12].i = 0; tt->struct_vals[13].i = 0; tt->struct_vals[14].i = 0; tt->struct_vals[15].i = 0; tt->struct_vals[16].f = 0; tt->struct_vals[17].f = 0; tt->struct_vals[18].e = DATA_CONVERT_NONE; tt->struct_vals[19].d = 1; tt->struct_vals[20].d = 0; tt++; // Parameter 'remap_output' // ctype is 'tdrp_bool_t' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = BOOL_TYPE; tt->param_name = tdrpStrDup("remap_output"); tt->descr = tdrpStrDup("Flag indicating whether to remap the output fields."); tt->help = tdrpStrDup("If TRUE, the output fields will be remapped according to the information in the remap_info parameter."); tt->val_offset = (char *) &remap_output - &_start_; tt->single_val.b = pFALSE; tt++; // Parameter 'auto_remap_to_latlon' // ctype is 'tdrp_bool_t' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = BOOL_TYPE; tt->param_name = tdrpStrDup("auto_remap_to_latlon"); tt->descr = tdrpStrDup("Option to automatically remap the grid to a lat-lon projection."); tt->help = tdrpStrDup("If true, the data in the file will be remapped to a latlon grid which matches the existing grid in resolution and extent. Other remap parameters will be ignored."); tt->val_offset = (char *) &auto_remap_to_latlon - &_start_; tt->single_val.b = pFALSE; tt++; // Parameter 'remap_info' // ctype is '_remap_info_t' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = STRUCT_TYPE; tt->param_name = tdrpStrDup("remap_info"); tt->descr = tdrpStrDup("Information on how to remap the output fields. Used only if remap_output is set to TRUE."); tt->help = tdrpStrDup("\tproj_type - specifies the output projection to use. Can be either PROJ_LATLON or PROJ_LAMBERT_CONF. Currently, only PROJ_LAMBERT_CONF is supported.\n\tnx, ny - specify the output grid dimensions.\n\tminx, miny - specify the output grid location.\n\tdx, dy - specify the output grid resolution.\n\torigin_lat, origin_lon - specify the output grid origin. Used only if proj_type is set to PROJ_LAMBERT_CONF.\nlat1, lat2 - specify the output grid parameters. Used only if proj_type is set to PROJ_LAMBERT_CONF."); tt->val_offset = (char *) &remap_info - &_start_; tt->struct_def.name = tdrpStrDup("remap_info_t"); tt->struct_def.nfields = 11; tt->struct_def.fields = (struct_field_t *) tdrpMalloc(tt->struct_def.nfields * sizeof(struct_field_t)); tt->struct_def.fields[0].ftype = tdrpStrDup("proj_type_t"); tt->struct_def.fields[0].fname = tdrpStrDup("proj_type"); tt->struct_def.fields[0].ptype = ENUM_TYPE; tt->struct_def.fields[0].rel_offset = (char *) &remap_info.proj_type - (char *) &remap_info; tt->struct_def.fields[0].enum_def.name = tdrpStrDup("proj_type_t"); tt->struct_def.fields[0].enum_def.nfields = 2; tt->struct_def.fields[0].enum_def.fields = (enum_field_t *) tdrpMalloc (tt->struct_def.fields[0].enum_def.nfields * sizeof(enum_field_t)); tt->struct_def.fields[0].enum_def.fields[0].name = tdrpStrDup("PROJ_LATLON"); tt->struct_def.fields[0].enum_def.fields[0].val = PROJ_LATLON; tt->struct_def.fields[0].enum_def.fields[1].name = tdrpStrDup("PROJ_LAMBERT_CONF"); tt->struct_def.fields[0].enum_def.fields[1].val = PROJ_LAMBERT_CONF; tt->struct_def.fields[1].ftype = tdrpStrDup("long"); tt->struct_def.fields[1].fname = tdrpStrDup("nx"); tt->struct_def.fields[1].ptype = LONG_TYPE; tt->struct_def.fields[1].rel_offset = (char *) &remap_info.nx - (char *) &remap_info; tt->struct_def.fields[2].ftype = tdrpStrDup("long"); tt->struct_def.fields[2].fname = tdrpStrDup("ny"); tt->struct_def.fields[2].ptype = LONG_TYPE; tt->struct_def.fields[2].rel_offset = (char *) &remap_info.ny - (char *) &remap_info; tt->struct_def.fields[3].ftype = tdrpStrDup("double"); tt->struct_def.fields[3].fname = tdrpStrDup("minx"); tt->struct_def.fields[3].ptype = DOUBLE_TYPE; tt->struct_def.fields[3].rel_offset = (char *) &remap_info.minx - (char *) &remap_info; tt->struct_def.fields[4].ftype = tdrpStrDup("double"); tt->struct_def.fields[4].fname = tdrpStrDup("miny"); tt->struct_def.fields[4].ptype = DOUBLE_TYPE; tt->struct_def.fields[4].rel_offset = (char *) &remap_info.miny - (char *) &remap_info; tt->struct_def.fields[5].ftype = tdrpStrDup("double"); tt->struct_def.fields[5].fname = tdrpStrDup("dx"); tt->struct_def.fields[5].ptype = DOUBLE_TYPE; tt->struct_def.fields[5].rel_offset = (char *) &remap_info.dx - (char *) &remap_info; tt->struct_def.fields[6].ftype = tdrpStrDup("double"); tt->struct_def.fields[6].fname = tdrpStrDup("dy"); tt->struct_def.fields[6].ptype = DOUBLE_TYPE; tt->struct_def.fields[6].rel_offset = (char *) &remap_info.dy - (char *) &remap_info; tt->struct_def.fields[7].ftype = tdrpStrDup("double"); tt->struct_def.fields[7].fname = tdrpStrDup("origin_lat"); tt->struct_def.fields[7].ptype = DOUBLE_TYPE; tt->struct_def.fields[7].rel_offset = (char *) &remap_info.origin_lat - (char *) &remap_info; tt->struct_def.fields[8].ftype = tdrpStrDup("double"); tt->struct_def.fields[8].fname = tdrpStrDup("origin_lon"); tt->struct_def.fields[8].ptype = DOUBLE_TYPE; tt->struct_def.fields[8].rel_offset = (char *) &remap_info.origin_lon - (char *) &remap_info; tt->struct_def.fields[9].ftype = tdrpStrDup("double"); tt->struct_def.fields[9].fname = tdrpStrDup("lat1"); tt->struct_def.fields[9].ptype = DOUBLE_TYPE; tt->struct_def.fields[9].rel_offset = (char *) &remap_info.lat1 - (char *) &remap_info; tt->struct_def.fields[10].ftype = tdrpStrDup("double"); tt->struct_def.fields[10].fname = tdrpStrDup("lat2"); tt->struct_def.fields[10].ptype = DOUBLE_TYPE; tt->struct_def.fields[10].rel_offset = (char *) &remap_info.lat2 - (char *) &remap_info; tt->n_struct_vals = 11; tt->struct_vals = (tdrpVal_t *) tdrpMalloc(tt->n_struct_vals * sizeof(tdrpVal_t)); tt->struct_vals[0].e = PROJ_LAMBERT_CONF; tt->struct_vals[1].l = 301; tt->struct_vals[2].l = 225; tt->struct_vals[3].d = -3332.14; tt->struct_vals[4].d = -588.89; tt->struct_vals[5].d = 20.318; tt->struct_vals[6].d = 20.318; tt->struct_vals[7].d = 25; tt->struct_vals[8].d = -95; tt->struct_vals[9].d = 25; tt->struct_vals[10].d = 25; tt++; // Parameter 'use_horiz_limits' // ctype is 'tdrp_bool_t' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = BOOL_TYPE; tt->param_name = tdrpStrDup("use_horiz_limits"); tt->descr = tdrpStrDup("Flag indicating whether to apply horizontal limits instead of remapping the output fields using the remap_info."); tt->help = tdrpStrDup("If TRUE and Lambert Conformal projection, the output fields will be limited by the horizontal boundary (minLat/maxLat/minLon/maxLon)."); tt->val_offset = (char *) &use_horiz_limits - &_start_; tt->single_val.b = pFALSE; tt++; // Parameter 'horiz_limits' // ctype is '_horiz_limits_t' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = STRUCT_TYPE; tt->param_name = tdrpStrDup("horiz_limits"); tt->descr = tdrpStrDup("Bounding box which defines the horizontal limits of the target data.Used only if use_horiz_limits is set to TRUE."); tt->help = tdrpStrDup("\tmin_lat - specifies the minimum latitude.\n\tmax_lat - specifies the maximum latitude.\n\tmin_lon - specifies the minimum longitude.\n\tmax_lon - specifies the maximum longitude."); tt->val_offset = (char *) &horiz_limits - &_start_; tt->struct_def.name = tdrpStrDup("horiz_limits_t"); tt->struct_def.nfields = 4; tt->struct_def.fields = (struct_field_t *) tdrpMalloc(tt->struct_def.nfields * sizeof(struct_field_t)); tt->struct_def.fields[0].ftype = tdrpStrDup("double"); tt->struct_def.fields[0].fname = tdrpStrDup("min_lat"); tt->struct_def.fields[0].ptype = DOUBLE_TYPE; tt->struct_def.fields[0].rel_offset = (char *) &horiz_limits.min_lat - (char *) &horiz_limits; tt->struct_def.fields[1].ftype = tdrpStrDup("double"); tt->struct_def.fields[1].fname = tdrpStrDup("max_lat"); tt->struct_def.fields[1].ptype = DOUBLE_TYPE; tt->struct_def.fields[1].rel_offset = (char *) &horiz_limits.max_lat - (char *) &horiz_limits; tt->struct_def.fields[2].ftype = tdrpStrDup("double"); tt->struct_def.fields[2].fname = tdrpStrDup("min_lon"); tt->struct_def.fields[2].ptype = DOUBLE_TYPE; tt->struct_def.fields[2].rel_offset = (char *) &horiz_limits.min_lon - (char *) &horiz_limits; tt->struct_def.fields[3].ftype = tdrpStrDup("double"); tt->struct_def.fields[3].fname = tdrpStrDup("max_lon"); tt->struct_def.fields[3].ptype = DOUBLE_TYPE; tt->struct_def.fields[3].rel_offset = (char *) &horiz_limits.max_lon - (char *) &horiz_limits; tt->n_struct_vals = 4; tt->struct_vals = (tdrpVal_t *) tdrpMalloc(tt->n_struct_vals * sizeof(tdrpVal_t)); tt->struct_vals[0].d = -90; tt->struct_vals[1].d = 90; tt->struct_vals[2].d = -180; tt->struct_vals[3].d = 180; tt++; // Parameter 'use_iso8601_filename_convention' // ctype is 'tdrp_bool_t' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = BOOL_TYPE; tt->param_name = tdrpStrDup("use_iso8601_filename_convention"); tt->descr = tdrpStrDup("If true the output filename uses the basename, followed by ISO 8601 timestamp convention"); tt->help = tdrpStrDup("eg. basename.2008-05-22T14:00:00.grb2"); tt->val_offset = (char *) &use_iso8601_filename_convention - &_start_; tt->single_val.b = pFALSE; tt++; // Parameter 'basename' // ctype is 'char*' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = STRING_TYPE; tt->param_name = tdrpStrDup("basename"); tt->descr = tdrpStrDup("basename of grib files, used only when use_iso8601_filename_convention=TRUE"); tt->help = tdrpStrDup(""); tt->val_offset = (char *) &basename - &_start_; tt->single_val.s = tdrpStrDup("grib2"); tt++; // trailing entry has param_name set to NULL tt->param_name = NULL; return; }