1 /* _______________________________________________________________________
2
3 DAKOTA: Design Analysis Kit for Optimization and Terascale Applications
4 Copyright 2014-2020 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
5 This software is distributed under the GNU Lesser General Public License.
6 For more information, see the README file in the top Dakota directory.
7 _______________________________________________________________________ */
8
9 //- Class: DataMethod
10 //- Description:
11 //-
12 //- Owner: Mike Eldred
13 //- Version: $Id: DataMethod.hpp 6984 2010-09-27 02:11:09Z lpswile $
14
15 #ifndef DATA_METHOD_H
16 #define DATA_METHOD_H
17
18 #include "dakota_system_defs.hpp"
19 #include "dakota_data_types.hpp"
20 #include "MPIPackBuffer.hpp"
21
22 namespace Dakota {
23
24 // --------
25 // Iterator
26 // --------
27 // unsigned short 16 bits are apportioned as [Minimizer,Opt,LSq,SurrBased,
28 // Analyzer,NonD,PStudyDACE,Verif,Meta,...] where the trailing 6 bits are
29 // available for up to 64 methods within a particular classification.
30 #define PARALLEL_BIT 64
31 #define META_BIT 128
32 #define VERIF_BIT 256
33 #define PSTUDYDACE_BIT 512
34 #define NOND_BIT 1024
35 #define ANALYZER_BIT 2048
36 #define SURRBASED_BIT 4096
37 #define LEASTSQ_BIT 8192
38 #define OPTIMIZER_BIT 16384
39 #define MINIMIZER_BIT 32768
40 // define special values for method name. Special bit selections enable
41 // identification of method groupings based on the value.
42 enum { DEFAULT_METHOD=0,
43 // Meta-Iterators:
44 HYBRID=(META_BIT | PARALLEL_BIT), PARETO_SET, MULTI_START,
45 // BRANCH_AND_BOUND,
46 // Verification Analyzers:
47 RICHARDSON_EXTRAP=(ANALYZER_BIT | VERIF_BIT),
48 // PStudyDACE Analyzers:
49 CENTERED_PARAMETER_STUDY=(ANALYZER_BIT | PSTUDYDACE_BIT),
50 LIST_PARAMETER_STUDY, MULTIDIM_PARAMETER_STUDY, VECTOR_PARAMETER_STUDY,
51 DACE, FSU_CVT, FSU_HALTON, FSU_HAMMERSLEY, PSUADE_MOAT,
52 // NonD Analyzers:
53 LOCAL_RELIABILITY=(ANALYZER_BIT | NOND_BIT), GLOBAL_RELIABILITY,
54 SURROGATE_BASED_UQ, POLYNOMIAL_CHAOS, MULTILEVEL_POLYNOMIAL_CHAOS,
55 MULTIFIDELITY_POLYNOMIAL_CHAOS, STOCH_COLLOCATION,
56 MULTIFIDELITY_STOCH_COLLOCATION, C3_FUNCTION_TRAIN,
57 MULTILEVEL_FUNCTION_TRAIN, MULTIFIDELITY_FUNCTION_TRAIN,
58 CUBATURE_INTEGRATION, SPARSE_GRID_INTEGRATION, QUADRATURE_INTEGRATION,
59 BAYES_CALIBRATION, GPAIS, POF_DARTS, RKD_DARTS,
60 IMPORTANCE_SAMPLING, ADAPTIVE_SAMPLING, MULTILEVEL_SAMPLING,
61 LIST_SAMPLING, RANDOM_SAMPLING, MUQ_SAMPLING,
62 // Variables::method_view(): epistemic if method_name > RANDOM_SAMPLING
63 LOCAL_INTERVAL_EST, LOCAL_EVIDENCE, GLOBAL_INTERVAL_EST, GLOBAL_EVIDENCE,
64 //BAYES_CALIBRATION=(ANALYZER_BIT | NOND_BIT | PARALLEL_BIT),
65 //BRANCH_AND_BOUND=(MINIMIZER_BIT | PARALLEL_BIT),
66 // SurrBased Minimizers:
67 SURROGATE_BASED_LOCAL=(MINIMIZER_BIT | SURRBASED_BIT),
68 DATA_FIT_SURROGATE_BASED_LOCAL, HIERARCH_SURROGATE_BASED_LOCAL,
69 SURROGATE_BASED_GLOBAL, EFFICIENT_GLOBAL,
70 // Gradient-based LeastSq Minimizers:
71 NL2SOL=(MINIMIZER_BIT | LEASTSQ_BIT), NLSSOL_SQP, OPTPP_G_NEWTON,
72 // Nongradient-based Optimizers / Minimizers:
73 ASYNCH_PATTERN_SEARCH=(MINIMIZER_BIT | OPTIMIZER_BIT), OPTPP_PDS,
74 COLINY_BETA, COLINY_COBYLA, COLINY_DIRECT, COLINY_MULTI_START,
75 COLINY_EA, COLINY_PATTERN_SEARCH, COLINY_SOLIS_WETS,
76 MOGA, SOGA, NCSU_DIRECT, MESH_ADAPTIVE_SEARCH, MIT_NOWPAC, MIT_SNOWPAC,
77 GENIE_OPT_DARTS, GENIE_DIRECT,
78 // Place Demo Opt TPL here based on current state of non-gradient flavor
79 DEMO_TPL,
80 // Gradient-based Optimizers / Minimizers:
81 NONLINEAR_CG, OPTPP_CG, OPTPP_Q_NEWTON, OPTPP_FD_NEWTON, OPTPP_NEWTON,
82 NPSOL_SQP, NLPQL_SQP, //REDUCED_SQP,
83 DOT_BFGS, DOT_FRCG, DOT_MMFD, DOT_SLP, DOT_SQP, CONMIN_FRCG, CONMIN_MFD,
84 ROL,
85 // Generic Optimizers / Minimizers:
86 DL_SOLVER,
87 // Minimizers that are both opt & least sq
88 BRANCH_AND_BOUND=(MINIMIZER_BIT | OPTIMIZER_BIT | LEASTSQ_BIT) };
89
90 /// Sub-methods, including sampling, inference algorithm, opt algorithm types
91 enum { SUBMETHOD_DEFAULT=0, // no specification
92 SUBMETHOD_NONE, // spec override of default: no submethod
93 /// Type of hybrid meta-iterator:
94 SUBMETHOD_COLLABORATIVE, SUBMETHOD_EMBEDDED, SUBMETHOD_SEQUENTIAL,
95 // Sampling and DOE types:
96 SUBMETHOD_LHS, SUBMETHOD_RANDOM,
97 SUBMETHOD_BOX_BEHNKEN, SUBMETHOD_CENTRAL_COMPOSITE,
98 SUBMETHOD_GRID, SUBMETHOD_OA_LHS, SUBMETHOD_OAS,
99 // Bayesian inference algorithms:
100 SUBMETHOD_DREAM, SUBMETHOD_GPMSA, SUBMETHOD_MUQ, SUBMETHOD_QUESO, SUBMETHOD_WASABI,
101 // optimization sub-method selections (in addition to SUBMETHOD_LHS):
102 SUBMETHOD_NIP, SUBMETHOD_SQP, SUBMETHOD_EA, SUBMETHOD_EGO, SUBMETHOD_SBO,
103 // verification approaches:
104 SUBMETHOD_CONVERGE_ORDER, SUBMETHOD_CONVERGE_QOI,
105 SUBMETHOD_ESTIMATE_ORDER };
106
107 // define special values for outputLevel within
108 // Iterator/Model/Interface/Approximation
109 enum { SILENT_OUTPUT, QUIET_OUTPUT, NORMAL_OUTPUT, VERBOSE_OUTPUT,
110 DEBUG_OUTPUT };
111 // define special values for printing of different results states
112 enum { NO_RESULTS=0, // suppress all results
113 REFINEMENT_RESULTS, // results following a (minor) refinement iteration
114 INTERMEDIATE_RESULTS,// results following a (major) alg stage/model level
115 FINAL_RESULTS }; // final UQ results (throttled if subIterator)
116
117 // define special values for Iterator and Interface scheduling
118 enum { DEFAULT_SCHEDULING, MASTER_SCHEDULING, PEER_SCHEDULING,
119 PEER_DYNAMIC_SCHEDULING, PEER_STATIC_SCHEDULING, DYNAMIC_SCHEDULING,
120 STATIC_SCHEDULING };
121 // define special values for ParallelLibrary configuration logic
122 // related to scheduling
123 enum { DEFAULT_CONFIG, PUSH_DOWN, PUSH_UP };
124
125 // ----
126 // NonD
127 // ----
128 // define special values for u-space type used for random var transformations
129 enum { STD_NORMAL_U, STD_UNIFORM_U, PARTIAL_ASKEY_U, ASKEY_U, EXTENDED_U };
130 // define special values for covarianceControl
131 enum { DEFAULT_COVARIANCE, NO_COVARIANCE, DIAGONAL_COVARIANCE,
132 FULL_COVARIANCE };
133 // define special values for probability integration refinement
134 enum { NO_INT_REFINE=0, IS, AIS, MMAIS };
135 // define special values for responseLevelTarget
136 enum { PROBABILITIES, RELIABILITIES, GEN_RELIABILITIES };
137 // define special values for responseLevelTargetReduce
138 enum { COMPONENT=0, SYSTEM_SERIES, SYSTEM_PARALLEL };
139 // define special values for distributionType
140 enum { CUMULATIVE, COMPLEMENTARY };
141 // define special values for finalMomentsType
142 enum { NO_MOMENTS=0, STANDARD_MOMENTS, CENTRAL_MOMENTS };
143
144 // -------------
145 // NonDExpansion (most enums defined by Pecos in pecos_global_defs.hpp)
146 // -------------
147 // define special values for lsRegressionType
148 enum { DEFAULT_LS=0, SVD_LS, EQ_CON_LS };
149 // define special values for multilevAllocControl
150 enum { DEFAULT_MLMF_CONTROL=0, ESTIMATOR_VARIANCE, RIP_SAMPLING, RANK_SAMPLING,
151 GREEDY_REFINEMENT };
152 // define special values for multilevDiscrepEmulation
153 enum { DEFAULT_EMULATION, DISTINCT_EMULATION, RECURSIVE_EMULATION };
154
155 // --------------------
156 // NonDBayesCalibration
157 // --------------------
158 // define special values for emulatorType
159 enum { NO_EMULATOR, PCE_EMULATOR, ML_PCE_EMULATOR, MF_PCE_EMULATOR, SC_EMULATOR,
160 MF_SC_EMULATOR, GP_EMULATOR, KRIGING_EMULATOR, EXPGP_EMULATOR,
161 VPS_EMULATOR };
162 // modes for calibrating multipliers on observational error
163 enum { CALIBRATE_NONE = 0, CALIBRATE_ONE, CALIBRATE_PER_EXPER,
164 CALIBRATE_PER_RESP, CALIBRATE_BOTH};
165
166 // ------------
167 // NonDSampling
168 // ------------
169 // LHS rank array processing modes:
170 enum { IGNORE_RANKS, SET_RANKS, GET_RANKS, SET_GET_RANKS };
171 // sampling modes (combination of view and native distribution vs. uniform):
172 enum { DESIGN, //DESIGN_UNIFORM,
173 UNCERTAIN, UNCERTAIN_UNIFORM,
174 ALEATORY_UNCERTAIN, ALEATORY_UNCERTAIN_UNIFORM,
175 EPISTEMIC_UNCERTAIN, EPISTEMIC_UNCERTAIN_UNIFORM,
176 STATE, //STATE_UNIFORM,
177 ACTIVE, ACTIVE_UNIFORM,
178 ALL, ALL_UNIFORM };
179 // (1) {,A,E}UNCERTAIN: sample only over the {,A,E} uncertain variables,
180 // ignoring design/state, using the native distributions.
181 // (2) {,A,E}UNCERTAIN_UNIFORM: sample only over the {,A,E}uncertain variables,
182 // ignoring design/state, using uniform distributions within native/inferred
183 // bounds.
184 // (3) ACTIVE: sample only over the active variables, ignoring inactive, using
185 // the native distributions (assumes uniform for design/state).
186 // (4) ACTIVE_UNIFORM: sample only over the active variables, ignoring inactive,
187 // using uniform distributions within native/inferred bounds.
188 // (5) ALL: sample over All variables using native distributions (assumes
189 // uniform for design/state).
190 // (6) ALL_UNIFORM: sample over All variables using uniform distributions.
191 // Note that ACTIVE modes will overlap with either UNCERTAIN or ALL modes
192 // depending on whether the Model/Variables employ an All or Distinct view.
193 // Wilks type of confidence interval
194 enum { ONE_SIDED_LOWER, ONE_SIDED_UPPER, TWO_SIDED };
195
196 // define special values for qoi aggregation norm for sample allocation over levels and QoIs
197 enum {QOI_AGGREGATION_MAX, QOI_AGGREGATION_SUM};
198
199 // target variance for fitting sample allocation
200 enum {TARGET_MEAN, TARGET_VARIANCE};
201 // ---------------
202 // NonDReliability
203 // ---------------
204 // define special values for mppSearchType
205 enum { MV=0, AMV_X, AMV_U, AMV_PLUS_X, AMV_PLUS_U, TANA_X, TANA_U,
206 QMEA_X, QMEA_U, NO_APPROX, EGRA_X, EGRA_U };
207 // define special values for secondOrderIntType
208 enum { BREITUNG, HOHENRACK, HONG };
209
210 // -----------------------
211 // SurrBasedLocalMinimizer
212 // -----------------------
213 // define special values for SBL approximate subproblem objective
214 enum { ORIGINAL_PRIMARY, SINGLE_OBJECTIVE,
215 LAGRANGIAN_OBJECTIVE, AUGMENTED_LAGRANGIAN_OBJECTIVE };
216 // define special values for SBL approximate subproblem constraints
217 enum { NO_CONSTRAINTS, LINEARIZED_CONSTRAINTS, ORIGINAL_CONSTRAINTS };
218 // define special values for SBL constraint relaxation
219 enum { NO_RELAX, HOMOTOPY, COMPOSITE_STEP }; // COMPOSITE_STEP: BYRD_OMOJOKUN,
220 // CELIS_DENNIS_TAPIA, or MAESTRO
221 // define special values for SBL and NonDGlobalReliability merit function type
222 enum { PENALTY_MERIT, ADAPTIVE_PENALTY_MERIT,
223 LAGRANGIAN_MERIT, AUGMENTED_LAGRANGIAN_MERIT }; // FILTER_AREA
224 // define special values for SBL iterate acceptance logic
225 enum { FILTER, TR_RATIO };
226
227
228 /// Body class for method specification data.
229
230 /** The DataMethodRep class is used to contain the data from a method
231 keyword specification. Default values are managed in the
232 DataMethodRep constructor. Data is public to avoid maintaining
233 set/get functions, but is still encapsulated within ProblemDescDB
234 since ProblemDescDB::dataMethodList is private. */
235
236 class DataMethodRep
237 {
238 //
239 //- Heading: Friends
240 //
241
242 /// the handle class can access attributes of the body class directly
243 friend class DataMethod;
244
245 public:
246
247 ~DataMethodRep(); ///< destructor
248
249 //
250 //- Heading: Data
251 //
252
253 // method independent controls
254
255 /// string identifier for the method specification data set (from
256 /// the \c id_method specification in \ref MethodIndControl)
257 String idMethod;
258 /// string pointer to the model specification to be used by this method
259 /// (from the \c model_pointer specification in \ref MethodIndControl)
260 String modelPointer;
261 /// string to point to the low fidelity model for Bayesian experimental design
262 String lowFidModelPointer;
263 /// method verbosity control: {SILENT,QUIET,NORMAL,VERBOSE,DEBUG}_OUTPUT
264 /// (from the \c output specification in \ref MethodIndControl)
265 short methodOutput;
266
267 /// maximum number of iterations allowed for the method (from the \c
268 /// max_iterations specification in \ref MethodIndControl)
269 int maxIterations;
270 /// maximum number of refinement iterations allowed for a uniform/adaptive
271 /// refinement approach (from the \c max_refinement_iterations specification
272 /// in \ref MethodIndControl)
273 int maxRefineIterations;
274 /// maximum number of internal solver iterations allowed for the method
275 /// (from the \c max_solver_iterations specification in \ref MethodIndControl)
276 int maxSolverIterations;
277 /// maximum number of function evaluations allowed for the method (from
278 /// the \c max_function_evaluations specification in \ref MethodIndControl)
279 int maxFunctionEvaluations;
280
281 /// flag for use of speculative gradient approaches for maintaining parallel
282 /// load balance during the line search portion of optimization algorithms
283 /// (from the \c speculative specification in \ref MethodIndControl)
284 bool speculativeFlag;
285 /// flag for usage of derivative data to enhance the computation of
286 /// surrogate models (PCE/SC expansions, GP models for EGO/EGRA/EGIE)
287 /// based on the \c use_derivatives specification
288 bool methodUseDerivsFlag;
289 /// tolerance for controlling the amount of infeasibility that is allowed
290 /// before an active constraint is considered to be violated (from the \c
291 /// constraint_tolerance specification in \ref MethodIndControl)
292 Real constraintTolerance;
293 /// flag indicating scaling status (from the \c scaling specification in
294 /// \ref MethodIndControl)
295 bool methodScaling;
296 /// number of final solutions returned from the iterator
297 size_t numFinalSolutions;
298
299 /// iteration convergence tolerance for the method (from the \c
300 /// convergence_tolerance specification in \ref MethodIndControl)
301 Real convergenceTolerance;
302 /// controls use of convergence tolerance in a relative (true) or
303 /// absolute (false) context
304 bool relativeConvMetric;
305 /// mode of computing statistics metrics used for convergence assessment
306 /// of multilevel/multifidelity refinement processes: active or combined
307 short statsMetricMode;
308
309 /// the method selection: one of the optimizer, least squares, nond, dace,
310 /// or parameter study methods
311 unsigned short methodName;
312 /// enum value for a sub-method type
313 unsigned short subMethod;
314 /// string identifier for a sub-method name within a multi-option
315 /// method specification (e.g., from meta-iterators)
316 String subMethodName;
317 /// string pointer for a sub-model specification used by a meta-iterator
318 String subModelPointer;
319 /// string pointer for a sub-method specification used by a meta-iterator
320 String subMethodPointer;
321
322 /// number of servers for concurrent iterator parallelism (from
323 /// the \c iterator_servers specification)
324 int iteratorServers;
325 /// number of processors for each concurrent iterator partition (from
326 /// the \c processors_per_iterator specification)
327 int procsPerIterator;
328 /// type of scheduling ({DEFAULT,MASTER,PEER}_SCHEDULING) used in concurrent
329 /// iterator parallelism (from the \c iterator_scheduling specification)
330 short iteratorScheduling;
331
332 /// array of methods for the sequential and collaborative hybrid
333 /// meta-iterators (from the \c method_name_list specification)
334 StringArray hybridMethodNames;
335 /// array of models for the sequential and collaborative hybrid
336 /// meta-iterators (from the \c model_pointer_list specification)
337 StringArray hybridModelPointers;
338 /// array of methods for the sequential and collaborative hybrid
339 /// meta-iterators (from the \c method_pointer_list specification)
340 StringArray hybridMethodPointers;
341 // progress threshold for sequential adaptive hybrids (from the \c
342 // progress_threshold specification)
343 //Real hybridProgThresh;
344 /// global method name for embedded hybrids (from the \c
345 /// global_method_name specification)
346 String hybridGlobalMethodName;
347 /// global model pointer for embedded hybrids (from the \c
348 /// global_model_pointer specification)
349 String hybridGlobalModelPointer;
350 /// global method pointer for embedded hybrids (from the \c
351 /// global_method_pointer specification)
352 String hybridGlobalMethodPointer;
353 /// local method name for embedded hybrids (from the \c
354 /// local_method_name specification)
355 String hybridLocalMethodName;
356 /// local model pointer for embedded hybrids (from the \c
357 /// local_model_pointer specification)
358 String hybridLocalModelPointer;
359 /// local method pointer for embedded hybrids (from the \c
360 /// local_method_pointer specification)
361 String hybridLocalMethodPointer;
362 /// local search probability for embedded hybrids (from the \c
363 /// local_search_probability specification)
364 Real hybridLSProb;
365
366 /// number of random jobs to perform in the pareto_set and
367 /// multi_start meta-iterators (from the \c random_starts and \c
368 /// random_weight_sets specifications)
369 int concurrentRandomJobs;
370 /// user-specified (i.e., nonrandom) parameter sets to evaluate in
371 /// the pareto_set and multi_start meta-iterators (from the \c
372 /// starting_points and \c weight_sets specifications)
373 RealVector concurrentParameterSets;
374
375 /// number of consecutive iterations with change less than
376 /// convergenceTolerance required to trigger convergence
377 unsigned short softConvLimit;
378 /// flag to indicate user-specification of a bypass of any/all
379 /// layerings in evaluating truth response values in SBL.
380 bool surrBasedLocalLayerBypass;
381 /// initial trust region sizes in the surrogate-based local method
382 /// (from the \c initial_size specification in \ref MethodSBL), one
383 /// size per surrogate model (notes: no trust region for the truth
384 /// model; sizes are relative values, e.g., 0.1 = 10% of range of
385 /// global bounds for each variable
386 RealVector trustRegionInitSize;
387 /// minimum trust region size in the surrogate-based local method
388 /// (from the \c minimum_size specification in \ref MethodSBL), if
389 /// the trust region size falls below this threshold the SBL
390 /// iterations are terminated (note: if kriging is used with SBL,
391 /// the min trust region size is set to 1.0e-3 in attempt to avoid
392 /// ill-conditioned matrixes that arise in kriging over small trust
393 /// regions)
394 Real trustRegionMinSize;
395 /// trust region minimum improvement level (ratio of actual to predicted
396 /// decrease in objective fcn) in the surrogate-based local method
397 /// (from the \c contract_threshold specification in \ref MethodSBL),
398 /// the trust region shrinks or is rejected if the ratio is below
399 /// this value ("eta_1" in the Conn-Gould-Toint trust region book)
400 Real trustRegionContractTrigger;
401 /// trust region sufficient improvement level (ratio of actual to
402 /// predicted decrease in objective fn) in the surrogate-based local
403 /// method (from the \c expand_threshold specification in \ref
404 /// MethodSBL), the trust region expands if the ratio is above this
405 /// value ("eta_2" in the Conn-Gould-Toint trust region book)
406 Real trustRegionExpandTrigger;
407 /// trust region contraction factor in the surrogate-based local method
408 /// (from the \c contraction_factor specification in \ref MethodSBL)
409 Real trustRegionContract;
410 /// trust region expansion factor in the surrogate-based local method
411 /// (from the \c expansion_factor specification in \ref MethodSBL)
412 Real trustRegionExpand;
413 /// SBL approximate subproblem objective: ORIGINAL_PRIMARY, SINGLE_OBJECTIVE,
414 /// LAGRANGIAN_OBJECTIVE, or AUGMENTED_LAGRANGIAN_OBJECTIVE
415 short surrBasedLocalSubProbObj;
416 /// SBL approximate subproblem constraints: NO_CONSTRAINTS,
417 /// LINEARIZED_CONSTRAINTS, or ORIGINAL_CONSTRAINTS
418 short surrBasedLocalSubProbCon;
419 /// SBL merit function type: BASIC_PENALTY, ADAPTIVE_PENALTY,
420 /// BASIC_LAGRANGIAN, or AUGMENTED_LAGRANGIAN
421 short surrBasedLocalMeritFn;
422 /// SBL iterate acceptance logic: TR_RATIO or FILTER
423 short surrBasedLocalAcceptLogic;
424 /// SBL constraint relaxation method: NO_RELAX or HOMOTOPY
425 short surrBasedLocalConstrRelax;
426 /// user-specified method for adding points to the set upon which the
427 /// next surrogate is based in the \c surrogate_based_global method.
428 bool surrBasedGlobalReplacePts;
429
430 // number of samples at the root for the branch and bound method
431 // (from the \c num_samples_at_root specification in \ref MethodBandB)
432 //int branchBndNumSamplesRoot;
433 // number of samples at each node for the branch and bound method
434 // (from the \c num_samples_at_node specification in \ref MethodBandB)
435 //int branchBndNumSamplesNode;
436
437 // DL_SOLVER
438
439 /// string of options for a dynamically linked solver
440 String dlDetails;
441 /// handle to dynamically loaded library
442 void *dlLib;
443
444 // NPSOL
445
446 /// the \c verify_level specification in \ref MethodNPSOLDC
447 int verifyLevel;
448 /// the \c function_precision specification in \ref MethodNPSOLDC
449 /// and the \c EPSILON specification in NOMAD
450 Real functionPrecision; /* also used by nl2sol */
451 /// the \c linesearch_tolerance specification in \ref MethodNPSOLDC
452 Real lineSearchTolerance;
453
454 // NL2SOL
455
456 Real absConvTol; ///< absolute function convergence tolerance
457 Real xConvTol; ///< x-convergence tolerance
458 Real singConvTol; ///< singular convergence tolerance
459 Real singRadius; ///< radius for singular convergence test
460 Real falseConvTol; ///< false-convergence tolerance
461 Real initTRRadius; ///< initial trust radius
462 int covarianceType; ///< kind of covariance required
463 bool regressDiag; ///< whether to print the regression diagnostic vector
464
465 // OPT++
466
467 /// the \c search_method specification for Newton and nonlinear
468 /// interior-point methods in \ref MethodOPTPPDC
469 String searchMethod;
470 /// the \c gradient_tolerance specification in \ref MethodOPTPPDC
471 Real gradientTolerance;
472 /// the \c max_step specification in \ref MethodOPTPPDC
473 Real maxStep;
474 /// the \c merit_function specification for nonlinear
475 /// interior-point methods in \ref MethodOPTPPDC
476 short meritFn;
477 /// the \c steplength_to_boundary specification for nonlinear
478 /// interior-point methods in \ref MethodOPTPPDC
479 Real stepLenToBoundary;
480 /// the \c centering_parameter specification for nonlinear
481 /// interior-point methods in \ref MethodOPTPPDC
482 Real centeringParam;
483 /// the \c search_scheme_size specification for PDS methods in
484 /// \ref MethodOPTPPDC
485 int searchSchemeSize;
486
487 // APPSPACK
488
489 // using solnTarget from COLINY
490
491 /// the \c initStepLength choice for nonlinearly constrained APPS in
492 /// \ref MethodAPPSDC
493 Real initStepLength;
494 /// the \c contractStepLength choice for nonlinearly constrained APPS in
495 /// \ref MethodAPPSDC
496 Real contractStepLength;
497 /// the \c threshStepLength choice for nonlinearly constrained APPS in
498 /// \ref MethodAPPSDC
499 Real threshStepLength;
500 /// the \c meritFunction choice for nonlinearly constrained APPS in
501 /// \ref MethodAPPSDC
502 String meritFunction;
503 /// the \c constrPenalty choice for nonlinearly constrained APPS in
504 /// \ref MethodAPPSDC
505 Real constrPenalty;
506 /// the initial \c smoothFactor value for nonlinearly constrained APPS in
507 /// \ref MethodAPPSDC
508 Real smoothFactor;
509
510 // COLINY
511
512 /// the initial \c constraint_penalty for COLINY methods in
513 /// \ref MethodAPPS, \ref MethodSCOLIBDIR, \ref MethodSCOLIBPS,
514 /// \ref MethodSCOLIBSW and \ref MethodSCOLIBEA
515 Real constraintPenalty;
516 /// the \c constant_penalty flag for COLINY methods in
517 /// \ref MethodSCOLIBPS and \ref MethodSCOLIBSW
518 bool constantPenalty;
519 /// the \c global_balance_parameter for the DIRECT method in
520 /// \ref MethodSCOLIBDIR
521 Real globalBalanceParam;
522 /// the \c local_balance_parameter for the DIRECT method in
523 /// \ref MethodSCOLIBDIR
524 Real localBalanceParam;
525 /// the \c max_boxsize_limit for the DIRECT method in \ref MethodSCOLIBDIR
526 Real maxBoxSize;
527 /// the \c min_boxsize_limit for the DIRECT method in \ref MethodSCOLIBDIR
528 /// and \ref MethodNCSUDC
529 Real minBoxSize;
530 /// the \c division setting (\c major_dimension or \c all_dimensions) for
531 /// the DIRECT method in \ref MethodSCOLIBDIR
532 String boxDivision;
533 /// the \c non_adaptive specification for the coliny_ea method in
534 /// \ref MethodSCOLIBEA
535 bool mutationAdaptive;
536 /// the \c show_misc_options specification in \ref MethodSCOLIBDC
537 bool showMiscOptions;
538 /// the \c misc_options specification in \ref MethodSCOLIBDC
539 StringArray miscOptions;
540 /// the \c solution_target specification in \ref MethodSCOLIBDC
541 Real solnTarget;
542 /// the \c crossover_rate specification for EA methods in \ref MethodSCOLIBEA
543 Real crossoverRate;
544 /// the \c mutation_rate specification for EA methods in \ref MethodSCOLIBEA
545 Real mutationRate;
546 /// the \c mutation_scale specification for EA methods in \ref MethodSCOLIBEA
547 Real mutationScale;
548 /// the \c min_scale specification for mutation in EA methods in
549 /// \ref MethodSCOLIBEA
550 Real mutationMinScale;
551 /// the \c initial_delta specification for APPS/COBYLA/PS/SW methods in
552 /// \ref MethodAPPS, \ref MethodSCOLIBCOB, \ref MethodSCOLIBPS, and
553 /// \ref MethodSCOLIBSW
554 Real initDelta;
555 /// the \c variable_tolerance specification for APPS/COBYLA/PS/SW methods
556 /// in \ref MethodAPPS, \ref MethodSCOLIBCOB, \ref MethodSCOLIBPS, and
557 /// \ref MethodSCOLIBSW
558 Real threshDelta;
559 /// the \c contraction_factor specification for APPS/PS/SW methods in
560 /// \ref MethodAPPS, \ref MethodSCOLIBPS, and \ref MethodSCOLIBSW
561 Real contractFactor;
562 /// the \c new_solutions_generated specification for GA/EPSA methods
563 /// in \ref MethodSCOLIBEA
564 int newSolnsGenerated;
565 /// the integer assignment to random, chc, or elitist in the \c
566 /// replacement_type specification for GA/EPSA methods in \ref
567 /// MethodSCOLIBEA
568 int numberRetained;
569 /// the \c no_expansion specification for APPS/PS/SW methods in
570 /// \ref MethodAPPS, \ref MethodSCOLIBPS, and \ref MethodSCOLIBSW
571 bool expansionFlag;
572 /// the \c expand_after_success specification for PS/SW methods in
573 /// \ref MethodSCOLIBPS and \ref MethodSCOLIBSW
574 int expandAfterSuccess;
575 /// the \c contract_after_failure specification for the SW method in
576 /// \ref MethodSCOLIBSW
577 int contractAfterFail;
578 /// the \c mutation_range specification for the pga_int method in
579 /// \ref MethodSCOLIBEA
580 int mutationRange;
581 /// the \c total_pattern_size specification for PS methods in
582 /// \ref MethodSCOLIBPS
583 int totalPatternSize;
584 /// the \c stochastic specification for the PS method in \ref MethodSCOLIBPS
585 bool randomizeOrderFlag;
586 /// the \c fitness_type specification for EA methods in \ref MethodSCOLIBEA
587 String selectionPressure;
588 /// the \c replacement_type specification for EA methods in
589 /// \ref MethodSCOLIBEA
590 String replacementType;
591 /// the \c crossover_type specification for EA methods in \ref MethodSCOLIBEA
592 String crossoverType;
593 /// the \c mutation_type specification for EA methods in \ref MethodSCOLIBEA
594 String mutationType;
595 /// the \c exploratory_moves specification for the PS method in
596 /// \ref MethodSCOLIBPS
597 String exploratoryMoves;
598 /// the \c pattern_basis specification for APPS/PS methods in
599 /// \ref MethodAPPS and \ref MethodSCOLIBPS
600 String patternBasis;
601 /// beta solvers don't need documentation
602 String betaSolverName;
603
604 // COLINY and APPS
605
606 /// the \c synchronization setting for parallel pattern search
607 /// methods in \ref MethodSCOLIBPS and \ref MethodAPPS
608 String evalSynchronize;
609
610 // JEGA
611
612 // using randomSeed from COLINY, NonD, & DACE methods
613 // using mutationType from COLINY
614 // using crossoverType from COLINY
615 // using mutationRate from COLINY
616 // using mutationScale from COLINY
617 // using crossoverRate from COLINY
618 // using populationSize from COLINY
619 // using maxIterations from method independent controls
620 // using maxFunctionEvaluations from method independent controls
621 // using convergenceTolerance for percentChange from method ind. controls
622 // mainLoopType defined in JEGAOptimizer.cpp
623 // evaluationType defined in JEGAOptimizer.cpp
624 // delimiter for flat file read defined in JEGAOptimizer.cpp
625
626 // varibles for the crossover operator
627 /// The number of crossover points or multi-point schemes.
628 size_t numCrossPoints;
629 /// The number of parents to use in a crossover operation.
630 size_t numParents;
631 /// The number of children to produce in a crossover operation.
632 size_t numOffspring;
633
634 // variables for the fitness assessment operator
635 /// the fitness assessment operator to use.
636 String fitnessType;
637
638 // variables for the selection operator
639 /// The means by which this JEGA should converge.
640 String convergenceType;
641
642 /// The minimum percent change before convergence
643 /// for a fitness tracker converger.
644 Real percentChange;
645 /// The number of generations over which a fitness
646 /// tracker converger should track.
647 size_t numGenerations;
648
649 // JEMOGA
650 /// The cutoff value for survival in fitness limiting selectors (e.g.,
651 /// below_limit selector).
652 Real fitnessLimit;
653 /// The minimum percentage of the requested number of selections that
654 /// must take place on each call to the selector (0, 1).
655 Real shrinkagePercent;
656
657 // variables for the niching operator
658 /// The niching type
659 String nichingType;
660
661 // variables for the niching type
662 /// The discretization percentage along each objective
663 RealVector nicheVector;
664
665 /// The maximum number of designs to keep when using the max_designs
666 /// nicher
667 size_t numDesigns;
668
669 // variables for the postprocessor operator
670 /// The post processor type
671 String postProcessorType;
672
673 // variables for the postprocessor type
674 /// The discretization percentage along each objective
675 RealVector distanceVector;
676
677 // JESOGA
678
679
680 // JEGA/COLINY
681
682 // variables for initialization
683 /// The means by which the JEGA should initialize the population.
684 String initializationType;
685 /// The filename to use for initialization.
686 String flatFile;
687 /// The filename to use for logging
688 String logFile;
689 /// the \c population_size specification for GA methods in \ref
690 /// MethodSCOLIBEA
691 int populationSize;
692 /// The \c print_each_pop flag to set the printing of the population
693 /// at each generation
694 bool printPopFlag;
695
696 // NCSU
697
698 // using solnTarget from COLINY
699 // using minBoxSize from COLINY
700
701 /// the \c volume_boxsize_limit for the DIRECT method in \ref MethodNCSUDC
702 Real volBoxSize;
703
704 // DDACE
705
706 /// the \c symbols specification for DACE methods
707 int numSymbols;
708 /// the \c main_effects specification for sampling methods
709 /// in \ref MethodDDACE)
710 bool mainEffectsFlag;
711
712 // FSUDace
713
714 // using numSamples from DDACE
715
716 /// the \c latinize specification for FSU QMC and CVT methods in
717 /// \ref MethodFSUDACE
718 bool latinizeFlag;
719 /// the \c quality_metrics specification for sampling methods (FSU QMC
720 /// and CVT methods in \ref MethodFSUDACE)
721 bool volQualityFlag;
722
723 // FSUDace QMC
724 /// the \c sequenceStart specification in \ref MethodFSUDACE
725 IntVector sequenceStart;
726 /// the \c sequenceLeap specification in \ref MethodFSUDACE
727 IntVector sequenceLeap;
728 /// the \c primeBase specification in \ref MethodFSUDACE
729 IntVector primeBase;
730
731 // FSUDace CVT
732 // using randomSeed, fixedSeedFlag, numSamples from other methods
733 // using initializationType, sampleType from other methods
734 /// the \c numTrials specification in \ref MethodFSUDACE
735 int numTrials;
736 /// the \c trial_type specification in \ref MethodFSUDACE
737 String trialType;
738
739 // COLINY, NonD, & DACE
740
741 /// the \c seed specification for COLINY, NonD, & DACE methods
742 int randomSeed;
743 /// the \c seed_sequence specification for multilevel UQ methods
744 SizetArray randomSeedSeq;
745
746 // MADS
747 /// the \c initMeshSize choice for NOMAD in \ref MethodNOMADDC
748 Real initMeshSize;
749 /// the \c minMeshSize choice for NOMAD in \ref MethodNOMADDC
750 Real minMeshSize;
751 /// the \c HISTORY_FILE specification for NOMAD
752 String historyFile;
753 /// the \c DISPLAY_STATS specification for NOMAD
754 String displayFormat;
755 /// the \c VNS specification for NOMAD
756 Real vns;
757 /// the \c NEIGHBOR_ORDER specification for NOMAD
758 int neighborOrder;
759 /// the \c DISPLAY_ALL_EVAL specification for NOMAD
760 bool showAllEval;
761 /// the \c HAS_SGTE specification for NOMAD
762 String useSurrogate;
763
764 // NonD C3 Function Train
765 // Note: regressionType,maxSolverIterations,regressionL2Penalty are shared
766
767 /// maximum number of cross iterations
768 int maxCrossIterations;
769 /// optimization tolerance for FT regression
770 Real solverTol;
771 /// Rounding tolerance for FT regression
772 Real solverRoundingTol;
773 /// arithmetic (rounding) tolerance for FT sums and products
774 Real statsRoundingTol;
775 /// starting polynomial order
776 unsigned short startOrder;
777 /// polynomial order increment when adapting
778 unsigned short kickOrder;
779 /// maximum order of basis polynomials
780 unsigned short maxOrder;
781 /// whether or not to adapt order by cross validation
782 bool adaptOrder;
783 /// starting rank
784 size_t startRank;
785 /// rank increment when adapting
786 size_t kickRank;
787 /// maximum rank
788 size_t maxRank;
789 /// whether or not to adapt rank
790 bool adaptRank;
791 /// quantity to increment (start rank, start order, max rank, max order,
792 /// max rank + max order) for FT (uniform) p-refinement
793 short c3AdvanceType;
794 /// starting polynomial order
795 UShortArray startOrderSeq;
796 /// starting rank
797 SizetArray startRankSeq;
798
799 // NonD & DACE
800
801 /// the \c samples specification for NonD & DACE methods
802 int numSamples;
803 /// flag for fixing the value of the seed among different NonD/DACE
804 /// sample sets. This results in the use of the same sampling
805 /// stencil/pattern throughout an execution with repeated sampling.
806 bool fixedSeedFlag;
807 /// flag for fixing the sequence for Halton or Hammersley QMC
808 /// sample sets. This results in the use of the same sampling
809 /// stencil/pattern throughout an execution with repeated sampling.
810 bool fixedSequenceFlag;
811 /// the \c var_based_decomp specification for a variety of sampling methods
812 bool vbdFlag;
813 /// the \c var_based_decomp tolerance for omitting index output
814 Real vbdDropTolerance;
815 /// the \c backfill option allows one to augment in LHS sample
816 /// by enforcing the addition of unique discrete variables to the sample
817 bool backfillFlag;
818 /// Flag to specify the calculation of principal components when
819 /// using LHS
820 bool pcaFlag;
821 /// The percentage of variance explained by using a truncated
822 /// number of principal components in PCA
823 Real percentVarianceExplained;
824 /// Flag to specify use of Wilks formula to calculate num samples
825 bool wilksFlag;
826 /// Wilks order parameter
827 unsigned short wilksOrder;
828 /// Wilks confidence interval parameter
829 Real wilksConfidenceLevel;
830 /// Wilks sided interval type
831 short wilksSidedInterval;
832
833 /// a sub-specification of vbdFlag: interaction order limit for
834 /// calculation/output of component VBD indices
835 unsigned short vbdOrder;
836 /// restrict the calculation of a full response covariance matrix
837 /// for high dimensional outputs: {DEFAULT,DIAGONAL,FULL}_COVARIANCE
838 short covarianceControl;
839 /// the \c basic random-number generator for NonD
840 String rngName;
841 /// refinement type for stochastic expansions from dimension refinement
842 /// keyword group
843 short refinementType;
844 /// refinement control for stochastic expansions from dimension refinement
845 /// keyword group
846 short refinementControl;
847 /// override for default point nesting policy: NO_NESTING_OVERRIDE, NESTED,
848 /// or NON_NESTED
849 short nestingOverride;
850 /// override for default point growth restriction policy: NO_GROWTH_OVERRIDE,
851 /// RESTRICTED, or UNRESTRICTED
852 short growthOverride;
853 /// enumeration for u-space type that defines u-space variable targets
854 /// for probability space transformations: EXTENDED_U (default), ASKEY_U,
855 /// PARTIAL_ASKEY_U, STD_NORMAL_U, or STD_UNIFORM_U
856 short expansionType;
857 /// boolean indicating presence of \c piecewise keyword
858 bool piecewiseBasis;
859 /// enumeration for type of basis in sparse grid interpolation
860 /// (Pecos::{NODAL,HIERARCHICAL}_INTERPOLANT) or regression
861 /// (Pecos::{TENSOR_PRODUCT,TOTAL_ORDER,ADAPTED}_BASIS).
862 short expansionBasisType;
863
864 /// the \c quadrature_order_sequence specification in \ref MethodNonDPCE and
865 /// \ref MethodNonDSC
866 UShortArray quadratureOrderSeq;
867 /// the \c sparse_grid_level_sequence specification in \ref MethodNonDPCE and
868 /// \ref MethodNonDSC
869 UShortArray sparseGridLevelSeq;
870 /// the \c expansion_order_sequence specification in \ref MethodNonDPCE
871 UShortArray expansionOrderSeq;
872 /// the \c collocation_points_sequence specification in \ref MethodNonDPCE
873 SizetArray collocationPointsSeq;
874 /// the \c expansion_samples_sequence specification in \ref MethodNonDPCE
875 SizetArray expansionSamplesSeq;
876
877 /// the \c quadrature_order specification in \ref MethodNonDPCE and
878 /// \ref MethodNonDSC
879 unsigned short quadratureOrder;
880 /// the \c sparse_grid_level specification in \ref MethodNonDPCE and
881 /// \ref MethodNonDSC
882 unsigned short sparseGridLevel;
883 /// the \c expansion_order specification in \ref MethodNonDPCE
884 unsigned short expansionOrder;
885 /// the \c collocation_points specification in \ref MethodNonDPCE
886 size_t collocationPoints;
887 /// the \c expansion_samples specification in \ref MethodNonDPCE
888 size_t expansionSamples;
889
890 // allows for incremental PCE construction using the \c incremental_lhs
891 // specification in \ref MethodNonDPCE
892 //String expansionSampleType;
893 /// the \c dimension_preference specification for tensor and sparse grids
894 /// and expansion orders in \ref MethodNonDPCE and \ref MethodNonDSC
895 RealVector anisoDimPref;
896 /// the \c cubature_integrand specification in \ref MethodNonDPCE
897 unsigned short cubIntOrder;
898 /// the \c collocation_ratio specification in \ref MethodNonDPCE
899 Real collocationRatio;
900 /// order applied to the number of expansion terms when applying
901 /// or computing the collocation ratio within regression PCE;
902 /// based on the \c ratio_order specification in \ref MethodNonDPCE
903 Real collocRatioTermsOrder;
904 /// type of regression: LS, OMP, BP, BPDN, LARS, or LASSO
905 short regressionType;
906 /// type of least squares regression: SVD or EQ_CON_QR
907 short lsRegressionType;
908 /// noise tolerance(s) for OMP, BPDN, LARS, and LASSO
909 RealVector regressionNoiseTol;
910 /// L2 regression penalty for a variant of LASSO known as the
911 /// elastic net method (default of 0 gives standard LASSO)
912 Real regressionL2Penalty;
913 /// flag indicating the use of cross-validation across expansion orders
914 /// (given a prescribed maximum order) and, for some methods, noise tolerances
915 bool crossValidation;
916 /// flag indicating the restriction of cross-validation to estimate only
917 /// the most effective noise tolerance; used to reduce cost from performing
918 /// CV over both noise tolerances and expansion orders
919 bool crossValidNoiseOnly;
920 // initial grid level for the ADAPTED_BASIS_GENERALIZED approach to
921 // defining the candidate basis for sparse recovery (compressed sensing)
922 //unsigned short adaptedBasisInitLevel;
923 /// initial grid level for the ADAPTED_BASIS_EXPANDING_FRONT approach to
924 /// defining the candidate basis for sparse recovery (compressed sensing)
925 unsigned short adaptedBasisAdvancements;
926 /// flag indicating the output of PCE coefficients corresponding to
927 /// normalized basis polynomials
928 bool normalizedCoeffs;
929 /// allows PCE construction to reuse points from previous sample
930 /// sets or data import using the \c reuse_points specification in
931 /// \ref MethodNonDPCE
932 String pointReuse;
933 /// flag for usage of a sub-sampled set of tensor-product grid points
934 /// within regression PCE; based on the \c tensor_grid specification
935 /// in \ref MethodNonDPCE
936 bool tensorGridFlag;
937 /// order of tensor-product grid points that are sub-sampled within
938 /// orthogonal least interpolation PCE; based on the \c tensor_grid
939 /// specification in \ref MethodNonDPCE
940 UShortArray tensorGridOrder;
941 /// the \c import_expansion_file specification in \ref MethodNonDPCE
942 String importExpansionFile;
943 /// the \c export_expansion_file specification in \ref MethodNonDPCE
944 String exportExpansionFile;
945 /// the \c sample_type specification in \ref MethodNonDMC, \ref
946 /// MethodNonDPCE, and \ref MethodNonDSC
947 unsigned short sampleType;
948 /// whether to generate D-optimal designs
949 bool dOptimal;
950 /// number of candidate designss in D-optimal design selection
951 size_t numCandidateDesigns;
952 /// the type of limit state search in \ref MethodNonDLocalRel
953 /// (\c x_taylor_mean, \c x_taylor_mpp, \c x_two_point, \c u_taylor_mean,
954 /// \c u_taylor_mpp, \c u_two_point, or \c no_approx) or
955 /// \ref MethodNonDGlobalRel (\c x_gaussian_process or \c u_gaussian_process)
956 unsigned short reliabilitySearchType;
957 /// the \c first_order or \c second_order integration selection in
958 /// \ref MethodNonDLocalRel
959 String reliabilityIntegration;
960 /// the \c import, \c adapt_import, or \c mm_adapt_import integration
961 /// refinement selection in \ref MethodNonDLocalRel, \ref MethodNonDPCE,
962 /// and \ref MethodNonDSC
963 unsigned short integrationRefine;
964 /// Sequence of refinement samples, e.g., the size of the batch
965 /// (e.g. number of supplemental points added) to be added to be
966 /// added to the build points for an emulator at each iteration
967 IntVector refineSamples;
968 /// the \c pilot_samples selection in \ref MethodMultilevelMC
969 SizetArray pilotSamples;
970 /// the \c allocationTarget selection in \ref MethodMultilevelMC
971 short allocationTarget;
972 /// the \c useTargetVarianceOptimizationFlag selection in \ref MethodMultilevelMC
973 bool useTargetVarianceOptimizationFlag;
974 /// the |c qoi_aggregation_norm selection in \ref MethodMultilevelMC
975 short qoiAggregation;
976 /// the \c allocation_control selection in \ref MethodMultilevelPCE
977 short multilevAllocControl;
978 /// the \c estimator_rate selection in \ref MethodMultilevelPCE
979 Real multilevEstimatorRate;
980 /// type of discrepancy emulation in multilevel methods: distinct or recursive
981 short multilevDiscrepEmulation;
982 /// the \c final_moments specification in \ref MethodNonD
983 short finalMomentsType;
984 /// the \c distribution \c cumulative or \c complementary specification
985 /// in \ref MethodNonD
986 short distributionType;
987 /// the \c compute \c probabilities, \c reliabilities, or \c
988 /// gen_reliabilities specification in \ref MethodNonD
989 short responseLevelTarget;
990 /// the \c system \c series or \c parallel specification in \ref MethodNonD
991 short responseLevelTargetReduce;
992 /// the \c response_levels specification in \ref MethodNonD
993 RealVectorArray responseLevels;
994 /// the \c probability_levels specification in \ref MethodNonD
995 RealVectorArray probabilityLevels;
996 /// the \c reliability_levels specification in \ref MethodNonD
997 RealVectorArray reliabilityLevels;
998 /// the \c gen_reliability_levels specification in \ref MethodNonD
999 RealVectorArray genReliabilityLevels;
1000 /// the number of MCMC chain samples
1001 int chainSamples;
1002 /// the number of samples to construct an emulator, e.g., for
1003 /// Bayesian calibration methods
1004 int buildSamples;
1005 /// number of samples to perform on emulator
1006 int samplesOnEmulator;
1007 /// The total order to be used in construction of a VPS surrogate
1008 int emulatorOrder;
1009 /// the \c emulator specification in \ref MethodNonDBayesCalib
1010 short emulatorType;
1011 /// the \c mcmc type specification in \ref MethodNonDBayesCalib
1012 String mcmcType;
1013 /// use of standardized probability spaces for MCMC within Bayesian inference
1014 bool standardizedSpace;
1015 /// flag indicating adaptive refinement of the emulator in regions
1016 /// of high posterior probability
1017 bool adaptPosteriorRefine;
1018 /// flag indicating user activation of logit transform option within QUESO
1019 bool logitTransform;
1020 /// whether to apply GPMSA-internal normalization
1021 bool gpmsaNormalize;
1022 /// flag indicating the calculation of KL divergence between prior
1023 /// and posterior in Bayesian methods
1024 bool posteriorStatsKL;
1025 /// flag indicating the calculation of mutual information between prior
1026 /// and posterior in Bayesian methods
1027 bool posteriorStatsMutual;
1028 /// flag indicating calculation of kernel density estimate of posterior
1029 /// distributions
1030 bool posteriorStatsKDE;
1031 /// flag indicating calculation of chain diagnostics
1032 bool chainDiagnostics;
1033 /// flag indicating calculation of confidence intervals as a chain
1034 /// diagnositc
1035 bool chainDiagnosticsCI;
1036 /// flag indicating calculation of the evidence of the model
1037 bool modelEvidence;
1038 /// flag indicating use of Monte Carlo approximation for evidence calc.
1039 bool modelEvidMC;
1040 /// number of prior samples to use in model evidence calculation
1041 int evidenceSamples;
1042 /// flag indicating use of Laplace approximation for evidence calc.
1043 bool modelEvidLaplace;
1044 /// the method used for performing a pre-solve for the MAP point
1045 unsigned short preSolveMethod;
1046 /// the type of proposal covariance: user, derivatives, or prior
1047 String proposalCovType;
1048 /// optional multiplier for prior-based proposal covariance
1049 Real priorPropCovMult;
1050 /// number of samples after which to update the proposal covariance from
1051 /// misfit Hessian (using residual values and derivatives)
1052 int proposalCovUpdatePeriod;
1053 /// the format of proposal covariance input: diagonal or matrix
1054 String proposalCovInputType;
1055 /// raw list of real data for the proposal covariance
1056 RealVector proposalCovData;
1057 /// file from which to read proposal covariance in diagonal or matrix format
1058 String proposalCovFile;
1059 /// file containing advanced ROL option overrides
1060 String advancedOptionsFilename;
1061 /// file containing advanced QUESO option overrides
1062 String quesoOptionsFilename;
1063 /// the \c fitness metric type specification in \ref
1064 /// MethodNonDAdaptive
1065 String fitnessMetricType;
1066 /// the \c batch selection type specification in \ref
1067 /// MethodNonDAdaptive
1068 String batchSelectionType;
1069 /// the \c Lipschitz type specification in \ref
1070 /// MethodNonDPOFDarts (e.g. either local or global estimation)
1071 String lipschitzType;
1072 /// calibration mode for observation error multipliers (CALIBRATE_*)
1073 unsigned short calibrateErrorMode;
1074 /// hyperparameters inverse gamma prior alphas
1075 RealVector hyperPriorAlphas;
1076 /// hyperparameters inverse gamma prior alphas
1077 RealVector hyperPriorBetas;
1078 /// number of MCMC samples to discard from acceptance chain
1079 int burnInSamples;
1080 /// period or skip in post-processing the acceptance chain
1081 int subSamplingPeriod;
1082 /// flag to calculate model discrepancy
1083 bool calModelDiscrepancy;
1084 /// number of prediction configurations at which to calculate model
1085 /// discrepancy
1086 size_t numPredConfigs;
1087 /// list of prediction configurations at which to calculate model discrepancy
1088 RealVector predictionConfigList;
1089 /// whether to import prediction configurations at which to calculate model
1090 /// discrepancy
1091 String importPredConfigs;
1092 /// tabular format for prediction configurations import file
1093 unsigned short importPredConfigFormat;
1094 /// type of model discrepancy emulation
1095 String modelDiscrepancyType;
1096 /// correction order for either gaussian process or polynomial model
1097 /// discrepancy calculations: 0 (=constant), 1 (=linear), 2 (=quadratic)
1098 short approxCorrectionOrder;
1099 /// specify the name of file to which corrected model (model+discrepancy)
1100 /// calculations are output
1101 String exportCorrModelFile;
1102 /// tabular format for corrected model (model+discrepancy) export file
1103 unsigned short exportCorrModelFormat;
1104 /// specify the name of file to which corrected model variance
1105 /// calculations are output
1106 String exportCorrVarFile;
1107 /// tabular format for corrected model variance export file
1108 unsigned short exportCorrVarFormat;
1109 /// specify the name of file to which discrepancy calculations are output
1110 String exportDiscrepFile;
1111 /// tabular format for model discrepancy export file
1112 unsigned short exportDiscrepFormat;
1113 /// whether to perform adaptive Bayesian design of experiments
1114 bool adaptExpDesign;
1115 /// whether to import candidate design points for adaptive Bayesian
1116 /// experimental design
1117 String importCandPtsFile;
1118 /// tabular format for the candidate design points import file
1119 unsigned short importCandFormat;
1120 /// number of candidate designs for adaptive Bayesian experimental design
1121 size_t numCandidates;
1122 /// maximum number of highfidelity model runs to be used for
1123 /// adaptive Bayesian experimental design
1124 int maxHifiEvals;
1125 /// number of optimal designs selected per iteration of experimental design
1126 /// algorithm; also number of concurrent GP refinement points for EGO
1127 int batchSize;
1128 /// portion of batchSize earmarked for exploration rather than acquisition
1129 int batchSizeExplore;
1130 /// indicate that the KSG2 algorithm is to be employed in the calculation
1131 /// of the mutual information
1132 bool mutualInfoKSG2;
1133
1134 // DREAM sub-specification
1135
1136 /// number of concurrent chains
1137 int numChains;
1138 /// number of CR-factors
1139 int numCR;
1140 /// number of crossover chain pairs
1141 int crossoverChainPairs;
1142 /// threshold for the Gelmin-Rubin statistic
1143 Real grThreshold;
1144 /// how often to perform a long jump in generations
1145 int jumpStep;
1146
1147 // WASABI sub-specification
1148 /// Number of samples from the prior that is pushed forward
1149 /// through the model to obtain the initial set of pushforward samples
1150 int numPushforwardSamples;
1151 /// the type of data distribution: kde, or gaussian
1152 String dataDistType;
1153 /// the format of data distribution gaussian covariance input:
1154 /// diagonal or matrix
1155 String dataDistCovInputType;
1156 /// raw list of real data for the data distribution gaussian means
1157 RealVector dataDistMeans;
1158 /// raw list of real data for the data distribution gaussian covariance
1159 RealVector dataDistCovariance;
1160 /// file from which to read data distribution data (covariance or samples )
1161 String dataDistFile;
1162 /// The filename of the export file containing an arbitrary set of
1163 /// samples and their corresponding density values
1164 String posteriorDensityExportFilename;
1165 /// The filename of the export file containing samples from the posterior and
1166 /// their corresponding density values
1167 String posteriorSamplesExportFilename;
1168 /// The filename of the import file containing samples at which the
1169 /// posterior will be evaluated
1170 String posteriorSamplesImportFilename;
1171 /// Flag specifying whether to generate random samples from the posterior
1172 bool generatePosteriorSamples;
1173 /// Flag specifying whether to evaluate the posterior density at a
1174 /// set of samples
1175 bool evaluatePosteriorDensity;
1176
1177 // Parameter Study
1178
1179 /// the \c final_point specification in \ref MethodPSVPS
1180 RealVector finalPoint;
1181 /// the \c step_vector specification in \ref MethodPSVPS and \ref MethodPSCPS
1182 RealVector stepVector;
1183 /// the \c num_steps specification in \ref MethodPSVPS
1184 int numSteps;
1185 /// the \c deltas_per_variable specification in \ref MethodPSCPS
1186 IntVector stepsPerVariable;
1187 /// the \c list_of_points specification in \ref MethodPSLPS
1188 RealVector listOfPoints;
1189 /// the \c import_points_file spec for a file-based parameter study
1190 String pstudyFilename;
1191 /// tabular format for the parameter study points file
1192 unsigned short pstudyFileFormat;
1193 /// whether to import active variables only
1194 bool pstudyFileActive;
1195 /// the \c partitions specification for PStudy method in \ref MethodPSMPS
1196 UShortArray varPartitions;
1197
1198 // Verification
1199
1200 /// rate of mesh refinement in Richardson extrapolation
1201 Real refinementRate;
1202
1203 // File read for surrogates
1204
1205 /// the file name from the \c import_build_points_file specification
1206 String importBuildPtsFile;
1207 /// tabular format for the build point import file
1208 unsigned short importBuildFormat;
1209 /// whether to import active variables only
1210 bool importBuildActive;
1211
1212 /// the file name from the \c import_approx_points_file specification
1213 String importApproxPtsFile;
1214 /// tabular format for the approx point import file
1215 unsigned short importApproxFormat;
1216 /// whether to import active variables only
1217 bool importApproxActive;
1218
1219 /// the file name from the \c export_approx_points_file specification
1220 String exportApproxPtsFile;
1221 /// tabular format for the approx point export file
1222 unsigned short exportApproxFormat;
1223
1224 /// the file name from the \c export_mcmc_points_file specification
1225 String exportMCMCPtsFile;
1226 /// flag for exporting the sequence of sample increments within
1227 /// multilevel sampling from the \c export_sample_sequence specification
1228 bool exportSampleSeqFlag;
1229 /// tabular format for the MCMC chain and MLMC sample sequence exports
1230 unsigned short exportSamplesFormat;
1231
1232 // options for archiving surrogates from EGO, EGRA, EGIE
1233 // (could be unified with other kinds of surrogate exports)
1234
1235 /// Option to turn on surrogate model export (export_model)
1236 bool exportSurrogate;
1237
1238 /// the filename prefix for export_model
1239 String modelExportPrefix;
1240
1241 /// Format selection for export_model
1242 unsigned short modelExportFormat;
1243
1244 private:
1245
1246 //
1247 //- Heading: Constructors, destructor, operators
1248 //
1249
1250 DataMethodRep(); ///< constructor
1251
1252 //
1253 //- Heading: Member methods
1254 //
1255
1256 /// write a DataInterfaceRep object to an std::ostream
1257 void write(std::ostream& s) const;
1258
1259 /// read a DataInterfaceRep object from a packed MPI buffer
1260 void read(MPIUnpackBuffer& s);
1261 /// write a DataInterfaceRep object to a packed MPI buffer
1262 void write(MPIPackBuffer& s) const;
1263
1264 //
1265 //- Heading: Private data members
1266 //
1267
1268 };
1269
1270
~DataMethodRep()1271 inline DataMethodRep::~DataMethodRep() { }
1272
1273
1274 /// Handle class for method specification data.
1275
1276 /** The DataMethod class is used to provide a memory management handle
1277 for the data in DataMethodRep. It is populated by
1278 IDRProblemDescDB::method_kwhandler() and is queried by the
1279 ProblemDescDB::get_<datatype>() functions. A list of DataMethod
1280 objects is maintained in ProblemDescDB::dataMethodList, one for
1281 each method specification in an input file. */
1282
1283 class DataMethod
1284 {
1285 //
1286 //- Heading: Friends
1287 //
1288
1289 // the problem description database
1290 friend class ProblemDescDB;
1291 // the NIDR derived problem description database
1292 friend class NIDRProblemDescDB;
1293
1294 public:
1295
1296 /// compares the idMethod attribute of DataMethod objects
id_compare(const DataMethod & dm,const std::string & id)1297 static bool id_compare(const DataMethod& dm, const std::string& id)
1298 { return id == dm.dataMethodRep->idMethod; }
1299
1300 //
1301 //- Heading: Constructors, destructor, operators
1302 //
1303
1304 DataMethod(); ///< constructor
1305 DataMethod(const DataMethod&); ///< copy constructor
1306 ~DataMethod(); ///< destructor
1307
1308 DataMethod& operator=(const DataMethod&); ///< assignment operator
1309
1310 //
1311 //- Heading: Member methods
1312 //
1313
1314 /// write a DataMethod object to an std::ostream
1315 void write(std::ostream& s) const;
1316
1317 /// read a DataMethod object from a packed MPI buffer
1318 void read(MPIUnpackBuffer& s);
1319 /// write a DataMethod object to a packed MPI buffer
1320 void write(MPIPackBuffer& s) const;
1321
1322 /// return dataMethodRep
1323 std::shared_ptr<DataMethodRep> data_rep();
1324
1325 private:
1326
1327 //
1328 //- Heading: Data
1329 //
1330
1331 /// pointer to the body (handle-body idiom)
1332 std::shared_ptr<DataMethodRep> dataMethodRep;
1333 };
1334
1335
data_rep()1336 inline std::shared_ptr<DataMethodRep> DataMethod::data_rep()
1337 {return dataMethodRep; }
1338
1339
1340 /// MPIPackBuffer insertion operator for DataMethod
operator <<(MPIPackBuffer & s,const DataMethod & data)1341 inline MPIPackBuffer& operator<<(MPIPackBuffer& s, const DataMethod& data)
1342 { data.write(s); return s; }
1343
1344
1345 /// MPIUnpackBuffer extraction operator for DataMethod
operator >>(MPIUnpackBuffer & s,DataMethod & data)1346 inline MPIUnpackBuffer& operator>>(MPIUnpackBuffer& s, DataMethod& data)
1347 { data.read(s); return s; }
1348
1349
1350 /// std::ostream insertion operator for DataMethod
operator <<(std::ostream & s,const DataMethod & data)1351 inline std::ostream& operator<<(std::ostream& s, const DataMethod& data)
1352 { data.write(s); return s; }
1353
write(std::ostream & s) const1354 inline void DataMethod::write(std::ostream& s) const
1355 { dataMethodRep->write(s); }
1356
1357
read(MPIUnpackBuffer & s)1358 inline void DataMethod::read(MPIUnpackBuffer& s)
1359 { dataMethodRep->read(s); }
1360
1361
write(MPIPackBuffer & s) const1362 inline void DataMethod::write(MPIPackBuffer& s) const
1363 { dataMethodRep->write(s); }
1364
1365 } // namespace Dakota
1366
1367 #endif
1368