From 4ba89a50cf96b07f1f0ec98f11272973e34d4195 Mon Sep 17 00:00:00 2001 From: John Halley Gotway Date: Wed, 30 Dec 2020 16:25:09 -0700 Subject: [PATCH] Per #1448, switch from tech1/tech2 to dev/ops methods. Update log messages and add lots of details to the tc_gen documentation. --- met/data/config/TCGenConfig_default | 12 +- met/docs/Users_Guide/tc-gen.rst | 77 ++++++-- met/src/basic/vx_config/config_constants.h | 2 + met/src/tools/tc_utils/tc_gen/tc_gen.cc | 171 ++++++++++++------ .../tools/tc_utils/tc_gen/tc_gen_conf_info.cc | 22 ++- .../tools/tc_utils/tc_gen/tc_gen_conf_info.h | 8 +- test/config/TCGenConfig_2016 | 12 +- 7 files changed, 218 insertions(+), 86 deletions(-) diff --git a/met/data/config/TCGenConfig_default b/met/data/config/TCGenConfig_default index 1fcd647212..30fbd35460 100644 --- a/met/data/config/TCGenConfig_default +++ b/met/data/config/TCGenConfig_default @@ -161,6 +161,12 @@ genesis_init_diff = 48; // //////////////////////////////////////////////////////////////////////////////// +// +// Scoring methods to be applied +// +dev_method_flag = TRUE; +ops_method_flag = TRUE; + // // Confidence interval alpha value // @@ -170,9 +176,9 @@ ci_alpha = 0.05; // Statistical output types // output_flag = { - fho = NONE; - ctc = BOTH; - cts = BOTH; + fho = NONE; + ctc = BOTH; + cts = BOTH; } // diff --git a/met/docs/Users_Guide/tc-gen.rst b/met/docs/Users_Guide/tc-gen.rst index 33b2dd4099..6786d43121 100644 --- a/met/docs/Users_Guide/tc-gen.rst +++ b/met/docs/Users_Guide/tc-gen.rst @@ -11,7 +11,7 @@ The TC-Gen tool provides verification of tropical cyclone genesis forecasts in A Statistical aspects ___________________ -The TC-Gen tool populates a contingency table with hits, misses, and false alarms. As with other extreme events (where the event occurs much less frequently than the non-event), the correct negative category is not computed the non-events would dominate the contingency table. Therefore, only statistics that do not include correct negatives should be considered for this tool. The following CTS statistics are relevant: Base rate (BASER), Mean forecast (FMEAN), Frequency Bias (FBIAS), Probability of Detection (PODY), False Alarm Ratio (FAR), Critical Success Index (CSI), Gilbert Skill Score (GSS), Extreme Dependency Score (EDS), Symmetric Extreme Dependency Score (SEDS), Bias Adjusted Gilbert Skill Score (BAGSS). +The TC-Gen tool populates a contingency tables with hits, misses, and false alarms. As with other extreme events (where the event occurs much less frequently than the non-event), the correct negative category is not computed the non-events would dominate the contingency table. Therefore, only statistics that do not include correct negatives should be considered for this tool. The following CTS statistics are relevant: Base rate (BASER), Mean forecast (FMEAN), Frequency Bias (FBIAS), Probability of Detection (PODY), False Alarm Ratio (FAR), Critical Success Index (CSI), Gilbert Skill Score (GSS), Extreme Dependency Score (EDS), Symmetric Extreme Dependency Score (SEDS), Bias Adjusted Gilbert Skill Score (BAGSS). Other considerations for interpreting the output of the TC-Gen tool involve the size of the contingency table output. The size of the contingency table will change depending on the number of matches. Additionally, the number of misses is based on the forecast duration and interval (specified in the configuration file). This change is due to the number of model opportunities to forecast the event, which is determined by the specified duration/interval. @@ -59,19 +59,33 @@ Optional arguments for tc_gen The TC-Gen tool implements the following logic: -* Parse the genesis data and identify forecast genesis events separately for each model present. +* Parse the forecast genesis data and identify forecast genesis events separately for each model present. -* Parse the BEST and operational track data and identify observed genesis events. +* Parse the BEST and operational track data, and identify BEST track genesis events. * Loop over the filters defined in the configuration file and apply the following logic for each. - * For each forecast genesis event, search the BEST genesis events for a match that is close enough in time and space. If not found, search the operational genesis events for a match. If a match is found, classify the forecast genesis event as a **hit**. Otherwise, classify it as a **false alarm**. + * For each BEST track genesis event meeting the filter critera, determine the initialization and lead times for which the model had an opportunity to forecast that genesis event. Store an unmatched genesis pair for each case. + + * For each forecast genesis event, search for a matching BEST track. A BEST track matches if the valid time of one of its track points matches the forecast genesis time and is within a configurable radius of the forecast genesis location. If a BEST track match is found, store the storm ID. + + * In no BEST track match is found, apply the same logic to search the 0-hour operational track points. If an operational match is found, store the storm ID. + + * If a matching storm ID is found, match the forecast genesis event to the BEST track genesis event for that storm ID. + + * If no matching storm ID is found, store an unmatched pair for the genesis forecast. - * For each BEST track genesis event, determine the initialization and lead times for which the model had an opportunity to forecast that genesis event. If the model opportunity is not classified in the previous step, then classify as a **miss**. + * Loop through the genesis pairs and populate contingency tables using two methods, the developement (dev) and operational (ops) methods. For each pair, if the forecast genesis event is unmatched, score it as a dev and ops FALSE ALARM. If the BEST track genesis event is unmatched, score it as a dev and ops MISS. Score each matched genesis pair as follows: - * Do not count any correct negatives. + * If the forecast initialization time is at or after the BEST track genesis event, DISCARD this case and exclude it from the statistics. + + * Compute the difference between the forecast and BEST track genesis events in time and space. If they are both within the configurable tolerance, score it as a dev HIT. If not, score it as a dev FALSE ALARM. + + * Compute the difference between the BEST track genesis time and model initialization time. If it is within the configurable tolerance, score it as an ops HIT. If not, score it as an ops FALSE ALARM. -* Report the contingency table hits, misses, and false alarms separately for each forecast model and configuration file filter. + * Do not count any CORRECT NEGATIVES. + +* Report the contingency table hits, misses, and false alarms separately for each forecast model and configuration file filter. The development (dev) scoring method is indicated in the output as *GENESIS_DEV* while the operational (ops) scoring method is indicated as *GENESIS_OPS*. tc_gen configuration file ~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -90,6 +104,14 @@ The **init_freq** variable is an integer specifying the model initialization fre ______________________ +.. code-block:: none + + valid_freq = 6; + +The **valid_freq** variable is an integer specifying the valid time of the track points to be analyzed in hours, starting at 00Z. The default value of 6 indicates that only track points with valid times of 00Z, 06Z, 12Z, and 18Z will be checked for genesis events. Since BEST and operational tracks are typically only available at those times, a match to a forecast genesis event is only possible for those hours. + +______________________ + .. code-block:: none lead_window = { @@ -128,14 +150,16 @@ ______________________ vmax_thresh = NA; mslp_thresh = NA; } - oper_genesis = { - technique = "CARQ"; - category = [ "DB", "LO", "WV" ]; - vmax_thresh = NA; - mslp_thresh = NA; - } -The **best_genesis** and **oper_genesis** dictionaries define genesis criteria for the BEST and operational tracks, respectively. Like the **fcst_genesis** dictionary, the **vmax_thresh** and **mslp_thresh** thresholds define required genesis criteria. In addition, the **category** array defines the ATCF storm categories that should qualify as genesis events. The **technique** string defines the ATCF ID for the BEST and operational tracks. +The **best_genesis** dictionary define genesis criteria for the BEST tracks. Like the **fcst_genesis** dictionary, the **vmax_thresh** and **mslp_thresh** thresholds define required genesis criteria. In addition, the **category** array defines the ATCF storm categories that should qualify as genesis events. The **technique** string defines the ATCF ID for the BEST track. + +______________________ + +.. code-block:: none + + oper_technique = "CARQ"; + +The **oper_technique** entry is a string which defines the ATCF ID for the operational track data that should be used. For each forecast genesis event, the BEST tracks are searched for a track point valid at the time of forecast genesis and within the search radius. If no match is found, the 0-hour operational track is searched for a match. ______________________ @@ -235,6 +259,31 @@ The **genesis_radius** entry defines a search radius, in km, relative to the for ______________________ +.. code-block:: none + + genesis_init_diff = 48; + +The **gensis_init_diff** entry is an integer which defines a maximum allowable time difference in hours. This option applies only to the ops matching methodology. For each matching forecast and BEST track genesis event, if the difference between the BEST track genesis time and the forecast initialization time is less than or equal to this value, then the pair is counted as a HIT. Otherwise, it is counted as a FALSE ALARM. + +______________________ + +.. code-block:: none + + dev_method_flag = TRUE; + ops_method_flag = TRUE; + +The **dev_method_flag** and **ops_method_flag** entries are booleans which indicate whether the development and operational scoring methods should be applied and written to the output. At least one of these flags must be set to true. + +______________________ + +.. code-block:: none + + basin_file = "MET_BASE/tc_data/basin_global_tenth_degree.nc"; + +The **basin_file** entry defines the path to the NetCDF basin data file that is included with MET. When a BEST track storm moves from one basin to another, the BEST track dataset can include two tracks for the same storm, one for each basin. However, both tracks have the same genesis point. When this occurs, this basin data file is read and used to determine the basin in which genesis actually occurred. The corresponding BEST track is retained and the other is discarded. + +______________________ + .. code-block:: none ci_alpha = 0.05; diff --git a/met/src/basic/vx_config/config_constants.h b/met/src/basic/vx_config/config_constants.h index fe2af7ea4d..24956f36b0 100644 --- a/met/src/basic/vx_config/config_constants.h +++ b/met/src/basic/vx_config/config_constants.h @@ -1069,6 +1069,8 @@ static const char conf_key_mslp_thresh[] = "mslp_thresh"; static const char conf_key_genesis_window[] = "genesis_window"; static const char conf_key_genesis_radius[] = "genesis_radius"; static const char conf_key_genesis_init_diff[] = "genesis_init_diff"; +static const char conf_key_dev_method_flag[] = "dev_method_flag"; +static const char conf_key_ops_method_flag[] = "ops_method_flag"; // // TC-RMW specific parameter key names diff --git a/met/src/tools/tc_utils/tc_gen/tc_gen.cc b/met/src/tools/tc_utils/tc_gen/tc_gen.cc index b92543f4bf..e74825fd62 100644 --- a/met/src/tools/tc_utils/tc_gen/tc_gen.cc +++ b/met/src/tools/tc_utils/tc_gen/tc_gen.cc @@ -361,22 +361,22 @@ void get_genesis_pairs(int i_vx, //////////////////////////////////////////////////////////////////////// // -// Score the PairDataGenesis events: +// Score the PairDataGenesis events, using two methods: // (1) Loop over the PairDataGenesis entries. // (2) If the forecast is set but not the BEST track, increment the // FALSE ALARM counts. // (2) If the BEST track is set but not the forecast, increment the // MISS counts. // (3) If both are set, but the model initialization time is at or -// after the BEST track genesis time, discard that case. +// after the BEST track genesis time, DISCARD that case. // (4) If both are set and the genesis time and location offsets // fall within the configurable windows, increment the -// technique 1 HIT counts. Otherwise, increment the technique 1 -// FALSE ALARM counts. -// (5) If both are set and the forecast genesis time is within the -// configurable window of the BEST track genesis time, increment -// the technique 2 HIT counts. Otherwise, increment the technique 2 +// dev method HIT counts. Otherwise, increment the dev method // FALSE ALARM counts. +// (5) If both are set and the difference between to BEST track genesis +// time and the forecast initialization time is small enough, +// increment the ops method HIT counts. Otherwise, increment the +// ops method FALSE ALARM counts. // //////////////////////////////////////////////////////////////////////// @@ -413,11 +413,11 @@ void do_genesis_ctc(int i_vx, << unix_to_yyyymmdd_hhmmss(fgi->genesis_time()) << " forecast genesis at (" << fgi->lat() << ", " << fgi->lon() - << ") is a technique 1 and 2 FALSE ALARM.\n"; + << ") is a dev and ops FALSE ALARM.\n"; - // Increment the FALSE ALARM count for both techniques - gci.cts_tech1.cts.inc_fy_on(); - gci.cts_tech2.cts.inc_fy_on(); + // Increment the FALSE ALARM count for both methods + gci.cts_dev.cts.inc_fy_on(); + gci.cts_ops.cts.inc_fy_on(); } // Unmatched BEST genesis (MISS) @@ -427,11 +427,11 @@ void do_genesis_ctc(int i_vx, << unix_to_yyyymmdd_hhmmss(bgi->genesis_time()) << " BEST track " << bgi->storm_id() << " genesis at (" << bgi->lat() << ", " << bgi->lon() - << ") is a technique 1 and 2 MISS.\n"; + << ") is a dev and ops MISS.\n"; - // Increment the MISS count for both techniques - gci.cts_tech1.cts.inc_fn_oy(); - gci.cts_tech2.cts.inc_fn_oy(); + // Increment the MISS count for both methods + gci.cts_dev.cts.inc_fn_oy(); + gci.cts_ops.cts.inc_fn_oy(); } // Matched genesis pairs (DISCARD, HIT, or FALSE ALARM) @@ -464,7 +464,7 @@ void do_genesis_ctc(int i_vx, offset_cs << "with a genesis time offset of " << dsec/sec_per_hour << " hours and location offset of " << dist << " km.\n"; - // Technique 1: + // Dev Method: // HIT if forecast genesis time and location // are within the temporal and spatial windows. if(dsec >= conf_info.VxOpt[i_vx].GenesisSecBeg && @@ -472,20 +472,20 @@ void do_genesis_ctc(int i_vx, dist <= conf_info.VxOpt[i_vx].GenesisRadius) { mlog << Debug(4) << case_cs - << " is a technique 1 HIT " << offset_cs; + << " is a dev method HIT " << offset_cs; // Increment the HIT count - gci.cts_tech1.cts.inc_fy_oy(); + gci.cts_dev.cts.inc_fy_oy(); } else { mlog << Debug(4) << case_cs - << " is a technique 1 FALSE ALARM " << offset_cs; + << " is a dev method FALSE ALARM " << offset_cs; // Increment the FALSE ALARM count - gci.cts_tech1.cts.inc_fy_on(); + gci.cts_dev.cts.inc_fy_on(); } - // Technique 2: + // Ops Method: // HIT if forecast init time is close enough to // the BEST genesis time. @@ -499,35 +499,39 @@ void do_genesis_ctc(int i_vx, if(dsec <= conf_info.VxOpt[i_vx].GenesisInitDSec) { mlog << Debug(4) << case_cs - << " is a technique 2 HIT " << offset_cs; + << " is an ops method HIT " << offset_cs; // Increment the HIT count - gci.cts_tech2.cts.inc_fy_oy(); + gci.cts_ops.cts.inc_fy_oy(); } else { mlog << Debug(4) << case_cs - << " is a technique 2 FALSE ALARM " << offset_cs; + << " is an ops method FALSE ALARM " << offset_cs; // Increment the FALSE ALARM count - gci.cts_tech2.cts.inc_fy_on(); + gci.cts_ops.cts.inc_fy_on(); } } } } // end for i n_pair - mlog << Debug(3) << "For filter " << i_vx+1 << " (" - << pairs.desc() << ") " << pairs.model() - << " model, technique 1 contingency table hits = " - << gci.cts_tech1.cts.fy_oy() << ", false alarms = " - << gci.cts_tech1.cts.fy_on() << ", and misses = " - << gci.cts_tech1.cts.fn_oy() << ".\n"; + if(conf_info.DevFlag) { + mlog << Debug(3) << "For filter " << i_vx+1 << " (" + << pairs.desc() << ") " << pairs.model() + << " model, dev method contingency table hits = " + << gci.cts_dev.cts.fy_oy() << ", false alarms = " + << gci.cts_dev.cts.fy_on() << ", and misses = " + << gci.cts_dev.cts.fn_oy() << ".\n"; + } - mlog << Debug(3) << "For filter " << i_vx+1 << " (" - << pairs.desc() << ") " << pairs.model() - << " model, technique 2 contingency table hits = " - << gci.cts_tech2.cts.fy_oy() << ", false alarms = " - << gci.cts_tech2.cts.fy_on() << ", and misses = " - << gci.cts_tech2.cts.fn_oy() << ".\n"; + if(conf_info.OpsFlag) { + mlog << Debug(3) << "For filter " << i_vx+1 << " (" + << pairs.desc() << ") " << pairs.model() + << " model, ops method contingency table hits = " + << gci.cts_ops.cts.fy_oy() << ", false alarms = " + << gci.cts_ops.cts.fy_on() << ", and misses = " + << gci.cts_ops.cts.fn_oy() << ".\n"; + } return; } @@ -915,7 +919,7 @@ void process_best_tracks(const StringArray &files, //////////////////////////////////////////////////////////////////////// void setup_txt_files(int n_model) { - int i, n_rows, n_cols; + int i, n_methods, n_rows, n_cols; // Initialize file stream stat_out = (ofstream *) 0; @@ -926,8 +930,11 @@ void setup_txt_files(int n_model) { // Create the output STAT file open_txt_file(stat_out, stat_file.c_str()); + if(conf_info.DevFlag && conf_info.OpsFlag) n_methods = 2; + else n_methods = 1; + // Setup the STAT AsciiTable - n_rows = 1 + 3 * n_model * conf_info.n_vx(); + n_rows = 1 + 3 * n_methods * n_model * conf_info.n_vx(); n_cols = 1 + n_header_columns + n_cts_columns; stat_at.set_size(n_rows, n_cols); setup_table(stat_at); @@ -955,7 +962,7 @@ void setup_txt_files(int n_model) { open_txt_file(txt_out[i], txt_file[i].c_str()); // Setup the text AsciiTable - n_rows = 1 + n_model * conf_info.n_vx(); + n_rows = 1 + n_methods * n_model * conf_info.n_vx(); n_cols = 1 + n_header_columns + n_txt_columns[i]; txt_at[i].set_size(n_rows, n_cols); setup_table(txt_at[i]); @@ -997,7 +1004,8 @@ void setup_table(AsciiTable &at) { //////////////////////////////////////////////////////////////////////// void write_cts(int i_vx, GenCTCInfo &info) { - ConcatString var_name("GENESIS"); + ConcatString dev_name("GENESIS_DEV"); + ConcatString ops_name("GENESIS_OPS"); // Setup header columns shc.set_model(info.model.c_str()); @@ -1013,8 +1021,6 @@ void write_cts(int i_vx, GenCTCInfo &info) { conf_info.VxOpt[i_vx].ValidBeg : info.obeg); shc.set_obs_valid_end(conf_info.VxOpt[i_vx].ValidEnd != 0 ? conf_info.VxOpt[i_vx].ValidEnd : info.oend); - shc.set_fcst_var(var_name); - shc.set_obs_var(var_name); shc.set_obtype(conf_info.BestEventInfo.Technique.c_str()); if(!conf_info.VxOpt[i_vx].VxMaskName.empty()) { shc.set_mask(conf_info.VxOpt[i_vx].VxMaskName.c_str()); @@ -1022,33 +1028,78 @@ void write_cts(int i_vx, GenCTCInfo &info) { // Write out FHO if(conf_info.OutputMap[stat_fho] != STATOutputType_None) { - write_fho_row(shc, info.cts_tech1, - conf_info.OutputMap[stat_fho], - stat_at, i_stat_row, - txt_at[i_fho], i_txt_row[i_fho]); + + if(conf_info.DevFlag) { + shc.set_fcst_var(dev_name); + shc.set_obs_var (dev_name); + write_fho_row(shc, info.cts_dev, + conf_info.OutputMap[stat_fho], + stat_at, i_stat_row, + txt_at[i_fho], i_txt_row[i_fho]); + } + + if(conf_info.OpsFlag) { + shc.set_fcst_var(ops_name); + shc.set_obs_var (ops_name); + write_fho_row(shc, info.cts_ops, + conf_info.OutputMap[stat_fho], + stat_at, i_stat_row, + txt_at[i_fho], i_txt_row[i_fho]); + } } // Write out CTC if(conf_info.OutputMap[stat_ctc] != STATOutputType_None) { - write_ctc_row(shc, info.cts_tech1, - conf_info.OutputMap[stat_ctc], - stat_at, i_stat_row, - txt_at[i_ctc], i_txt_row[i_ctc]); + + if(conf_info.DevFlag) { + shc.set_fcst_var(dev_name); + shc.set_obs_var (dev_name); + write_ctc_row(shc, info.cts_dev, + conf_info.OutputMap[stat_ctc], + stat_at, i_stat_row, + txt_at[i_ctc], i_txt_row[i_ctc]); + } + + if(conf_info.OpsFlag) { + shc.set_fcst_var(ops_name); + shc.set_obs_var (ops_name); + write_ctc_row(shc, info.cts_ops, + conf_info.OutputMap[stat_ctc], + stat_at, i_stat_row, + txt_at[i_ctc], i_txt_row[i_ctc]); + } } // Write out CTS if(conf_info.OutputMap[stat_cts] != STATOutputType_None) { - // Compute the statistics - info.cts_tech1.allocate_n_alpha(1); - info.cts_tech1.alpha[0] = conf_info.CIAlpha; - info.cts_tech1.compute_stats(); - info.cts_tech1.compute_ci(); + if(conf_info.DevFlag) { + info.cts_dev.allocate_n_alpha(1); + info.cts_dev.alpha[0] = conf_info.CIAlpha; + info.cts_dev.compute_stats(); + info.cts_dev.compute_ci(); + + shc.set_fcst_var(dev_name); + shc.set_obs_var (dev_name); + write_cts_row(shc, info.cts_dev, + conf_info.OutputMap[stat_cts], + stat_at, i_stat_row, + txt_at[i_cts], i_txt_row[i_cts]); + } - write_cts_row(shc, info.cts_tech1, - conf_info.OutputMap[stat_cts], - stat_at, i_stat_row, - txt_at[i_cts], i_txt_row[i_cts]); + if(conf_info.OpsFlag) { + info.cts_ops.allocate_n_alpha(1); + info.cts_ops.alpha[0] = conf_info.CIAlpha; + info.cts_ops.compute_stats(); + info.cts_ops.compute_ci(); + + shc.set_fcst_var(ops_name); + shc.set_obs_var (ops_name); + write_cts_row(shc, info.cts_ops, + conf_info.OutputMap[stat_cts], + stat_at, i_stat_row, + txt_at[i_cts], i_txt_row[i_cts]); + } } return; diff --git a/met/src/tools/tc_utils/tc_gen/tc_gen_conf_info.cc b/met/src/tools/tc_utils/tc_gen/tc_gen_conf_info.cc index 3beb1f9f06..6ac7308c58 100644 --- a/met/src/tools/tc_utils/tc_gen/tc_gen_conf_info.cc +++ b/met/src/tools/tc_utils/tc_gen/tc_gen_conf_info.cc @@ -38,8 +38,8 @@ GenCTCInfo::GenCTCInfo() { void GenCTCInfo::clear() { model.clear(); - cts_tech1.clear(); - cts_tech2.clear(); + cts_dev.clear(); + cts_ops.clear(); fbeg = fend = obeg = oend = (unixtime) 0; } @@ -48,8 +48,8 @@ void GenCTCInfo::clear() { GenCTCInfo & GenCTCInfo::operator+=(const GenCTCInfo &g) { // Increment counts - cts_tech1.cts += g.cts_tech1.cts; - cts_tech2.cts += g.cts_tech2.cts; + cts_dev.cts += g.cts_dev.cts; + cts_ops.cts += g.cts_ops.cts; // Keep track of the minimum and maximum times if(fbeg == 0 || g.fbeg < fbeg) fbeg = g.fbeg; @@ -326,6 +326,8 @@ void TCGenConfInfo::clear() { BasinGrid.clear(); BasinData.clear(); Version.clear(); + DevFlag = false; + OpsFlag = false; CIAlpha = bad_data_double; OutputMap.clear(); @@ -410,6 +412,18 @@ void TCGenConfInfo::process_config() { Version = Conf.lookup_string(conf_key_version); check_met_version(Version.c_str()); + // Conf: DevFlag and OpsFlag + DevFlag = Conf.lookup_bool(conf_key_dev_method_flag); + OpsFlag = Conf.lookup_bool(conf_key_ops_method_flag); + + if(!DevFlag && !OpsFlag) { + mlog << Error << "\nTCGenConfInfo::process_config() -> " + << "at least one of " << conf_key_dev_method_flag + << " or " << conf_key_ops_method_flag + << " must be set to true!\n\n"; + exit(1); + } + // Conf: CIAlpha CIAlpha = Conf.lookup_double(conf_key_ci_alpha); diff --git a/met/src/tools/tc_utils/tc_gen/tc_gen_conf_info.h b/met/src/tools/tc_utils/tc_gen/tc_gen_conf_info.h index d50bde24dd..ae74871d04 100644 --- a/met/src/tools/tc_utils/tc_gen/tc_gen_conf_info.h +++ b/met/src/tools/tc_utils/tc_gen/tc_gen_conf_info.h @@ -43,8 +43,8 @@ static const STATLineType txt_file_type[n_txt] = { struct GenCTCInfo { ConcatString model; - CTSInfo cts_tech1; - CTSInfo cts_tech2; + CTSInfo cts_dev; + CTSInfo cts_ops; unixtime fbeg, fend, obeg, oend; GenCTCInfo(); @@ -158,6 +158,10 @@ class TCGenConfInfo { // Config file version ConcatString Version; + // Scoring methods + bool DevFlag; + bool OpsFlag; + // Output file options double CIAlpha; map OutputMap; diff --git a/test/config/TCGenConfig_2016 b/test/config/TCGenConfig_2016 index 814bcd0720..b5d82472ab 100644 --- a/test/config/TCGenConfig_2016 +++ b/test/config/TCGenConfig_2016 @@ -190,6 +190,12 @@ genesis_init_diff = 48; // //////////////////////////////////////////////////////////////////////////////// +// +// Scoring methods to be applied +// +dev_method_flag = TRUE; +ops_method_flag = TRUE; + // // Confidence interval alpha value // @@ -199,9 +205,9 @@ ci_alpha = 0.05; // Statistical output types // output_flag = { - fho = NONE; - ctc = BOTH; - cts = BOTH; + fho = NONE; + ctc = BOTH; + cts = BOTH; } //