$extrastylesheet
Dakota  Version 6.2
Public Member Functions | Protected Member Functions | Private Member Functions | Private Attributes
NonDQuadrature Class Reference

Derived nondeterministic class that generates N-dimensional numerical quadrature points for evaluation of expectation integrals over uncorrelated standard normals/uniforms/exponentials/betas/gammas. More...

Inheritance diagram for NonDQuadrature:
NonDIntegration NonD Analyzer Iterator

List of all members.

Public Member Functions

 NonDQuadrature (Model &model, const UShortArray &quad_order_seq, const RealVector &dim_pref, short driver_mode)
 alternate constructor for instantiations "on the fly" based on a quadrature order specification
 NonDQuadrature (Model &model, int num_filt_samples, const RealVector &dim_pref, short driver_mode)
 alternate constructor for instantiations "on the fly" that generate a filtered tensor product sample set
 NonDQuadrature (Model &model, int num_rand_samples, int seed, const UShortArray &quad_order_seq, const RealVector &dim_pref, short driver_mode)
 alternate constructor for instantiations "on the fly" that sample randomly from a tensor product multi-index
void increment_grid ()
 increment SSG level/TPQ order
void update ()
 propagate any numSamples updates and/or grid updates/increments
const Pecos::UShortArray & quadrature_order () const
 return Pecos::TensorProductDriver::quadOrder
void quadrature_order (const Pecos::UShortArray &dim_quad_order)
 set dimQuadOrderRef and map to Pecos::TensorProductDriver::quadOrder
void samples (size_t samples)
 set numSamples
short mode () const
 return quadMode

Protected Member Functions

 NonDQuadrature (ProblemDescDB &problem_db, Model &model)
 constructor
 ~NonDQuadrature ()
 destructor
void initialize_grid (const std::vector< Pecos::BasisPolynomial > &poly_basis)
void get_parameter_sets (Model &model)
 Returns one block of samples (ndim * num_samples)
void reset ()
 restore initial state for repeated sub-iterator executions
void sampling_reset (int min_samples, bool all_data_flag, bool stats_flag)
void increment_grid_preference (const RealVector &dim_pref)
 increment SSG level/TPQ order and update anisotropy
void increment_specification_sequence ()
 increment sequenceIndex and update active orders/levels
int num_samples () const

Private Member Functions

void increment_grid (UShortArray &dim_quad_order)
 convenience function used to make increment_grid() more modular
void increment_grid_preference (const RealVector &dim_pref, UShortArray &dim_quad_order)
 convenience function used to make increment_grid_preference() more modular
void compute_minimum_quadrature_order (size_t min_samples, const RealVector &dim_pref, UShortArray &dim_quad_order)
 calculate smallest dim_quad_order with at least min_samples
void filter_parameter_sets ()
 prune allSamples back to size numSamples, retaining points with highest product weight
void update_anisotropic_order (const RealVector &dim_pref, UShortArray &quad_order_ref)
 update quad_order_ref based on an updated dimension preference, enforcing previous values as a lower bound
void initialize_dimension_quadrature_order (unsigned short quad_order_spec, const RealVector &dim_pref_spec, UShortArray &dim_quad_order)
 initialize dim_quad_order from quad_order_spec and dim_pref_spec
void increment_dimension_quadrature_order (UShortArray &dim_quad_order)
 increment each dim_quad_order entry by 1
void increment_dimension_quadrature_order (const RealVector &dim_pref, UShortArray &dim_quad_order)
 increment the dim_quad_order entry with maximum preference by 1 and then rebalance

Private Attributes

Pecos::TensorProductDriver * tpqDriver
 convenience pointer to the numIntDriver representation
bool nestedRules
 for studies involving refinement strategies, allow for use of nested quadrature rules such as Gauss-Patterson
UShortArray quadOrderSeqSpec
 a sequence of scalar quadrature orders, one per refinement level
UShortArray dimQuadOrderRef
 reference point for Pecos::TensorProductDriver::quadOrder: the original user specification for the number of Gauss points per dimension, plus any refinements posted by increment_grid()
short quadMode
 point generation mode: FULL_TENSOR, FILTERED_TENSOR, RANDOM_TENSOR
size_t numSamples
 size of a subset of tensor quadrature points (filtered based on product weight or sampled uniformly from the tensor multi-index); used by the regression PCE approach known as "probabilistic collocation"
int randomSeed
 seed for the random number generator used in sampling of the tensor multi-index

Detailed Description

Derived nondeterministic class that generates N-dimensional numerical quadrature points for evaluation of expectation integrals over uncorrelated standard normals/uniforms/exponentials/betas/gammas.

This class is used by NonDPolynomialChaos, but could also be used for general numerical integration of moments. It employs Gauss-Hermite, Gauss-Legendre, Gauss-Laguerre, Gauss-Jacobi and generalized Gauss-Laguerre quadrature for use with normal, uniform, exponential, beta, and gamma density functions and integration bounds. The abscissas and weights for one-dimensional integration are extracted from the appropriate OrthogonalPolynomial class and are extended to n-dimensions using a tensor product approach.


Constructor & Destructor Documentation

NonDQuadrature ( Model model,
const UShortArray &  quad_order_seq,
const RealVector &  dim_pref,
short  driver_mode 
)

alternate constructor for instantiations "on the fly" based on a quadrature order specification

This alternate constructor is used for on-the-fly generation and evaluation of numerical quadrature points.

References NonDIntegration::numIntDriver, and NonDQuadrature::tpqDriver.

NonDQuadrature ( Model model,
int  num_filt_samples,
const RealVector &  dim_pref,
short  driver_mode 
)

alternate constructor for instantiations "on the fly" that generate a filtered tensor product sample set

This alternate constructor is used for on-the-fly generation and evaluation of filtered tensor quadrature points.

References NonDIntegration::numIntDriver, and NonDQuadrature::tpqDriver.

NonDQuadrature ( Model model,
int  num_rand_samples,
int  seed,
const UShortArray &  quad_order_seq,
const RealVector &  dim_pref,
short  driver_mode 
)

alternate constructor for instantiations "on the fly" that sample randomly from a tensor product multi-index

This alternate constructor is used for on-the-fly generation and evaluation of random sampling from a tensor quadrature multi-index.

References NonDIntegration::numIntDriver, and NonDQuadrature::tpqDriver.

NonDQuadrature ( ProblemDescDB problem_db,
Model model 
) [protected]

constructor

This constructor is called for a standard letter-envelope iterator instantiation. In this case, set_db_list_nodes has been called and probDescDB can be queried for settings from the method specification. It is not currently used, as there is not yet a separate nond_quadrature method specification.

References NonDIntegration::check_variables(), Iterator::convergenceTol, ProblemDescDB::get_bool(), ProblemDescDB::get_short(), ProblemDescDB::get_ushort(), Iterator::maxEvalConcurrency, Iterator::maxIterations, NonD::natafTransform, NonDQuadrature::nestedRules, NonDIntegration::numIntDriver, Iterator::outputLevel, Iterator::probDescDB, NonDQuadrature::reset(), and NonDQuadrature::tpqDriver.


Member Function Documentation

void initialize_grid ( const std::vector< Pecos::BasisPolynomial > &  poly_basis) [protected, virtual]
void sampling_reset ( int  min_samples,
bool  all_data_flag,
bool  stats_flag 
) [protected, virtual]

used by DataFitSurrModel::build_global() to publish the minimum number of points needed from the quadrature routine in order to build a particular global approximation.

Reimplemented from Iterator.

References NonDQuadrature::compute_minimum_quadrature_order(), NonDIntegration::dimPrefSpec, NonDQuadrature::dimQuadOrderRef, NonDQuadrature::nestedRules, Analyzer::numContinuousVars, and NonDQuadrature::tpqDriver.

Referenced by NonDQuadrature::update().

int num_samples ( ) const [inline, protected, virtual]

Return current number of evaluation points. Since the calculation of samples, collocation points, etc. might be costly, provide a default implementation here that backs out from the maxEvalConcurrency.

Reimplemented from Analyzer.

References NonDQuadrature::numSamples, NonDQuadrature::quadMode, and NonDQuadrature::tpqDriver.


The documentation for this class was generated from the following files: