Class for using global nongradient-based optimization approaches to calculate interval bounds for epistemic uncertainty quantification.
More...
|
|
| NonDGlobalInterval (ProblemDescDB &problem_db, Model &model) |
| | constructor
|
| |
|
| ~NonDGlobalInterval () |
| | destructor
|
| |
|
void | derived_init_communicators (ParLevLIter pl_iter) |
| | derived class contributions to initializing the communicators associated with this Iterator instance
|
| |
|
void | derived_set_communicators (ParLevLIter pl_iter) |
| | derived class contributions to setting the communicators associated with this Iterator instance
|
| |
|
void | derived_free_communicators (ParLevLIter pl_iter) |
| | derived class contributions to freeing the communicators associated with this Iterator instance
|
| |
|
void | core_run () |
| | Performs an optimization to determine interval bounds for an entire function or interval bounds on a particular statistical estimator.
|
| |
| const Model & | algorithm_space_model () const |
| |
|
| NonDInterval (ProblemDescDB &problem_db, Model &model) |
| | constructor
|
| |
|
| ~NonDInterval () |
| | destructor
|
| |
|
void | print_results (std::ostream &s, short results_state=FINAL_RESULTS) |
| | print the cumulative distribution functions for belief and plausibility
|
| |
|
bool | resize () |
| | reinitializes iterator based on new variable size
|
| |
|
void | requested_levels (const RealVectorArray &req_resp_levels, const RealVectorArray &req_prob_levels, const RealVectorArray &req_rel_levels, const RealVectorArray &req_gen_rel_levels, short resp_lev_tgt, short resp_lev_tgt_reduce, bool cdf_flag, bool pdf_output) |
| | set requestedRespLevels, requestedProbLevels, requestedRelLevels, requestedGenRelLevels, respLevelTarget, cdfFlag, and pdfOutput (used in combination with alternate ctors)
|
| |
|
void | print_level_mappings (std::ostream &s) const |
| | prints the z/p/beta/beta* mappings reflected in {requested,computed}{Resp,Prob,Rel,GenRel}Levels for default qoi_type and qoi_labels
|
| |
| void | print_level_mappings (std::ostream &s, String qoi_type, const StringArray &qoi_labels) const |
| | prints the z/p/beta/beta* mappings reflected in {requested,computed}{Resp,Prob,Rel,GenRel}Levels More...
|
| |
| void | print_level_mappings (std::ostream &s, const RealVector &level_maps, bool moment_offset, const String &prepend="") |
| | print level mapping statistics using optional pre-pend More...
|
| |
|
bool | pdf_output () const |
| | get pdfOutput
|
| |
|
void | pdf_output (bool output) |
| | set pdfOutput
|
| |
|
short | final_moments_type () const |
| | get finalMomentsType
|
| |
|
void | final_moments_type (short type) |
| | set finalMomentsType
|
| |
|
const VariablesArray & | all_variables () |
| | return the complete set of evaluated variables
|
| |
|
const RealMatrix & | all_samples () |
| | return the complete set of evaluated samples
|
| |
|
const IntResponseMap & | all_responses () const |
| | return the complete set of computed responses
|
| |
| size_t | num_samples () const |
| |
|
virtual void | vary_pattern (bool pattern_flag) |
| | sets varyPattern in derived classes that support it
|
| |
| | Iterator (std::shared_ptr< TraitsBase > traits=std::shared_ptr< TraitsBase >(new TraitsBase())) |
| | default constructor More...
|
| |
| | Iterator (ProblemDescDB &problem_db, std::shared_ptr< TraitsBase > traits=std::shared_ptr< TraitsBase >(new TraitsBase())) |
| | standard envelope constructor, which constructs its own model(s) More...
|
| |
| | Iterator (ProblemDescDB &problem_db, Model &model, std::shared_ptr< TraitsBase > traits=std::shared_ptr< TraitsBase >(new TraitsBase())) |
| | alternate envelope constructor which uses the ProblemDescDB but accepts a model from a higher level (meta-iterator) context, instead of constructing its own More...
|
| |
| | Iterator (const String &method_string, Model &model, std::shared_ptr< TraitsBase > traits=std::shared_ptr< TraitsBase >(new TraitsBase())) |
| | alternate envelope constructor for instantiations by name without the ProblemDescDB More...
|
| |
| | Iterator (const Iterator &iterator) |
| | copy constructor More...
|
| |
|
virtual | ~Iterator () |
| | destructor
|
| |
|
Iterator | operator= (const Iterator &iterator) |
| | assignment operator
|
| |
|
virtual void | post_input () |
| | read tabular data for post-run mode
|
| |
|
virtual void | reset () |
| | restore initial state for repeated sub-iterator executions
|
| |
|
virtual void | nested_variable_mappings (const SizetArray &c_index1, const SizetArray &di_index1, const SizetArray &ds_index1, const SizetArray &dr_index1, const ShortArray &c_target2, const ShortArray &di_target2, const ShortArray &ds_target2, const ShortArray &dr_target2) |
| | set primaryA{CV,DIV,DRV}MapIndices, secondaryA{CV,DIV,DRV}MapTargets within derived Iterators; supports computation of higher-level sensitivities in nested contexts (e.g., derivatives of statistics w.r.t. inserted design variables)
|
| |
|
virtual void | nested_response_mappings (const RealMatrix &primary_coeffs, const RealMatrix &secondary_coeffs) |
| | set primaryResponseCoefficients, secondaryResponseCoefficients within derived Iterators; Necessary for scalarization case in MLMC NonDMultilevelSampling to map scalarization in nested context
|
| |
|
virtual void | initialize_iterator (int job_index) |
| | used by IteratorScheduler to set the starting data for a run
|
| |
|
virtual void | pack_parameters_buffer (MPIPackBuffer &send_buffer, int job_index) |
| | used by IteratorScheduler to pack starting data for an iterator run
|
| |
|
virtual void | unpack_parameters_buffer (MPIUnpackBuffer &recv_buffer, int job_index) |
| | used by IteratorScheduler to unpack starting data for an iterator run
|
| |
|
virtual void | unpack_parameters_initialize (MPIUnpackBuffer &recv_buffer, int job_index) |
| | used by IteratorScheduler to unpack starting data and initialize an iterator run
|
| |
|
virtual void | pack_results_buffer (MPIPackBuffer &send_buffer, int job_index) |
| | used by IteratorScheduler to pack results data from an iterator run
|
| |
|
virtual void | unpack_results_buffer (MPIUnpackBuffer &recv_buffer, int job_index) |
| | used by IteratorScheduler to unpack results data from an iterator run
|
| |
|
virtual void | update_local_results (int job_index) |
| | used by IteratorScheduler to update local results arrays
|
| |
|
virtual const RealSymMatrix & | response_error_estimates () const |
| | return error estimates associated with the final iterator solution
|
| |
|
virtual bool | accepts_multiple_points () const |
| | indicates if this iterator accepts multiple initial points. Default return is false. Override to return true if appropriate.
|
| |
|
virtual void | initial_point (const Variables &pt) |
| | sets the initial point for this iterator (user-functions mode for which Model updating is not used)
|
| |
|
virtual void | initial_point (const RealVector &pt) |
| | sets the initial point (active continuous variables) for this iterator (user-functions mode for which Model updating is not used)
|
| |
|
virtual void | initial_points (const VariablesArray &pts) |
| | sets the multiple initial points for this iterator. This should only be used if accepts_multiple_points() returns true.
|
| |
|
virtual void | update_callback_data (const RealVector &cv_initial, const RealVector &cv_lower_bnds, const RealVector &cv_upper_bnds, const RealMatrix &lin_ineq_coeffs, const RealVector &lin_ineq_lb, const RealVector &lin_ineq_ub, const RealMatrix &lin_eq_coeffs, const RealVector &lin_eq_tgt, const RealVector &nln_ineq_lb, const RealVector &nln_ineq_ub, const RealVector &nln_eq_tgt) |
| | assign variable values and bounds and constraint coefficients and bounds for this iterator (user-functions mode for which iteratedModel is null)
|
| |
|
virtual const RealMatrix & | callback_linear_ineq_coefficients () const |
| | return linear constraint coefficients for this iterator (user-functions mode for which iteratedModel is null)
|
| |
|
virtual const RealVector & | callback_linear_ineq_lower_bounds () const |
| | return linear constraint lower bounds for this iterator (user-functions mode for which iteratedModel is null)
|
| |
|
virtual const RealVector & | callback_linear_ineq_upper_bounds () const |
| | return linear constraint upper bounds for this iterator (user-functions mode for which iteratedModel is null)
|
| |
| virtual void | initialize_graphics (int iterator_server_id=1) |
| | initialize the 2D graphics window and the tabular graphics data More...
|
| |
| virtual void | check_sub_iterator_conflict () |
| | detect any conflicts due to recursive use of the same Fortran solver More...
|
| |
|
virtual unsigned short | uses_method () const |
| | return name of any enabling iterator used by this iterator
|
| |
|
virtual void | method_recourse (unsigned short method_name) |
| | perform a method switch, if possible, due to a detected conflict with the simultaneous use of method_name at an higher-level
|
| |
|
virtual void | sampling_reset (size_t min_samples, bool all_data_flag, bool stats_flag) |
| | reset sampling iterator to use at least min_samples
|
| |
|
virtual void | sampling_reference (size_t samples_ref) |
| | set reference number of samples, which is a lower bound during reset
|
| |
|
virtual void | sampling_increment () |
| | increment to next in sequence of refinement samples
|
| |
|
virtual void | random_seed (int seed) |
| | set randomSeed, if present
|
| |
|
virtual unsigned short | sampling_scheme () const |
| | return sampling name
|
| |
|
virtual IntIntPair | estimate_partition_bounds () |
| | estimate the minimum and maximum partition sizes that can be utilized by this Iterator
|
| |
|
virtual void | declare_sources () |
| | Declare sources to the evaluations database.
|
| |
|
void | init_communicators (ParLevLIter pl_iter) |
| | initialize the communicators associated with this Iterator instance
|
| |
|
void | set_communicators (ParLevLIter pl_iter) |
| | set the communicators associated with this Iterator instance
|
| |
|
void | free_communicators (ParLevLIter pl_iter) |
| | free the communicators associated with this Iterator instance
|
| |
|
void | resize_communicators (ParLevLIter pl_iter, bool reinit_comms) |
| | Resize the communicators. This is called from the letter's resize()
|
| |
|
void | parallel_configuration_iterator (ParConfigLIter pc_iter) |
| | set methodPCIter
|
| |
|
ParConfigLIter | parallel_configuration_iterator () const |
| | return methodPCIter
|
| |
|
void | parallel_configuration_iterator_map (std::map< size_t, ParConfigLIter > pci_map) |
| | set methodPCIterMap
|
| |
|
std::map< size_t, ParConfigLIter > | parallel_configuration_iterator_map () const |
| | return methodPCIterMap
|
| |
|
void | run (ParLevLIter pl_iter) |
| | invoke set_communicators(pl_iter) prior to run()
|
| |
| void | run () |
| | orchestrate initialize/pre/core/post/finalize phases More...
|
| |
| void | assign_rep (std::shared_ptr< Iterator > iterator_rep) |
| | replaces existing letter with a new one More...
|
| |
|
void | iterated_model (const Model &model) |
| | set the iteratedModel (iterators and meta-iterators using a single model instance)
|
| |
|
Model & | iterated_model () |
| | return the iteratedModel (iterators & meta-iterators using a single model instance)
|
| |
|
ProblemDescDB & | problem_description_db () const |
| | return the problem description database (probDescDB)
|
| |
|
ParallelLibrary & | parallel_library () const |
| | return the parallel library (parallelLib)
|
| |
|
void | method_name (unsigned short m_name) |
| | set the method name to an enumeration value
|
| |
|
unsigned short | method_name () const |
| | return the method name via its native enumeration value
|
| |
|
void | method_string (const String &m_str) |
| | set the method name by string
|
| |
|
String | method_string () const |
| | return the method name by string
|
| |
|
String | method_enum_to_string (unsigned short method_enum) const |
| | convert a method name enumeration value to a string
|
| |
|
unsigned short | method_string_to_enum (const String &method_str) const |
| | convert a method name string to an enumeration value
|
| |
|
String | submethod_enum_to_string (unsigned short submethod_enum) const |
| | convert a sub-method name enumeration value to a string
|
| |
|
const String & | method_id () const |
| | return the method identifier (methodId)
|
| |
|
int | maximum_evaluation_concurrency () const |
| | return the maximum evaluation concurrency supported by the iterator
|
| |
|
void | maximum_evaluation_concurrency (int max_conc) |
| | set the maximum evaluation concurrency supported by the iterator
|
| |
|
size_t | maximum_iterations () const |
| | return the maximum iterations for this iterator
|
| |
|
void | maximum_iterations (size_t max_iter) |
| | set the maximum iterations for this iterator
|
| |
|
void | convergence_tolerance (Real conv_tol) |
| | set the method convergence tolerance (convergenceTol)
|
| |
|
Real | convergence_tolerance () const |
| | return the method convergence tolerance (convergenceTol)
|
| |
|
void | output_level (short out_lev) |
| | set the method output level (outputLevel)
|
| |
|
short | output_level () const |
| | return the method output level (outputLevel)
|
| |
|
void | summary_output (bool summary_output_flag) |
| | Set summary output control; true enables evaluation/results summary.
|
| |
|
size_t | num_final_solutions () const |
| | return the number of solutions to retain in best variables/response arrays
|
| |
|
void | num_final_solutions (size_t num_final) |
| | set the number of solutions to retain in best variables/response arrays
|
| |
|
void | active_set (const ActiveSet &set) |
| | set the default active set (for use with iterators that employ evaluate_parameter_sets())
|
| |
|
const ActiveSet & | active_set () const |
| | return the default active set (used by iterators that employ evaluate_parameter_sets())
|
| |
|
void | active_set_request_vector (const ShortArray &asv) |
| | return the default active set request vector (used by iterators that employ evaluate_parameter_sets())
|
| |
|
const ShortArray & | active_set_request_vector () const |
| | return the default active set request vector (used by iterators that employ evaluate_parameter_sets())
|
| |
|
void | active_set_request_values (short asv_val) |
| | return the default active set request vector (used by iterators that employ evaluate_parameter_sets())
|
| |
|
void | sub_iterator_flag (bool si_flag) |
| | set subIteratorFlag (and update summaryOutputFlag if needed)
|
| |
|
bool | is_null () const |
| | function to check iteratorRep (does this envelope contain a letter?)
|
| |
|
std::shared_ptr< Iterator > | iterator_rep () const |
| | returns iteratorRep for access to derived class member functions that are not mapped to the top Iterator level
|
| |
| virtual void | eval_tag_prefix (const String &eval_id_str) |
| | set the hierarchical eval ID tag prefix More...
|
| |
|
std::shared_ptr< TraitsBase > | traits () const |
| | returns methodTraits for access to derived class member functions that are not mapped to the top TraitsBase level
|
| |
|
bool | top_level () |
| | Return whether the iterator is the top level iterator.
|
| |
|
void | top_level (bool tflag) |
| | Set the iterator's top level flag.
|
| |
|
|
virtual void | initialize () |
| | perform any required initialization
|
| |
|
virtual void | set_cell_bounds () |
| | set the optimization variable bounds for each cell
|
| |
|
virtual void | get_best_sample (bool maximize, bool eval_approx) |
| | determine truthFnStar and approxFnStar
|
| |
|
virtual void | post_process_cell_results (bool maximize) |
| | post-process a cell minimization/maximization result
|
| |
|
virtual void | post_process_response_fn_results () |
| | post-process the interval computed for a response function
|
| |
|
virtual void | post_process_final_results () |
| | perform final post-processing
|
| |
|
void | post_process_run_results (bool maximize) |
| | post-process an optimization execution: output results, update convergence controls, and update GP approximation
|
| |
|
void | evaluate_response_star_truth () |
| | evaluate the truth response at the optimal variables solution and update the GP with the new data
|
| |
|
void | initialize_final_statistics () |
| | initialize finalStatistics for belief/plausibility results sets
|
| |
|
void | compute_evidence_statistics () |
| | method for computing belief and plausibility values for response levels or vice-versa
|
| |
|
void | calculate_cells_and_bpas () |
| | computes the interval combinations (cells) and their bpas replaces CBPIIC_F77 from wrapper calculate_basic_prob_intervals()
|
| |
|
void | calculate_cbf_cpf (bool complementary=true) |
| | function to compute (complementary) distribution functions on belief and plausibility replaces CCBFPF_F77 from wrapper calculate_cum_belief_plaus()
|
| |
|
| NonD (ProblemDescDB &problem_db, Model &model) |
| | constructor
|
| |
|
| NonD (unsigned short method_name, Model &model) |
| | alternate constructor for sample generation and evaluation "on the fly"
|
| |
|
| NonD (unsigned short method_name, Model &model, const ShortShortPair &approx_view) |
| | alternate constructor for sample generation and evaluation "on the fly"
|
| |
|
| NonD (unsigned short method_name, const RealVector &lower_bnds, const RealVector &upper_bnds) |
| | alternate constructor for sample generation "on the fly"
|
| |
|
| ~NonD () |
| | destructor
|
| |
| void | initialize_run () |
| | utility function to perform common operations prior to pre_run(); typically memory initialization; setting of instance pointers More...
|
| |
| void | finalize_run () |
| | utility function to perform common operations following post_run(); deallocation and resetting of instance pointers More...
|
| |
|
const Response & | response_results () const |
| | return the final statistics from the nondeterministic iteration
|
| |
|
void | response_results_active_set (const ActiveSet &set) |
| | set the active set within finalStatistics
|
| |
|
virtual void | initialize_response_covariance () |
| | initializes respCovariance
|
| |
|
virtual void | update_final_statistics () |
| | update finalStatistics::functionValues
|
| |
|
virtual bool | discrepancy_sample_counts () const |
| | flag identifying whether sample counts correspond to level discrepancies
|
| |
|
void | pull_level_mappings (RealVector &level_maps, size_t offset) |
| | concatenate computed{Resp,Prob,Rel,GenRel}Levels into level_maps
|
| |
|
void | push_level_mappings (const RealVector &level_maps, size_t offset) |
| | update computed{Resp,Prob,Rel,GenRel}Levels from level_maps
|
| |
| void | configure_1d_sequence (size_t &num_steps, size_t &secondary_index, short &seq_type) |
| | configure a one-dimensional hierarchical sequence (ML or MF) More...
|
| |
| void | configure_2d_sequence (size_t &num_steps, size_t &secondary_index, short &seq_type) |
| | configure a two-dimensional hierarchical sequence (MLMF) More...
|
| |
| void | configure_enumeration (size_t &num_combinations, short &seq_type) |
| | configure the total number of model form/resolution level options More...
|
| |
|
short | configure_cost (size_t num_steps, short seq_type, RealVector &cost) |
| | extract cost estimates from model ensemble, enforcing requirements (case without metadata support)
|
| |
|
short | configure_cost (size_t num_steps, short seq_type, RealVector &cost, SizetSizetPairArray &cost_md_indices) |
| | extract cost estimates from model ensemble, enforcing requirements (case with metadata support)
|
| |
|
short | query_cost (size_t num_steps, short seq_type, RealVector &cost) |
| | optionally extract cost estimates from model ensemble, if available (case without metadata support)
|
| |
|
short | query_cost (size_t num_steps, short seq_type, RealVector &cost, BitArray &model_cost_spec, const SizetSizetPairArray &cost_md_indices) |
| | optionally extract cost estimates from model ensemble, if available (case with metadata support)
|
| |
|
void | test_cost (short seq_type, const BitArray &model_cost_spec, SizetSizetPairArray &cost_md_indices) |
| | check cost specification and metadata indices for each active model
|
| |
|
bool | test_cost (bool cost_spec, SizetSizetPair &cost_md_indices, const String &model_id) |
| | check cost specification and metadata indices for a given model
|
| |
|
bool | valid_cost (Real cost) const |
| | test cost for value > 0
|
| |
|
bool | valid_costs (const RealVector &costs) const |
| | test costs for valid values > 0
|
| |
|
void | load_pilot_sample (const SizetArray &pilot_spec, size_t num_steps, SizetArray &delta_N_l) |
| | distribute pilot sample specification across model forms or levels
|
| |
|
void | load_pilot_sample (const SizetArray &pilot_spec, short seq_type, const Sizet3DArray &N_l, Sizet2DArray &delta_N_l) |
| | distribute pilot sample specification across model forms and levels
|
| |
|
template<typename ArrayType > |
| void | inflate_approx_samples (const ArrayType &N_l, bool multilev, size_t secondary_index, std::vector< ArrayType > &N_l_vec) |
| | update the relevant slice of N_l_3D from the final 2D multilevel or 2D multifidelity sample profile
|
| |
|
template<typename ArrayType > |
| void | inflate_sequence_samples (const ArrayType &N_l, bool multilev, size_t secondary_index, std::vector< ArrayType > &N_l_vec) |
| | update the relevant slice of N_l_3D from the final 2D multilevel or 2D multifidelity sample profile
|
| |
|
void | resize_final_statistics_gradients () |
| | resizes finalStatistics::functionGradients based on finalStatistics ASV
|
| |
|
void | update_aleatory_final_statistics () |
| | update finalStatistics::functionValues from momentStats and computed{Prob,Rel,GenRel,Resp}Levels
|
| |
|
void | update_system_final_statistics () |
| | update system metrics from component metrics within finalStatistics
|
| |
|
void | update_system_final_statistics_gradients () |
| | update finalStatistics::functionGradients
|
| |
|
void | initialize_level_mappings () |
| | size computed{Resp,Prob,Rel,GenRel}Levels
|
| |
| void | compute_densities (const RealRealPairArray &min_max_fns, bool prob_refinement=false, bool all_levels_computed=false) |
| | compute the PDF bins from the CDF/CCDF values and store in computedPDF{Abscissas,Ordinates} More...
|
| |
|
void | print_densities (std::ostream &s) const |
| | output the PDFs reflected in computedPDF{Abscissas,Ordinates} using default qoi_type and pdf_labels
|
| |
|
void | print_densities (std::ostream &s, String qoi_type, const StringArray &pdf_labels) const |
| | output the PDFs reflected in computedPDF{Abscissas,Ordinates}
|
| |
|
void | print_system_mappings (std::ostream &s) const |
| | print system series/parallel mappings for response levels
|
| |
|
void | print_multilevel_evaluation_summary (std::ostream &s, const SizetArray &N_m) |
| | print evaluation summary for multilevel sampling across 1D level profile
|
| |
|
void | print_multilevel_evaluation_summary (std::ostream &s, const Sizet2DArray &N_m) |
| | print evaluation summary for multilevel sampling across 2D level+QoI profile
|
| |
|
void | print_multilevel_discrepancy_summary (std::ostream &s, const SizetArray &N_m) |
| | print evaluation summary for multilevel sampling across 1D level profile for discrepancy across levels
|
| |
|
void | print_multilevel_discrepancy_summary (std::ostream &s, const SizetArray &N_m, const SizetArray &N_mp1) |
| | print evaluation summary for multilevel sampling across 1D level profile for discrepancy across model forms
|
| |
|
void | print_multilevel_discrepancy_summary (std::ostream &s, const Sizet2DArray &N_m) |
| | print evaluation summary for multilevel sampling across 2D level+QoI profile for discrepancy across levels
|
| |
|
void | print_multilevel_discrepancy_summary (std::ostream &s, const Sizet2DArray &N_m, const Sizet2DArray &N_mp1) |
| | print evaluation summary for multilevel sampling across 2D level+QoI profile for discrepancy across model forms
|
| |
|
template<typename ArrayType > |
| void | print_multilevel_model_summary (std::ostream &s, const std::vector< ArrayType > &N_samp, String type, short seq_type, bool discrep_flag) |
| | print evaluation summary for multilevel sampling across 2D model+level profile (allocations) or 3D model+level+QoI profile (actual)
|
| |
|
void | construct_lhs (Iterator &u_space_sampler, Model &u_model, unsigned short sample_type, int num_samples, int seed, const String &rng, bool vary_pattern, short sampling_vars_mode=ACTIVE) |
| | assign a NonDLHSSampling instance within u_space_sampler
|
| |
|
unsigned short | sub_optimizer_select (unsigned short requested_sub_method, unsigned short default_sub_method=SUBMETHOD_NPSOL) |
| | utility for vetting sub-method request against optimizers within the package configuration
|
| |
|
size_t | one_sided_relax_round (Real diff, Real relax_factor=1.) |
| | compute a one-sided sample increment for multilevel methods to move current sampling level to a new target
|
| |
|
size_t | one_sided_delta (Real current, Real target, Real relax_factor=1.) |
| | compute a one-sided sample increment for multilevel methods to move current sampling level to a new target
|
| |
|
size_t | one_sided_delta (const SizetArray ¤t, const RealVector &targets, Real relax_factor=1., size_t power=1) |
| | compute a one-sided sample increment for multilevel methods to move current sampling level to a new target
|
| |
|
size_t | one_sided_delta (const SizetArray ¤t, Real target, Real relax_factor=1., size_t power=1) |
| | compute a one-sided sample increment for multilevel methods to move current sampling level to a new target
|
| |
|
void | one_sided_delta (const SizetArray ¤t, const RealVector &targets, SizetArray &delta_N, Real relax_factor=1.) |
| | compute a one-sided sample increment vector to move current sampling levels to new targets
|
| |
|
void | one_sided_delta (const Sizet2DArray ¤t, const RealVector &targets, SizetArray &delta_N, Real relax_factor=1.) |
| | compute a one-sided sample increment vector to move current sampling levels to new targets
|
| |
|
bool | differ (size_t N_alloc_ij, const SizetArray &N_actual_ij) const |
| | return true if fine-grained reporting differs from coarse-grained
|
| |
|
bool | differ (const SizetArray &N_alloc_i, const Sizet2DArray &N_actual_i) const |
| | return true if fine-grained reporting differs from coarse-grained
|
| |
|
bool | differ (const Sizet2DArray &N_alloc, const Sizet3DArray &N_actual) const |
| | return true if fine-grained reporting differs from coarse-grained
|
| |
|
void | archive_allocate_mappings () |
| | allocate results array storage for distribution mappings
|
| |
|
void | archive_from_resp (size_t fn_index, size_t inc_id=0) |
| | archive the mappings from specified response levels for specified fn
|
| |
|
void | archive_to_resp (size_t fn_index, size_t inc_id=0) |
| | archive the mappings to computed response levels for specified fn and (optional) increment id.
|
| |
|
void | archive_allocate_pdf () |
| | allocate results array storage for pdf histograms
|
| |
|
void | archive_pdf (size_t fn_index, size_t inc_id=0) |
| | archive a single pdf histogram for specified function
|
| |
|
void | archive_equiv_hf_evals (const Real equiv_hf_evals) |
| | archive the equivalent number of HF evals (used by ML/MF methods)
|
| |
|
bool | zeros (const SizetArray &N_m) const |
| | return true if N_m is empty or only populated with zeros
|
| |
|
bool | zeros (const Sizet2DArray &N_m) const |
| | return true if N_m is empty or only populated with zeros
|
| |
|
bool | zeros (const SizetVector &N_m) const |
| | return true if N_m is empty or only populated with zeros
|
| |
|
bool | homogeneous (const SizetArray &N_l) const |
| | return true if N_l has consistent values
|
| |
|
| Analyzer () |
| | default constructor
|
| |
|
| Analyzer (ProblemDescDB &problem_db, Model &model) |
| | standard constructor
|
| |
|
| Analyzer (unsigned short method_name, Model &model) |
| | alternate constructor for instantiations "on the fly" with a Model
|
| |
|
| Analyzer (unsigned short method_name, Model &model, const ShortShortPair &view_override) |
| | alternate constructor for instantiations "on the fly" with a Model
|
| |
|
| Analyzer (unsigned short method_name) |
| | alternate constructor for instantiations "on the fly" without a Model
|
| |
|
| ~Analyzer () |
| | destructor
|
| |
|
virtual void | get_parameter_sets (Model &model) |
| | Generate one block of numSamples samples (ndim * num_samples), populating allSamples; ParamStudy is the only class that specializes to use allVariables.
|
| |
|
virtual void | get_parameter_sets (Model &model, const size_t num_samples, RealMatrix &design_matrix) |
| | Generate one block of numSamples samples (ndim * num_samples), populating design_matrix.
|
| |
|
virtual void | update_model_from_sample (Model &model, const Real *sample_vars) |
| | update model's current variables with data from sample
|
| |
|
virtual void | update_model_from_variables (Model &model, const Variables &vars) |
| | update model's current variables with data from vars
|
| |
| virtual void | sample_to_variables (const Real *sample_vars, Variables &vars) |
| | convert column of samples array to variables; derived classes may reimplement for more than active continuous variables More...
|
| |
|
void | update_from_model (const Model &model) |
| | set inherited data attributes based on extractions from incoming model
|
| |
| void | pre_run () |
| | pre-run portion of run (optional); re-implemented by Iterators which can generate all Variables (parameter sets) a priori More...
|
| |
| void | post_run (std::ostream &s) |
| | post-run portion of run (optional); verbose to print results; re-implemented by Iterators that can read all Variables/Responses and perform final analysis phase in a standalone way More...
|
| |
| void | pre_output () |
| |
|
const Variables & | variables_results () const |
| | return a single final iterator solution (variables)
|
| |
|
const VariablesArray & | variables_array_results () |
| | return multiple final iterator solutions (variables). This should only be used if returns_multiple_points() returns true.
|
| |
|
const ResponseArray & | response_array_results () |
| | return multiple final iterator solutions (response). This should only be used if returns_multiple_points() returns true.
|
| |
|
bool | compact_mode () const |
| | returns Analyzer::compactMode
|
| |
|
bool | returns_multiple_points () const |
| | indicates if this iterator returns multiple final points. Default return is false. Override to return true if appropriate.
|
| |
| void | evaluate_parameter_sets (Model &model, bool log_resp_flag=true, bool log_best_flag=false) |
| | perform function evaluations to map parameter sets (allVariables) into response sets (allResponses) More...
|
| |
|
void | evaluate_batch (Model &model, int batch_id, bool log_best_flag=false) |
| | perform function evaluations to map a keyed batch of parameter sets (allVariablesMap[key]) into a corresponding batch of response sets (allResponsesMap[key])
|
| |
|
const IntIntResponse2DMap & | synchronize_batches (Model &model, bool log_best_flag=false) |
| | perform function evaluations to map a keyed batch of parameter sets (allVariablesMap[key]) into a corresponding batch of response sets (allResponsesMap[key])
|
| |
|
void | clear_batches () |
| | since synchronize returns the aggregation of all evaluated batches, we use a separate call to indicate when processing of this data is complete and bookkeeping can be cleared
|
| |
| void | get_vbd_parameter_sets (Model &model, size_t num_samples) |
| | generate replicate parameter sets for use in variance-based decomposition More...
|
| |
|
virtual void | archive_model_variables (const Model &, size_t idx) const |
| | archive model evaluation points
|
| |
|
virtual void | archive_model_response (const Response &, size_t idx) const |
| | archive model evaluation responses
|
| |
| void | read_variables_responses (int num_evals, size_t num_vars) |
| | convenience function for reading variables/responses (used in derived classes post_input) More...
|
| |
|
void | samples_to_variables_array (const RealMatrix &sample_matrix, VariablesArray &vars_array) |
| | convert samples array to variables array; e.g., allSamples to allVariables
|
| |
| virtual void | variables_to_sample (const Variables &vars, Real *sample_c_vars) |
| | convert the active continuous variables into a column of allSamples More...
|
| |
|
void | variables_array_to_samples (const VariablesArray &vars_array, RealMatrix &sample_matrix) |
| | convert variables array to samples array; e.g., allVariables to allSamples
|
| |
| | Iterator (BaseConstructor, ProblemDescDB &problem_db, std::shared_ptr< TraitsBase > traits=std::shared_ptr< TraitsBase >(new TraitsBase())) |
| | constructor initializes the base class part of letter classes (BaseConstructor overloading avoids infinite recursion in the derived class constructors - Coplien, p. 139) More...
|
| |
| | Iterator (NoDBBaseConstructor, unsigned short method_name, Model &model, std::shared_ptr< TraitsBase > traits=std::shared_ptr< TraitsBase >(new TraitsBase())) |
| | alternate constructor for base iterator classes constructed on the fly More...
|
| |
| | Iterator (NoDBBaseConstructor, unsigned short method_name, std::shared_ptr< TraitsBase > traits=std::shared_ptr< TraitsBase >(new TraitsBase())) |
| | alternate constructor for base iterator classes constructed on the fly More...
|
| |
| | Iterator (NoDBBaseConstructor, Model &model, size_t max_iter, size_t max_eval, Real conv_tol, std::shared_ptr< TraitsBase > traits=std::shared_ptr< TraitsBase >(new TraitsBase())) |
| | alternate envelope constructor for instantiations without ProblemDescDB More...
|
| |
|
virtual const VariablesArray & | initial_points () const |
| | gets the multiple initial points for this iterator. This will only be meaningful after a call to initial_points mutator.
|
| |
|
StrStrSizet | run_identifier () const |
| | get the unique run identifier based on method name, id, and number of executions
|
| |
| void | initialize_model_graphics (Model &model, int iterator_server_id) |
| | helper function that encapsulates initialization operations, modular on incoming Model instance More...
|
| |
| void | export_final_surrogates (Model &data_fit_surr_model) |
| | export final surrogates generated, e.g., GP in EGO and friends More...
|
| |
|
|
Iterator | daceIterator |
| | LHS iterator for constructing initial GP for all response functions.
|
| |
|
Model | fHatModel |
| | GP model of response, one approximation per response function.
|
| |
|
Iterator | intervalOptimizer |
| | optimizer for solving surrogate-based subproblem: NCSU DIRECT optimizer for maximizing expected improvement or mixed EA if discrete variables.
|
| |
|
Model | intervalOptModel |
| | recast model which formulates the surrogate-based optimization subproblem (recasts as design problem; may assimilate mean and variance to enable max(expected improvement))
|
| |
|
Real | approxFnStar |
| | approximate response corresponding to minimum/maximum truth response
|
| |
|
Real | truthFnStar |
| | minimum/maximum truth response function value
|
| |
|
size_t | numContIntervalVars |
| | number of variables of type CONTINUOUS_INTERVAL_UNCERTAIN
|
| |
|
size_t | numDiscIntervalVars |
| | number of variables of type DISCRETE_INTERVAL_UNCERTAIN
|
| |
|
size_t | numDiscSetIntUncVars |
| | number of variables of type DISCRETE_UNCERTAIN_SET_INT
|
| |
|
size_t | numDiscSetRealUncVars |
| | number of variables of type DISCRETE_UNCERTAIN_SET_REAL
|
| |
|
bool | singleIntervalFlag |
| | flag for SingleInterval derived class
|
| |
|
RealVectorArray | ccBelFn |
| | Storage array to hold CCBF values.
|
| |
|
RealVectorArray | ccPlausFn |
| | Storage array to hold CCPF values.
|
| |
|
RealVectorArray | ccBelVal |
| | Storage array to hold CCB response values.
|
| |
|
RealVectorArray | ccPlausVal |
| | Storage array to hold CCP response values.
|
| |
|
RealVectorArray | cellContLowerBounds |
| | Storage array to hold cell lower bounds for continuous variables.
|
| |
|
RealVectorArray | cellContUpperBounds |
| | Storage array to hold cell upper bounds for continuous variables.
|
| |
|
IntVectorArray | cellIntRangeLowerBounds |
| | Storage array to hold cell lower bounds for discrete int range variables.
|
| |
|
IntVectorArray | cellIntRangeUpperBounds |
| | Storage array to hold cell upper bounds for discrete int range variables.
|
| |
|
IntVectorArray | cellIntSetBounds |
| | Storage array to hold cell values for discrete integer set variables.
|
| |
|
IntVectorArray | cellRealSetBounds |
| | Storage array to hold cell value for discrete real set variables.
|
| |
|
RealVectorArray | cellFnLowerBounds |
| | Storage array to hold cell min.
|
| |
|
RealVectorArray | cellFnUpperBounds |
| | Storage array to hold cell max.
|
| |
|
RealVector | cellBPA |
| | Storage array to hold cell bpa.
|
| |
|
size_t | respFnCntr |
| | response function counter
|
| |
|
size_t | cellCntr |
| | cell counter
|
| |
|
size_t | numCells |
| | total number of interval combinations
|
| |
|
NonD * | prevNondInstance |
| | pointer containing previous value of nondInstance
|
| |
|
size_t | startCAUV |
| | starting index of continuous aleatory uncertain variables within active continuous variables (convenience for managing offsets)
|
| |
|
size_t | numCAUV |
| | number of active continuous aleatory uncertain variables
|
| |
|
bool | epistemicStats |
| | flag for computing interval-type metrics instead of integrated metrics If any epistemic vars are active in a metric evaluation, then flag is set.
|
| |
|
RealMatrix | momentStats |
| | standardized or central resp moments, as determined by finalMomentsType. Calculated in compute_moments()) and indexed as (moment,fn).
|
| |
|
RealVectorArray | requestedRespLevels |
| | requested response levels for all response functions
|
| |
|
RealVectorArray | computedProbLevels |
| | output probability levels for all response functions resulting from requestedRespLevels
|
| |
|
RealVectorArray | computedRelLevels |
| | output reliability levels for all response functions resulting from requestedRespLevels
|
| |
|
RealVectorArray | computedGenRelLevels |
| | output generalized reliability levels for all response functions resulting from requestedRespLevels
|
| |
|
short | respLevelTarget |
| | indicates mapping of z->p (PROBABILITIES), z->beta (RELIABILITIES), or z->beta* (GEN_RELIABILITIES)
|
| |
|
short | respLevelTargetReduce |
| | indicates component or system series/parallel failure metrics
|
| |
|
RealVectorArray | requestedProbLevels |
| | requested probability levels for all response functions
|
| |
|
RealVectorArray | requestedRelLevels |
| | requested reliability levels for all response functions
|
| |
|
RealVectorArray | requestedGenRelLevels |
| | requested generalized reliability levels for all response functions
|
| |
|
RealVectorArray | computedRespLevels |
| | output response levels for all response functions resulting from requestedProbLevels, requestedRelLevels, or requestedGenRelLevels
|
| |
|
size_t | totalLevelRequests |
| | total number of levels specified within requestedRespLevels, requestedProbLevels, and requestedRelLevels
|
| |
|
bool | cdfFlag |
| | flag for type of probabilities/reliabilities used in mappings: cumulative/CDF (true) or complementary/CCDF (false)
|
| |
|
bool | pdfOutput |
| | flag for managing output of response probability density functions (PDFs)
|
| |
|
RealVectorArray | computedPDFAbscissas |
| | sorted response PDF intervals bounds extracted from min/max sample and requested/computedRespLevels (vector lengths = num bins + 1)
|
| |
|
RealVectorArray | computedPDFOrdinates |
| | response PDF densities computed from bin counts divided by (unequal) bin widths (vector lengths = num bins)
|
| |
|
Response | finalStatistics |
| | final statistics from the uncertainty propagation used in strategies: response means, standard deviations, and probabilities of failure
|
| |
|
short | finalMomentsType |
| | type of moments logged within finalStatistics: none, central, standard
|
| |
|
size_t | miPLIndex |
| | index for the active ParallelLevel within ParallelConfiguration::miPLIters
|
| |
|
BitArray | pdfComputed |
| | Whether PDF was computed for function i; used to determine whether a pdf should be archived.
|
| |
|
size_t | numFunctions |
| | number of response functions
|
| |
|
size_t | numContinuousVars |
| | number of active continuous vars
|
| |
|
size_t | numDiscreteIntVars |
| | number of active discrete integer vars
|
| |
|
size_t | numDiscreteStringVars |
| | number of active discrete string vars
|
| |
|
size_t | numDiscreteRealVars |
| | number of active discrete real vars
|
| |
|
bool | compactMode |
| | switch for allSamples (compact mode) instead of allVariables (normal mode)
|
| |
|
VariablesArray | allVariables |
| | array of all variables to be evaluated in evaluate_parameter_sets()
|
| |
|
RealMatrix | allSamples |
| | compact alternative to allVariables
|
| |
|
IntResponseMap | allResponses |
| | array of all responses to be computed in evaluate_parameter_sets()
|
| |
|
IntIntVariables2DMap | batchVariablesMap |
| | alternate container for Variables samples supporting evaluate_batch() and synchronize_batches(), a 2D map with outer batch_id and inner eval_id
|
| |
|
IntIntRealVector2DMap | batchSamplesMap |
| | alternate container for RealVector samples supporting evaluate_batch() and synchronize_batches(), a 2D map with outer batch_id and inner eval_id
|
| |
|
IntIntResponse2DMap | batchResponsesMap |
| | alternate container for Response samples supporting evaluate_batch() and synchronize_batches(), a 2D map with outer batch_id and inner eval_id
|
| |
|
StringArray | allHeaders |
| | array of headers to insert into output while evaluating allVariables
|
| |
|
size_t | numObjFns |
| | number of objective functions
|
| |
|
size_t | numLSqTerms |
| | number of least squares terms
|
| |
|
RealPairPRPMultiMap | bestVarsRespMap |
| | map which stores best set of solutions
|
| |
|
bool | vbdFlag |
| | flag indicating the activation of variance-bsaed decomposition for computing Sobol' indices, via either PCE or sampling
|
| |
|
Real | vbdDropTol |
| | tolerance for omitting output of small VBD indices computed via either PCE or sampling
|
| |
| ProblemDescDB & | probDescDB |
| | class member reference to the problem description database More...
|
| |
|
ParallelLibrary & | parallelLib |
| | class member reference to the parallel library
|
| |
|
ParConfigLIter | methodPCIter |
| | the active ParallelConfiguration used by this Iterator instance
|
| |
|
Model | iteratedModel |
| | the model to be iterated (for iterators and meta-iterators employing a single model instance)
|
| |
|
size_t | myModelLayers |
| | number of Models locally (in Iterator or derived classes) wrapped around the initially passed in Model
|
| |
|
unsigned short | methodName |
| | name of the iterator (the user's method spec)
|
| |
|
Real | convergenceTol |
| | iteration convergence tolerance
|
| |
|
size_t | maxIterations |
| | maximum number of iterations for the method
|
| |
|
size_t | maxFunctionEvals |
| | maximum number of fn evaluations for the method
|
| |
| int | maxEvalConcurrency |
| | maximum number of concurrent model evaluations More...
|
| |
|
ActiveSet | activeSet |
| | the response data requirements on each function evaluation
|
| |
|
size_t | numFinalSolutions |
| | number of solutions to retain in best variables/response arrays
|
| |
|
VariablesArray | bestVariablesArray |
| | collection of N best solution variables found during the study; always in context of Model originally passed to the Iterator (any in-flight Recasts must be undone)
|
| |
|
ResponseArray | bestResponseArray |
| | collection of N best solution responses found during the study; always in context of Model originally passed to the Iterator (any in-flight Recasts must be undone)
|
| |
|
bool | subIteratorFlag |
| | flag indicating if this Iterator is a sub-iterator (NestedModel::subIterator or DataFitSurrModel::daceIterator)
|
| |
|
short | outputLevel |
| | output verbosity level: {SILENT,QUIET,NORMAL,VERBOSE,DEBUG}_OUTPUT
|
| |
|
bool | summaryOutputFlag |
| | flag for summary output (evaluation stats, final results); default true, but false for on-the-fly (helper) iterators and sub-iterator use cases
|
| |
|
ResultsManager & | resultsDB |
| | reference to the global iterator results database
|
| |
|
EvaluationStore & | evaluationsDB |
| | reference to the global evaluation database
|
| |
|
EvaluationsDBState | evaluationsDBState |
| | State of evaluations DB for this iterator.
|
| |
|
ResultsNames | resultsNames |
| | valid names for iterator results
|
| |
|
std::shared_ptr< TraitsBase > | methodTraits |
| | pointer that retains shared ownership of a TraitsBase object, or child thereof
|
| |
|
bool | topLevel |
| | Whether this is the top level iterator.
|
| |
|
bool | exportSurrogate = false |
| | whether to export final surrogates
|
| |
|
String | surrExportPrefix |
| | base filename for exported surrogates
|
| |
|
unsigned short | surrExportFormat = NO_MODEL_FORMAT |
| | (bitwise) format(s) to export
|
| |
Public Member Functions inherited from NonDInterval
1.8.20