QUESO Namespace Reference

Classes
class	ArrayOfSequences
	Class for handling array samples (arrays of scalar sequences). More...
class	BoxSubset
	Class representing a subset of a vector space shaped like a hypercube. More...
class	ConcatenationSubset
	A templated class representing the concatenation of two vector subsets. More...
class	ConstantScalarFunction
	A class for handling scalar functions which image is a constant (real number). More...
class	ConstantVectorFunction
	A class for handling vector functions which image is constant. More...
class	DiscreteSubset
	A templated class representing the discrete vector subsets. More...
class	GenericScalarFunction
	A class for handling generic scalar functions. More...
class	GenericVectorFunction
	A class for handling generic vector functions. More...
class	IntersectionSubset
	A templated class representing the intersection of two vector sets. More...
class	BaseScalarFunction
	A templated (base) class for handling scalar functions. More...
class	BayesianJointPdf
	A class for handling Bayesian joint PDFs. More...
class	ScalarFunctionSynchronizer
	A templated class for synchronizing the calls of scalar functions (BaseScalarFunction and derived classes). More...
class	ScalarSequence
	Class for handling scalar samples. More...
class	SequenceOfVectors
	Class for handling vector samples (sequence of vectors). More...
class	BaseVectorFunction
	A templated (base) class for handling vector functions. More...
class	VectorFunctionSynchronizer
	A templated class for synchronizing the calls of vector-valued functions. More...
class	BaseVectorSequence
	Base class for handling vector and array samples (sequence of vectors or arrays). More...
class	VectorSpace
	A class representing a vector space. More...
class	VectorSet
	A templated class for handling sets. More...
class	VectorSubset
	A templated class for handling subsets. More...
class	AlgorithmFactory
class	AlgorithmFactoryImp
class	BaseInputOptionsParser
class	BasicPdfsBase
	TODO: Base class for basic PDFs (via either GSL or Boost). More...
class	BasicPdfsBoost
	TODO: Base class for basic PDFs using Boost library. More...
class	BasicPdfsGsl
	TODO: Base class for basic PDFs using Gsl library. More...
class	BoostInputOptionsParser
class	DistArray
	A class for partitioning vectors and matrices. More...
struct	FilePtrSetStruct
	Struct for handling data input and output from files. More...
class	BaseEnvironment
	This (virtual) class sets up the environment underlying the use of the QUESO library by an executable. More...
class	EmptyEnvironment
	This class sets up the environment underlying the use of the QUESO library by an executable. More...
class	FullEnvironment
	This class sets up the full environment underlying the use of the QUESO library by an executable. More...
class	EnvOptionsValues
	This class provides a suite options one can pass to a QUESO environment. More...
class	EnvironmentOptions
	This class reads options one can pass to a QUESO environment through an input file. More...
class	LogicError
class	NotImplemented
class	FileError
class	Factory
class	FactoryImp
class	FunctionBase
	Abstract base class for function objects. More...
class	FunctionOperatorBuilder
class	GslBlockMatrix
	Class for representing block matrices using GSL library. More...
class	GslMatrix
	Class for matrix operations using GSL library. More...
class	GslOptimizer
	A base class for handling optimisation of scalar functions. More...
class	GslVector
	Class for vector operations using GSL library. More...
class	InfiniteDimensionalGaussian
	Class defining infinite dimensional Gaussian measures. More...
class	InfiniteDimensionalLikelihoodBase
	Abstract class representing the likelihood. Users must subclass this. More...
class	InfiniteDimensionalMCMCSamplerOptions
	This class defines the options that specify the behaviour of the MCMC sampler. More...
class	InfiniteDimensionalMeasureBase
	Abstract base class for infinite dimensional measures. More...
class	Map
	A class for partitioning vectors and matrices. More...
class	Matrix
	Class for matrix operations (virtual). More...
struct	data_type
class	DataType
class	StandardType
class	MpiComm
	The QUESO MPI Communicator Class. More...
class	OperatorBase
	Abstract base class for operator objects. Operators are assumed to be symmetric and positive-definite. More...
class	BaseOptimizer
	A base class for handling optimisation of scalar functions. More...
class	OptimizerMonitor
	Object to monitor convergence of optimizers. More...
class	OptimizerOptions
	This class provides options for a Optimizer. More...
class	RngBase
	Class for random number generation (base class for either GSL or Boost RNG). More...
class	RngBoost
class	RngGsl
class	TKFactoryLogitRandomWalk
class	TKFactoryMALA
class	TKFactoryRandomWalk
class	TKFactoryStochasticNewton
class	TransitionKernelFactory
class	Vector
	Class for vector operations (virtual). More...
class	ExperimentModel
class	EmOptionsValues
class	ExperimentModelOptions
class	ExperimentStorage
class	GcmExperimentInfo
class	GcmJointInfo
class	GcmJointTildeInfo
class	GcmSimulationInfo
class	GcmSimulationTildeInfo
class	GcmTotalInfo
class	GcmZInfo
class	GcmZTildeInfo
class	GPMSAEmulator
class	GPMSAFactory
class	GpmsaComputerModel
class	GcmOptionsValues
class	GpmsaComputerModelOptions
class	GPMSAOptions
	This class defines the options that specify the behaviour of the Gaussian process emulator. More...
class	SimulationModel
class	SmOptionsValues
class	SimulationModelOptions
class	SimulationStorage
class	Base1D1DFunction
	Class for one-dimensional functions. More...
class	Generic1D1DFunction
	Class for generic one-dimensional functions. More...
class	Constant1D1DFunction
	Class for constant one-dimensional functions. More...
class	Linear1D1DFunction
	Class for linear one-dimensional functions. More...
class	PiecewiseLinear1D1DFunction
	Class for piecewise-linear one-dimensional functions. More...
class	Quadratic1D1DFunction
	Class for one-dimensional quadratic functions. More...
class	Sampled1D1DFunction
	Class for one-dimensional sampled functions. More...
class	ScalarTimesFunc1D1DFunction
	Class for multiplication of a one-dimensional function by a scalar. More...
class	FuncTimesFunc1D1DFunction
	Class for multiplication of a one-dimensional function by another. More...
class	FuncPlusFunc1D1DFunction
	Class for addition of a one-dimensional function with another. More...
class	LagrangePolynomial1D1DFunction
	Class for one-dimensional Lagrange polynomials. More...
class	LagrangeBasis1D1DFunction
	Class for Lagrange polynomial basis. More...
class	Base1DQuadrature
	Base class for one-dimensional quadrature rules (numerical integration of functions). More...
class	Generic1DQuadrature
	Class for one-dimensional generic quadrature rules (numerical integration of functions). More...
class	UniformLegendre1DQuadrature
	Class for Legendre-Gauss quadrature rule for one-dimensional functions. More...
class	GaussianHermite1DQuadrature
	Class for Hermite-Gauss quadrature rule for one-dimensional functions. More...
class	WignerInverseChebyshev1st1DQuadrature
	Class for first type Chebyshev-Gauss quadrature rule for one-dimensional functions. More...
class	WignerChebyshev2nd1DQuadrature
	Class for second type Chebyshev-Gauss quadrature rule for one-dimensional functions. More...
class	TwoDArray
	Class for handling arrays of generic data. More...
class	ArrayOfOneDGrids
	Class to accommodate arrays of one-dimensional grid. More...
class	ArrayOfOneDTables
	Class to accommodate arrays of one-dimensional tables. More...
class	AsciiTable
	Class for reading ASCII values from a table in a file. More...
class	Fft
	Class for a Fast Fourier Transform (FFT) algorithm. More...
class	BaseOneDGrid
	Base class for accommodating one-dimensional grids. More...
class	StdOneDGrid
	Class for accommodating standard one-dimensional grids. More...
class	StreamUtilities
class	UniformOneDGrid
	Class for accommodating uniform one-dimensional grids. More...
class	BaseTKGroup
	This base class allows the representation of a transition kernel. More...
class	Algorithm
class	BetaJointPdf
	A class for handling Beta joint PDFs. More...
class	BetaVectorRealizer
	A class for handling sampling from a Beta probability density distribution. More...
class	BetaVectorRV
	A class representing a vector RV constructed via Beta distribution. More...
class	ConcatenatedJointPdf
	A class for handling concatenated PDFs. More...
class	ConcatenatedVectorRealizer
	A class for handling sampling from concatenated probability density distributions. More...
class	ConcatenatedVectorRV
	A class representing concatenated vector RVs. More...
class	ExponentialMatrixCovarianceFunction
	A class for exponential covariance matrices. More...
class	ExponentialScalarCovarianceFunction
	A class for exponential covariances. More...
class	FiniteDistribution
	A templated class for a finite distribution. More...
class	GammaJointPdf
	A class for handling Gamma joint PDFs. More...
class	GammaVectorRealizer
	A class for handling sampling from a Gamma probability density distribution. More...
class	GammaVectorRV
	A class representing a vector RV constructed via Gamma distribution. More...
class	GaussianJointPdf
	A class for handling Gaussian joint PDFs. More...
class	BaseGaussianLikelihood
	Base class for canned Gaussian likelihoods. More...
class	GaussianLikelihoodBlockDiagonalCovariance
	A class representing a Gaussian likelihood with block-diagonal covariance matrix. More...
class	GaussianLikelihoodBlockDiagonalCovarianceRandomCoefficients
	A class representing a Gaussian likelihood with block-diagonal covariance matrix. More...
class	GaussianLikelihoodDiagonalCovariance
	A class that represents a Gaussian likelihood with diagonal covariance matrix. More...
class	GaussianLikelihoodFullCovariance
	A class that represents a Gaussian likelihood with full covariance. More...
class	GaussianLikelihoodFullCovarianceRandomCoefficient
	A class that represents a Gaussian likelihood with full covariance and random coefficient. More...
class	GaussianLikelihoodScalarCovariance
	A class that represents a Gaussian likelihood with scalar covariance. More...
class	GaussianVectorCdf
	TODO: A class for handling Gaussian CDFs. More...
class	GaussianVectorMdf
	TODO: A class for handling Gaussian MDFs. More...
class	GaussianVectorRealizer
	A class for handling sampling from Gaussian probability density distributions. More...
class	GaussianVectorRV
	A class representing a Gaussian vector RV. More...
class	GenericJointPdf
	A class for handling generic joint PDFs. More...
class	GenericMatrixCovarianceFunction
	A class for generic covariance matrices. More...
class	GenericScalarCovarianceFunction
	A class for generic covariances. More...
class	GenericVectorCdf
	A class for handling generic vector CDFs. More...
class	GenericVectorMdf
	A class for handling generic MDFs of vector functions. More...
class	GenericVectorRealizer
	A class for handling sampling from generic probability density distributions. More...
class	GenericVectorRV
	A templated class for handling generic vector RVs. More...
class	HessianCovMatricesTKGroup
	This class allows the representation of a transition kernel with Hessians. More...
class	InverseGammaJointPdf
	A class for handling Inverse Gamma joint PDFs. More...
class	InverseGammaVectorRealizer
	A class for handling sampling from an Inverse Gamma probability density distribution. More...
class	InverseGammaVectorRV
	A class representing a vector RV constructed via Inverse Gamma distribution. More...
class	InvLogitGaussianJointPdf
	A class for handling hybrid (transformed) Gaussians with bounds. More...
class	InvLogitGaussianVectorRealizer
	A class for handling sampling from (transformed) Gaussian probability density distributions with bounds. More...
class	InvLogitGaussianVectorRV
	A class representing a (transformed) Gaussian vector RV with bounds. More...
class	JeffreysJointPdf
	A class for handling jeffreys joint PDFs. More...
class	JeffreysVectorRealizer
	A class for handling sampling from a jeffreys probability density distribution. More...
class	JeffreysVectorRV
	A class representing a jeffreys vector RV. More...
class	BaseJointPdf
	A templated (base) class for handling joint PDFs. More...
class	LogNormalJointPdf
	A class for handling Log-Normal joint PDFs. More...
class	LogNormalVectorRealizer
	A class for handling sampling from a Log-Normal probability density distribution. More...
class	LogNormalVectorRV
	A class representing a LogNormal vector RV. More...
class	MarkovChainPositionData
	A templated class that represents a Markov Chain. More...
class	BaseMatrixCovarianceFunction
	A templated (base) class to accommodate covariance matrix of (random) vector functions. More...
class	BayseianJointPdf
class	MetropolisAdjustedLangevinTK
	This class allows the representation of the MALA transition kernel with a scaled covariance matrix for the purposes of delayed rejection. More...
struct	MHRawChainInfoStruct
	A struct that represents a Metropolis-Hastings sample. More...
class	MetropolisHastingsSG
	A templated class that represents a Metropolis-Hastings generator of samples. More...
class	MhOptionsValues
	This class provides options for the Metropolis-Hastings generator of samples if no input file is available. More...
class	MetropolisHastingsSGOptions
	This class reads the options for the Metropolis-Hastings generator of samples from an input file. More...
struct	ExchangeInfoStruct
struct	BalancedLinkedChainControlStruct
struct	BalancedLinkedChainsPerNodeStruct
struct	UnbalancedLinkedChainControlStruct
struct	UnbalancedLinkedChainsPerNodeStruct
class	MLSampling
	A templated class that represents a Multilevel generator of samples. More...
class	MLSamplingLevelOptions
	This class provides options for each level of the Multilevel sequence generator if no input file is available. More...
class	MLSamplingOptions
	This class provides options for the Multilevel sequence generator if no input file is available. More...
class	ModelValidation
	A templated class for model validation of the example validationPyramid. More...
class	MonteCarloSG
	A templated class that implements a Monte Carlo generator of samples. More...
class	McOptionsValues
	This class provides options for the Monte Carlo sequence generator if no input file is available. More...
class	MonteCarloSGOptions
	This class reads the options for the Monte Carlo sequence generator from an input file. More...
class	PoweredJointPdf
	A class for handling a powered joint PDFs. More...
class	SampledScalarCdf
	A class for handling sampled CDFs. More...
class	SampledVectorCdf
	A class for handling sampled vector CDFs. More...
class	SampledVectorMdf
	A class for handling sampled vector MDFs. More...
class	BaseScalarCdf
	A templated (base) class for handling CDFs. More...
class	BaseScalarCovarianceFunction
	A templated (base) class to accommodate scalar covariance functions (of random variables). More...
class	ScalarGaussianRandomField
	A class for handling scalar Gaussian random fields (GRF). More...
class	ScaledCovMatrixTKGroup
	This class allows the representation of a transition kernel with a scaled covariance matrix. More...
class	SequentialVectorRealizer
	A class for handling sequential draws (sampling) from probability density distributions. More...
class	StatisticalForwardProblem
	This templated class represents a Statistical Forward Problem. More...
class	SfpOptionsValues
	This class provides options for a Statistical Forward Problem if no input file is available. More...
class	StatisticalForwardProblemOptions
	This class reads option values for a Statistical Forward Problem from an input file. More...
class	StatisticalInverseProblem
	This templated class represents a Statistical Inverse Problem. More...
class	SipOptionsValues
	This class provides options for a Statistical Inverse Problem if no input file is available. More...
class	StatisticalInverseProblemOptions
	This class reads option values for a Statistical Inverse Problem from an input file. More...
class	StdScalarCdf
	A class for handling standard CDFs. More...
class	TransformedScaledCovMatrixTKGroup
	This class represents a transition kernel with a scaled covariance matrix on hybrid bounded/unbounded state spaces. More...
class	UniformJointPdf
	A class for handling uniform joint PDFs. More...
class	UniformVectorRealizer
	A class for handling sampling from a Uniform probability density distribution. More...
class	UniformVectorRV
	A class representing a uniform vector RV. More...
class	ValidationCycle
	A templated class for validation cycle of the examples validationCycle and validationCycle2. More...
class	BaseVectorCdf
	A templated (base) class for handling CDFs of vector functions. More...
class	VectorGaussianRandomField
	A class for handling vector Gaussian random fields (GRF). More...
class	BaseVectorMdf
	A templated (base) class for handling MDFs of vector functions. More...
class	BaseVectorRealizer
	A templated (base) class for handling sampling from vector RVs. More...
class	BaseVectorRV
	A templated base class for handling vector RV. More...
class	WignerJointPdf
	A class for handling Wigner joint PDFs. More...
class	WignerVectorRealizer
	A class for handling sampling from a Wigner probability density distribution. More...
class	WignerVectorRV
	A class representing a vector RV constructed via Wigner distribution. More...
class	InterpolationSurrogateData
class	InterpolationSurrogateBase
	Base class for interpolation-based surrogates. More...
class	InterpolationSurrogateBuilder
	Build interpolation-based surrogate. More...
class	InterpolationSurrogateDataSet
	Container class for multiple, consistent InterpolationSurrogateData objects. More...
class	InterpolationSurrogateHelper
class	InterpolationSurrogateIOASCII
class	InterpolationSurrogateIOBase
class	LinearLagrangeInterpolationSurrogate
	Linear Lagrange interpolation surrogate. More...
class	SurrogateBase
	Base class for surrogates of models. More...
class	SurrogateBuilderBase
	Base class for builders of surrogates. More...

Typedefs
typedef int	RawType_MPI_Comm
typedef int	RawType_MPI_Group
typedef int	RawType_MPI_Datatype
typedef int	RawType_MPI_Op
typedef int	RawType_MPI_Status

Functions
template<class V , class M >
VectorSet< V, M > *	InstantiateIntersection (const VectorSet< V, M > &domain1, const VectorSet< V, M > &domain2)
	This method calculates the intersection of domain1 and domain2. More...
template<class T >
void	ComputeSubGaussian2dKde (const ScalarSequence< T > &scalarSeq1, const ScalarSequence< T > &scalarSeq2, unsigned int initialPos, double scaleValue1, double scaleValue2, const std::vector< T > &evaluationPositions1, const std::vector< T > &evaluationPositions2, std::vector< double > &densityValues)
template<class T >
void	ComputeUnifiedGaussian2dKde (bool useOnlyInter0Comm, const ScalarSequence< T > &scalarSeq1, const ScalarSequence< T > &scalarSeq2, unsigned int initialPos, double unifiedScaleValue1, double unifiedScaleValue2, const std::vector< T > &unifiedEvaluationPositions1, const std::vector< T > &unifiedEvaluationPositions2, std::vector< double > &unifiedDensityValues)
template<class T >
void	ComputeCovCorrBetweenScalarSequences (const ScalarSequence< T > &subPSeq, const ScalarSequence< T > &subQSeq, unsigned int subNumSamples, T &covValue, T &corrValue)
template<class P_V , class P_M , class Q_V , class Q_M >
void	ComputeCovCorrMatricesBetweenVectorSequences (const BaseVectorSequence< P_V, P_M > &subPSeq, const BaseVectorSequence< Q_V, Q_M > &subQSeq, unsigned int subNumSamples, P_M &pqCovMatrix, P_M &pqCorrMatrix)
int	MyWorldfullRank ()
	Returns the rank of the calling process in the communicator. More...
void	queso_terminate_handler ()
	Function for unhandled exceptions in Queso. More...
void	QUESO_version_print (std::ostream &os)
int	QUESO_get_numeric_version ()
std::ostream &	operator<< (std::ostream &os, const BaseEnvironment &obj)
std::ostream &	operator<< (std::ostream &os, const EnvironmentOptions &obj)
	Print values of the options chosen. More...
std::ostream &	operator<< (std::ostream &os, const GslBlockMatrix &obj)
GslMatrix	operator* (double a, const GslMatrix &mat)
GslVector	operator* (const GslMatrix &mat, const GslVector &vec)
GslMatrix	operator* (const GslMatrix &m1, const GslMatrix &m2)
GslMatrix	operator+ (const GslMatrix &m1, const GslMatrix &m2)
GslMatrix	operator- (const GslMatrix &m1, const GslMatrix &m2)
GslMatrix	matrixProduct (const GslVector &v1, const GslVector &v2)
GslMatrix	leftDiagScaling (const GslVector &vec, const GslMatrix &mat)
GslMatrix	rightDiagScaling (const GslMatrix &mat, const GslVector &vec)
std::ostream &	operator<< (std::ostream &os, const GslMatrix &obj)
GslVector	operator/ (double a, const GslVector &x)
GslVector	operator/ (const GslVector &x, const GslVector &y)
GslVector	operator* (double a, const GslVector &x)
GslVector	operator* (const GslVector &x, const GslVector &y)
double	scalarProduct (const GslVector &x, const GslVector &y)
GslVector	operator+ (const GslVector &x, const GslVector &y)
GslVector	operator- (const GslVector &x, const GslVector &y)
bool	operator== (const GslVector &lhs, const GslVector &rhs)
std::ostream &	operator<< (std::ostream &os, const GslVector &obj)
	QUESO_STANDARD_TYPE (char, MPI_CHAR)
	QUESO_STANDARD_TYPE (int, MPI_INT)
	QUESO_STANDARD_TYPE (unsigned int, MPI_UNSIGNED)
	QUESO_STANDARD_TYPE (double, MPI_DOUBLE)
template<>
void	BoostInputOptionsParser::getOption< std::vector< double, std::allocator< double > > > (std::string &name, std::vector< double, std::allocator< double > > &value)
std::ostream &	operator<< (std::ostream &os, const BoostInputOptionsParser &parser)
template void	BoostInputOptionsParser::registerOption< std::string > (std::string, std::string, std::string)
template void	BoostInputOptionsParser::getOption< std::string > (std::string &, std::string &)
template void	BoostInputOptionsParser::getOption< std::vector< unsigned int, std::allocator< unsigned int > > > (std::string &, std::vector< unsigned int, std::allocator< unsigned int > > &)
std::ostream &	operator<< (std::ostream &os, const EnvOptionsValues &obj)
double	c_evaluate (const gsl_vector *x, void *context)
void	c_evaluate_derivative (const gsl_vector *x, void *context, gsl_vector *derivative)
void	c_evaluate_with_derivative (const gsl_vector *x, void *context, double *f, gsl_vector *derivative)
std::ostream &	operator<< (std::ostream &os, const InfiniteDimensionalMCMCSamplerOptions &obj)
std::ostream &	operator<< (std::ostream &os, const OptimizerOptions &obj)
std::ostream &	operator<< (std::ostream &os, const ExperimentModelOptions &obj)
std::ostream &	operator<< (std::ostream &os, const GpmsaComputerModelOptions &obj)
std::ostream &	operator<< (std::ostream &os, const SimulationModelOptions &obj)
std::ostream &	operator<< (std::ostream &os, const GPMSAOptions &obj)
template<class T >
double	SubF1F2Gaussian2dKdeIntegral (const ScalarSequence< T > &scalarSeq1, const ScalarSequence< T > &scalarSeq2, unsigned int initialPos, double scaleValue1, double scaleValue2, const Base1D1DFunction &func1, const Base1D1DFunction &func2, unsigned int quadratureOrder)
	Calculates the integral of a 2D Gaussian KDE. More...
template<class V , class M >
void	CovCond (double condNumber, const V &direction, M &covMatrix, M &precMatrix)
template<typename T >
bool	queso_isnan (T arg)
template<typename T >
bool	queso_isfinite (T arg)
void	MiscReadDoublesFromString (const std::string &inputString, std::vector< double > &outputDoubles)
void	MiscReadWordsFromString (const std::string &inputString, std::vector< std::string > &outputWords)
int	MiscReadStringAndDoubleFromFile (std::ifstream &ifs, std::string &termString, double *termValue)
int	MiscReadCharsAndDoubleFromFile (std::ifstream &ifs, std::string &termString, double *termValue, bool &endOfLineAchieved)
double	MiscGammar (double a, double b, const RngBase *rngObject)
double	MiscGetEllapsedSeconds (struct timeval *timeval0)
double	MiscHammingWindow (unsigned int N, unsigned int j)
double	MiscGaussianDensity (double x, double mu, double sigma)
unsigned int	MiscUintDebugMessage (unsigned int value, const char *message)
int	MiscIntDebugMessage (int value, const char *message)
double	MiscDoubleDebugMessage (double value, const char *message)
int	CheckFilePath (const char *path)
int	GRVY_CheckDir (const char *dirname)
template<class T >
bool	MiscCheckForSameValueInAllNodes (T &inputValue, double acceptableTreshold, const MpiComm &comm, const char *whereString)
template<class V >
void	MiscComputePositionsBetweenMinMax (V minValues, V maxValues, std::vector< V * > &positions)
template<class V1 , class V2 >
void	MiscCheckTheParallelEnvironment (const V1 &vec1, const V2 &vec2)
template<class V , class M >
std::ostream &	operator<< (std::ostream &os, const ArrayOfOneDTables< V, M > &obj)
template<class V , class M >
std::ostream &	operator<< (std::ostream &os, const AsciiTable< V, M > &obj)
template<class V , class M >
void	ComputeConditionalGaussianVectorRV (const V &muVec1, const V &muVec2, const M &sigmaMat11, const M &sigmaMat12, const M &sigmaMat21, const M &sigmaMat22, const V &sampleVec2, V &muVec1_cond_on_2, M &sigmaMat11_cond_on_2)
template<class V , class M >
std::ostream &	operator<< (std::ostream &os, const BaseJointPdf< V, M > &obj)
std::ostream &	operator<< (std::ostream &os, const MetropolisHastingsSGOptions &obj)
std::ostream &	operator<< (std::ostream &os, const MonteCarloSGOptions &obj)
	Prints the object obj, overloading an operator. More...
template<class T >
double	horizontalDistance (const BaseScalarCdf< T > &cdf1, const BaseScalarCdf< T > &cdf2, double epsilon)
	It calculated the maximum horizontal distance between two CDFs. More...
std::ostream &	operator<< (std::ostream &os, const StatisticalForwardProblemOptions &obj)
	Prints the object obj, overloading an operator. More...
std::ostream &	operator<< (std::ostream &os, const StatisticalInverseProblemOptions &obj)
	Prints the object obj, overloading an operator. More...
template<class V , class M >
void	horizontalDistances (const BaseVectorCdf< V, M > &cdf1, const BaseVectorCdf< V, M > &cdf2, const V &epsilonVec, V &distances)
	It calculated the maximum horizontal distances between two vector CDFs. More...
template<class P_V , class P_M , class Q_V , class Q_M >
void	ComputeCovCorrMatricesBetweenVectorRvs (const BaseVectorRV< P_V, P_M > &paramRv, const BaseVectorRV< Q_V, Q_M > &qoiRv, unsigned int localNumSamples, P_M &pqCovMatrix, P_M &pqCorrMatrix)
std::ostream &	operator<< (std::ostream &os, const MhOptionsValues &obj)
template<class P_V , class P_M >
std::ostream &	operator<< (std::ostream &os, const MLSampling< P_V, P_M > &obj)
std::ostream &	operator<< (std::ostream &os, const MLSamplingLevelOptions &obj)
std::ostream &	operator<< (std::ostream &os, const MLSamplingOptions &obj)
std::ostream &	operator<< (std::ostream &os, const McOptionsValues &obj)
std::ostream &	operator<< (std::ostream &os, const SfpOptionsValues &obj)
std::ostream &	operator<< (std::ostream &os, const SipOptionsValues &obj)

Variables
const int	UQ_UNAVAILABLE_RANK = -1
const int	UQ_OK_RC = 0
const int	UQ_INCOMPLETE_IMPLEMENTATION_RC = -1
const int	UQ_INVALID_PARAMETER_SPEC_RC = -2
const int	UQ_INVALID_OBSERVABLE_SPEC_RC = -3
const int	UQ_INVALID_QOI_SPEC_RC = -4
const int	UQ_INVALID_INTERNAL_RESULT_RC = -5
const int	UQ_INVALID_INTERNAL_STATE_RC = -6
const int	UQ_FAILED_TO_OPEN_FILE_RC = -7
const int	UQ_MATRIX_IS_NOT_POS_DEFINITE_RC = -8
const int	UQ_FAILED_READING_FILE_RC = -9
const int	UQ_INVALID_SPACE_COMPONENT_ID_RC = -10
const int	UQ_MATRIX_SVD_FAILED_RC = -11
AlgorithmFactoryImp< Algorithm < GslVector, GslMatrix > >	random_walk_alg ("random_walk")
AlgorithmFactoryImp< Algorithm < GslVector, GslMatrix > >	logit_random_walk_alg ("logit_random_walk")
std::terminate_handler	old_terminate_handler
TKFactoryLogitRandomWalk < TransformedScaledCovMatrixTKGroup < GslVector, GslMatrix > >	tk_factory_logit_random_walk ("logit_random_walk")
TKFactoryMALA < MetropolisAdjustedLangevinTK < GslVector, GslMatrix > >	tk_factory_mala ("mala")
TKFactoryRandomWalk < ScaledCovMatrixTKGroup < GslVector, GslMatrix > >	tk_factory_random_walk ("random_walk")
TKFactoryStochasticNewton < HessianCovMatricesTKGroup < GslVector, GslMatrix > >	tk_factory_stochastic_newton ("stochastic_newton")

Typedef Documentation

typedef int QUESO::RawType_MPI_Comm

Definition at line 57 of file MpiComm.h.

typedef int QUESO::RawType_MPI_Datatype

Definition at line 59 of file MpiComm.h.

typedef int QUESO::RawType_MPI_Group

Definition at line 58 of file MpiComm.h.

typedef int QUESO::RawType_MPI_Op

Definition at line 61 of file MpiComm.h.

typedef int QUESO::RawType_MPI_Status

Definition at line 62 of file MpiComm.h.

Function Documentation

template void QUESO::BoostInputOptionsParser::getOption< std::string >	(	std::string &	,
		std::string &
	)

template<>

void QUESO::BoostInputOptionsParser::getOption< std::vector< double, std::allocator< double > > >	(	std::string &	name,
		std::vector< double, std::allocator< double > > &	value
	)

Definition at line 139 of file BoostInputOptionsParser.C.

References MiscReadDoublesFromString(), and queso_deprecated.

{
  queso_deprecated();
  if (m_scannedInputFile) {
    // Need to reset value?

    // Get the option as a string
    // DM:  Why do it this way?  Doesn't boost support vectors as input options?
    std::string optionValue;
    this->getOption<std::string>(name, optionValue);
    MiscReadDoublesFromString(optionValue, value);
  }
}

template void QUESO::BoostInputOptionsParser::getOption< std::vector< unsigned int, std::allocator< unsigned int > > >	(	std::string &	,
		std::vector< unsigned int, std::allocator< unsigned int > > &
	)

template void QUESO::BoostInputOptionsParser::registerOption< std::string >	(	std::string	,
		std::string	,
		std::string
	)

double QUESO::c_evaluate	(	const gsl_vector *	x,
		void *	context
	)

Definition at line 43 of file GslOptimizer.C.

References QUESO::GslOptimizer::objectiveFunction().

Referenced by c_evaluate_with_derivative(), QUESO::GslOptimizer::minimize_no_gradient(), and QUESO::GslOptimizer::minimize_with_gradient().

                                                          {

    GslOptimizer * optimizer = static_cast<GslOptimizer * >(context);

    GslVector state(
        optimizer->objectiveFunction().domainSet().vectorSpace().zeroVector());

    // DM: Doing this copy sucks, but whatever.  It'll do for now.
    for (unsigned int i = 0; i < state.sizeLocal(); i++) {
      state[i] = gsl_vector_get(x, i);
    }

    // Bail early if GSL tries to evaluate outside of the domain
    if (!optimizer->objectiveFunction().domainSet().contains(state)) {
      return GSL_NAN;
    }

    // Should cache derivative here so we don't a) segfault in the user's code
    // and b) so we don't recompute stuff
    double result = -optimizer->objectiveFunction().lnValue(state, NULL, NULL,
        NULL, NULL);

    return result;
  }

void QUESO::c_evaluate_derivative	(	const gsl_vector *	x,
		void *	context,
		gsl_vector *	derivative
	)

Definition at line 69 of file GslOptimizer.C.

References QUESO::BaseOptimizer::getFiniteDifferenceStepSize(), and QUESO::GslOptimizer::objectiveFunction().

Referenced by c_evaluate_with_derivative(), and QUESO::GslOptimizer::minimize_with_gradient().

                               {
    GslOptimizer * optimizer = static_cast<GslOptimizer * >(context);

    GslVector state(
        optimizer->objectiveFunction().domainSet().vectorSpace().zeroVector());
    GslVector deriv(
        optimizer->objectiveFunction().domainSet().vectorSpace().zeroVector());

    // DM: Doing this copy sucks, but whatever.  It'll do for now.
    for (unsigned int i = 0; i < state.sizeLocal(); i++) {
      state[i] = gsl_vector_get(x, i);

      // We fill with GSL_NAN and use it as a flag to check later that the user
      // actually fills the derivative vector with stuff
      deriv[i] = GSL_NAN;
    }

    if (!optimizer->objectiveFunction().domainSet().contains(state)) {
      // Fill derivative with error codes if the point is outside of the
      // domain
      for (unsigned int i = 0; i < deriv.sizeLocal(); i++) {
        gsl_vector_set(derivative, i, GSL_NAN);
      }
    }
    else {
      // We should cache the return value here so we don't recompute stuff
      double fx = -optimizer->objectiveFunction().lnValue(state, NULL, &deriv,
          NULL, NULL);

      // Decide whether or not we need to do a finite difference based on
      // whether the user actually filled deriv with values that are not
      // GSL_NAN
      //
      // We're currently doing this check every time this function gets called.
      // We could probably pull this logic out of here and put it somewhere
      // where it only happens once
      bool userComputedDerivative = true;
      for (unsigned int i = 0; i < deriv.sizeLocal(); i++) {
        // If the user missed out a derivative in any direction, fall back to
        // a finite difference
        if (gsl_isnan(deriv[i])) {
          userComputedDerivative = false;
          break;
        }
      }

      if (userComputedDerivative) {
        for (unsigned int i = 0; i < deriv.sizeLocal(); i++) {
          gsl_vector_set(derivative, i, -deriv[i]);  // We need the minus sign
        }
      }
      else {
        // Finite difference step-size
        double h = optimizer->getFiniteDifferenceStepSize();

        // User did not provide a derivative, so do a finite difference
        for (unsigned int i = 0; i < deriv.sizeLocal(); i++) {
          double tempState = state[i];
          state[i] += h;

          // User didn't provide a derivative, so we don't bother passing in
          // the derivative vector again
          double fxph = -optimizer->objectiveFunction().lnValue(state, NULL,
              NULL, NULL, NULL);

          // Reset the state back to what it was before
          state[i] = tempState;

          // Make sure we didn't do anything dumb and tell gsl if we did
          if (!gsl_isnan(fx) && !gsl_isnan(fxph)) {
            gsl_vector_set(derivative, i, (fxph - fx) / h);
          }
          else {
            gsl_vector_set(derivative, i, GSL_NAN);
          }
        }
      }
    }
  }

void QUESO::c_evaluate_with_derivative	(	const gsl_vector *	x,
		void *	context,
		double *	f,
		gsl_vector *	derivative
	)

Definition at line 151 of file GslOptimizer.C.

References c_evaluate(), and c_evaluate_derivative().

Referenced by QUESO::GslOptimizer::minimize_with_gradient().

                                           {
    // We don't need to call both of these
    *f = c_evaluate(x, context);
    c_evaluate_derivative(x, context, derivative);
  }

int QUESO::CheckFilePath

(

const char *

pathname

)

int CheckFilePath(const char *path) {

// verify parent directories in path exist (and create if not).

ifdef HAVE_GRVY return(grvy_check_file_path(path)); else

return 0; endif }

Definition at line 362 of file Miscellaneous.C.

References GRVY_CheckDir().

Referenced by QUESO::FullEnvironment::construct(), QUESO::BaseEnvironment::openInputFile(), QUESO::BaseEnvironment::openOutputFile(), QUESO::BaseEnvironment::openUnifiedInputFile(), and QUESO::BaseEnvironment::openUnifiedOutputFile().

  {

    // verify parent directories in path exist (and create if not).

#ifdef HAVE_GRVY
    return(grvy_check_file_path(pathname));
#else

    const int MAX_DEPTH = 50;

    char *pathlocal;
    char *parents;
    char *dirstring;
    char *token;
    int depth = 0;

    // Save a copy of pathname and look for the parent directories.

    pathlocal = strdup(pathname);
    dirstring = strdup(pathname);
    parents   = dirname(pathlocal);

    if(strcmp(parents,".") == 0)
      {
        free(pathlocal);
        free(dirstring);
        return 0;
      }

    // Deal with the possibility of an absolute path being provided

    bool abs_path = false;

    std::string leading_char("");
    std::string path_to_check;

    if(strncmp(parents,"/",1) == 0)
      {
        leading_char = "/";
        abs_path     = true;
      }

    // Verify existence of top-level directory

    if( (token = strtok(parents,"/")) != NULL )
      {
        path_to_check += leading_char + token;

        if ( GRVY_CheckDir(path_to_check.c_str()) )
          {
            free(pathlocal);
            free(dirstring);
            return -1;
          }

        // Now, search for any remaining parent directories.

        if(abs_path)
          sprintf(dirstring,"/%s",token);
        else
          sprintf(dirstring,"%s",token);

        while ( (token = strtok(0,"/")) && (depth < MAX_DEPTH) )
          {
            dirstring = strcat(dirstring,"/");

            if(GRVY_CheckDir(strcat(dirstring,token)))
              {
                free(pathlocal);
                free(dirstring);
                return -1;
              }
            depth++;
          };

        if(depth >= MAX_DEPTH )
          {
            std::cerr << __func__ << ": error - Max directory depth exceeded, limit =  " << MAX_DEPTH << std::endl;
            free(pathlocal);
            free(dirstring);
            return -1;
          }
      }

    // Clean Up
    free(pathlocal);
    free(dirstring);

    return 0;
#endif
  }

template<class V , class M >

void QUESO::ComputeConditionalGaussianVectorRV	(	const V &	muVec1,
		const V &	muVec2,
		const M &	sigmaMat11,
		const M &	sigmaMat12,
		const M &	sigmaMat21,
		const M &	sigmaMat22,
		const V &	sampleVec2,
		V &	muVec1_cond_on_2,
		M &	sigmaMat11_cond_on_2
	)

Definition at line 207 of file GaussianVectorRV.C.

References queso_require_equal_to_msg, queso_require_less_msg, queso_require_msg, and QUESO::BaseEnvironment::subDisplayFile().

Referenced by QUESO::GpmsaComputerModel< S_V, S_M, D_V, D_M, P_V, P_M, Q_V, Q_M >::predictVUsAtGridPoint(), and QUESO::GpmsaComputerModel< S_V, S_M, D_V, D_M, P_V, P_M, Q_V, Q_M >::predictWsAtGridPoint().

{
  const BaseEnvironment& env = muVec1.env();
  unsigned int dim1 = muVec1.sizeLocal();
  unsigned int dim2 = muVec2.sizeLocal();

  queso_require_msg(!((sigmaMat11.numRowsLocal() != dim1) || (sigmaMat11.numCols() != dim1)), "invalid sigmaMat11");

  queso_require_msg(!((sigmaMat12.numRowsLocal() != dim1) || (sigmaMat12.numCols() != dim2)), "invalid sigmaMat12");

  queso_require_msg(!((sigmaMat21.numRowsLocal() != dim2) || (sigmaMat21.numCols() != dim1)), "invalid sigmaMat21");

  queso_require_msg(!((sigmaMat22.numRowsLocal() != dim2) || (sigmaMat22.numCols() != dim2)), "invalid sigmaMat22");

  // Check transpose operation
  M mat_tt(sigmaMat12);
  mat_tt.cwSet(0.);
  mat_tt.fillWithTranspose(0,0,sigmaMat21,true,true);
  double auxNorm = (mat_tt - sigmaMat12).normFrob();
  if (auxNorm >= 1.e-12) {
    if (env.subDisplayFile()) {
      *env.subDisplayFile() << "In ComputeConditionalGaussianVectorRV()"
                            << ": WARNING, ||sigmaMat21^T - sigmaMat12||_2 = " << auxNorm
                            << std::endl;
    }
  }
  queso_require_less_msg(auxNorm, 1.e-12, "sigmaMat12 and sigmaMat21 are not transpose of each other");

  queso_require_equal_to_msg(sampleVec2.sizeLocal(), dim2, "invalid sampleVec2");

  queso_require_equal_to_msg(muVec1_cond_on_2.sizeLocal(), dim1, "invalid muVec1_cond_on_2");

  queso_require_msg(!((sigmaMat11_cond_on_2.numRowsLocal() != dim1) || (sigmaMat11_cond_on_2.numCols() != dim1)), "invalid sigmaMat11_cond_on_2");

  muVec1_cond_on_2     = muVec1     + sigmaMat12 * sigmaMat22.invertMultiply(sampleVec2 - muVec2);
  sigmaMat11_cond_on_2 = sigmaMat11 - sigmaMat12 * sigmaMat22.invertMultiply(sigmaMat21);

  return;
}

template<class T >

void QUESO::ComputeCovCorrBetweenScalarSequences	(	const ScalarSequence< T > &	subPSeq,
		const ScalarSequence< T > &	subQSeq,
		unsigned int	subNumSamples,
		T &	covValue,
		T &	corrValue
	)

Definition at line 4072 of file ScalarSequence.C.

References QUESO::ScalarSequence< T >::env(), QUESO::BaseEnvironment::inter0Comm(), QUESO::BaseEnvironment::inter0Rank(), k, queso_require_msg, RawValue_MPI_SUM, QUESO::ScalarSequence< T >::subSequenceSize(), QUESO::ScalarSequence< T >::unifiedMeanExtra(), and QUESO::ScalarSequence< T >::unifiedSampleVarianceExtra().

Referenced by ComputeSubGaussian2dKde().

{
  // Check input data consistency
  const BaseEnvironment& env = subPSeq.env();

  queso_require_msg(!((subNumSamples > subPSeq.subSequenceSize()) || (subNumSamples > subQSeq.subSequenceSize())), "subNumSamples is too large");

  // For both P and Q vector sequences: fill them
  T tmpP = 0.;
  T tmpQ = 0.;

  // For both P and Q vector sequences: compute the unified mean
  T unifiedMeanP = subPSeq.unifiedMeanExtra(true,0,subNumSamples);
  T unifiedMeanQ = subQSeq.unifiedMeanExtra(true,0,subNumSamples);

  // Compute "sub" covariance matrix
  covValue = 0.;
  for (unsigned k = 0; k < subNumSamples; ++k) {
    // For both P and Q vector sequences: get the difference (wrt the unified mean) in them
    tmpP = subPSeq[k] - unifiedMeanP;
    tmpQ = subQSeq[k] - unifiedMeanQ;
    covValue += tmpP*tmpQ;
  }

  // For both P and Q vector sequences: compute the unified variance
  T unifiedSampleVarianceP = subPSeq.unifiedSampleVarianceExtra(true,
                                                                0,
                                                                subNumSamples,
                                                                unifiedMeanP);

  T unifiedSampleVarianceQ = subQSeq.unifiedSampleVarianceExtra(true,
                                                                0,
                                                                subNumSamples,
                                                                unifiedMeanQ);

  // Compute unified covariance
  if (env.inter0Rank() >= 0) {
    unsigned int unifiedNumSamples = 0;
    env.inter0Comm().template Allreduce<unsigned int>(&subNumSamples, &unifiedNumSamples, (int) 1, RawValue_MPI_SUM,
                               "ComputeCovCorrBetweenScalarSequences()",
                               "failed MPI.Allreduce() for subNumSamples");

    double aux = 0.;
    env.inter0Comm().template Allreduce<double>(&covValue, &aux, (int) 1, RawValue_MPI_SUM,
                               "ComputeCovCorrBetweenScalarSequences()",
                               "failed MPI.Allreduce() for a matrix position");
    covValue = aux/((double) (unifiedNumSamples-1)); // Yes, '-1' in order to compensate for the 'N-1' denominator factor in the calculations of sample variances above (whose square roots will be used below)

    corrValue = covValue/std::sqrt(unifiedSampleVarianceP)/std::sqrt(unifiedSampleVarianceQ);

    if ((corrValue < -1.) || (corrValue > 1.)) { // prudencio 2010-07-23
      std::cerr << "In ComputeCovCorrBetweenScalarSequences()"
                << ": computed correlation is out of range, corrValue = " << corrValue
                << std::endl;
    }

    //                    env.worldRank(),
    //                    "ComputeCovCorrBetweenScalarSequences()",
    //                    "computed correlation is out of range");
  }
  else {
    // Node not in the 'inter0' communicator: do nothing extra
  }

  return;
}

template<class P_V , class P_M , class Q_V , class Q_M >

void QUESO::ComputeCovCorrMatricesBetweenVectorRvs	(	const BaseVectorRV< P_V, P_M > &	paramRv,
		const BaseVectorRV< Q_V, Q_M > &	qoiRv,
		unsigned int	localNumSamples,
		P_M &	pqCovMatrix,
		P_M &	pqCorrMatrix
	)

Definition at line 201 of file VectorRV.C.

References ComputeCovCorrMatricesBetweenVectorSequences(), QUESO::BaseVectorRV< V, M >::imageSet(), k, QUESO::VectorSpace< V, M >::numOfProcsForStorage(), queso_require_msg, QUESO::BaseVectorRealizer< V, M >::realization(), QUESO::BaseVectorRV< V, M >::realizer(), QUESO::VectorSet< V, M >::vectorSpace(), and QUESO::VectorSpace< V, M >::zeroVector().

{
  // Check input data consistency
  bool useOnlyInter0Comm = (paramRv.imageSet().vectorSpace().numOfProcsForStorage() == 1) &&
                           (qoiRv.imageSet().vectorSpace().numOfProcsForStorage()   == 1);

  queso_require_msg(useOnlyInter0Comm, "parallel vectors not supported yet");

  unsigned int numRows = paramRv.imageSet().vectorSpace().dim();
  unsigned int numCols = qoiRv.imageSet().vectorSpace().dim();

  queso_require_msg(!((numRows != pqCovMatrix.numRows()) || (numCols != pqCovMatrix.numCols())), "inconsistent dimensions for covariance matrix");

  queso_require_msg(!((numRows != pqCorrMatrix.numRows()) || (numCols != pqCorrMatrix.numCols())), "inconsistent dimensions for correlation matrix");

  queso_require_msg(!((localNumSamples > paramRv.realizer().period()) || (localNumSamples > qoiRv.realizer().period())), "localNumSamples is too large");

  // For both P and Q vector sequences: fill them
  P_V tmpP(paramRv.imageSet().vectorSpace().zeroVector());
  Q_V tmpQ(qoiRv.imageSet().vectorSpace().zeroVector());

  SequenceOfVectors<P_V,P_M> localWorkingPSeq(paramRv.imageSet().vectorSpace(),
                                                     localNumSamples,
                                                     "covTmpP");
  SequenceOfVectors<Q_V,Q_M> localWorkingQSeq(qoiRv.imageSet().vectorSpace(),
                                                     localNumSamples,
                                                     "covTmpQ");
  for (unsigned int k = 0; k < localNumSamples; ++k) {
    paramRv.realizer().realization(tmpP);
    localWorkingPSeq.setPositionValues(k,tmpP);

    qoiRv.realizer().realization(tmpQ);
    localWorkingQSeq.setPositionValues(k,tmpQ);
  }

  ComputeCovCorrMatricesBetweenVectorSequences(localWorkingPSeq,
                                                 localWorkingQSeq,
                                                 localNumSamples,
                                                 pqCovMatrix,
                                                 pqCorrMatrix);

  return;
}

template<class P_V , class P_M , class Q_V , class Q_M >

void QUESO::ComputeCovCorrMatricesBetweenVectorSequences	(	const BaseVectorSequence< P_V, P_M > &	subPSeq,
		const BaseVectorSequence< Q_V, Q_M > &	subQSeq,
		unsigned int	subNumSamples,
		P_M &	pqCovMatrix,
		P_M &	pqCorrMatrix
	)

Definition at line 2774 of file VectorSequence.C.

References QUESO::MpiComm::Barrier(), QUESO::VectorSpace< V, M >::dimGlobal(), QUESO::VectorSpace< V, M >::dimLocal(), QUESO::BaseVectorSequence< V, M >::getPositionValues(), QUESO::BaseEnvironment::inter0Comm(), QUESO::BaseEnvironment::inter0Rank(), k, QUESO::VectorSpace< V, M >::numOfProcsForStorage(), queso_require_greater_equal_msg, queso_require_greater_msg, queso_require_less_equal_msg, queso_require_msg, RawValue_MPI_SUM, QUESO::BaseVectorSequence< V, M >::subSequenceSize(), QUESO::BaseVectorSequence< V, M >::unifiedMeanExtra(), QUESO::BaseVectorSequence< V, M >::unifiedSampleVarianceExtra(), QUESO::BaseVectorSequence< V, M >::vectorSpace(), QUESO::BaseEnvironment::worldRank(), and QUESO::VectorSpace< V, M >::zeroVector().

Referenced by ComputeCovCorrMatricesBetweenVectorRvs(), QUESO::GpmsaComputerModel< S_V, S_M, D_V, D_M, P_V, P_M, Q_V, Q_M >::predictVUsAtGridPoint(), QUESO::GpmsaComputerModel< S_V, S_M, D_V, D_M, P_V, P_M, Q_V, Q_M >::predictWsAtGridPoint(), and QUESO::StatisticalForwardProblem< P_V, P_M, Q_V, Q_M >::solveWithMonteCarlo().

{
  queso_require_greater_equal_msg(subNumSamples, 2,
      "must provide at least 2 samples to compute correlation matrices");

  // Check input data consistency
  const BaseEnvironment& env = subPSeq.vectorSpace().zeroVector().env();

  bool useOnlyInter0Comm = (subPSeq.vectorSpace().numOfProcsForStorage() == 1) &&
                           (subQSeq.vectorSpace().numOfProcsForStorage() == 1);

  queso_require_msg(useOnlyInter0Comm, "parallel vectors not supported yet");

  unsigned int numRowsLocal = subPSeq.vectorSpace().dimLocal();
  unsigned int numCols = subQSeq.vectorSpace().dimGlobal();

  queso_require_msg(!((numRowsLocal != pqCovMatrix.numRowsLocal()) || (numCols != pqCovMatrix.numCols())), "inconsistent dimensions for covariance matrix");

  queso_require_msg(!((numRowsLocal != pqCorrMatrix.numRowsLocal()) || (numCols != pqCorrMatrix.numCols())), "inconsistent dimensions for correlation matrix");

  queso_require_msg(!((subNumSamples > subPSeq.subSequenceSize()) || (subNumSamples > subQSeq.subSequenceSize())), "subNumSamples is too large");

  // For both P and Q vector sequences: fill them
  P_V tmpP(subPSeq.vectorSpace().zeroVector());
  Q_V tmpQ(subQSeq.vectorSpace().zeroVector());

  // For both P and Q vector sequences: compute the unified mean
  P_V unifiedMeanP(subPSeq.vectorSpace().zeroVector());
  subPSeq.unifiedMeanExtra(0,subNumSamples,unifiedMeanP);

  Q_V unifiedMeanQ(subQSeq.vectorSpace().zeroVector());
  subQSeq.unifiedMeanExtra(0,subNumSamples,unifiedMeanQ);

  // Compute "sub" covariance matrix
  for (unsigned i = 0; i < numRowsLocal; ++i) {
    for (unsigned j = 0; j < numCols; ++j) {
      pqCovMatrix(i,j) = 0.;
    }
  }
  for (unsigned k = 0; k < subNumSamples; ++k) {
    // For both P and Q vector sequences: get the difference (wrt the unified mean) in them
    subPSeq.getPositionValues(k,tmpP);
    tmpP -= unifiedMeanP;

    subQSeq.getPositionValues(k,tmpQ);
    tmpQ -= unifiedMeanQ;

    for (unsigned i = 0; i < numRowsLocal; ++i) {
      for (unsigned j = 0; j < numCols; ++j) {
        pqCovMatrix(i,j) += tmpP[i]*tmpQ[j];
      }
    }
  }

  // For both P and Q vector sequences: compute the unified variance
  P_V unifiedSampleVarianceP(subPSeq.vectorSpace().zeroVector());
  subPSeq.unifiedSampleVarianceExtra(0,
                                     subNumSamples,
                                     unifiedMeanP,
                                     unifiedSampleVarianceP);

  Q_V unifiedSampleVarianceQ(subQSeq.vectorSpace().zeroVector());
  subQSeq.unifiedSampleVarianceExtra(0,
                                     subNumSamples,
                                     unifiedMeanQ,
                                     unifiedSampleVarianceQ);

  // Check the variance is positive in every component
  double minSampleVarianceP;
  double minSampleVarianceQ;
  minSampleVarianceP = unifiedSampleVarianceP.getMinValue();
  minSampleVarianceQ = unifiedSampleVarianceQ.getMinValue();
  queso_require_greater_msg(minSampleVarianceP, 0.0, "sample variance is not positive");
  queso_require_greater_msg(minSampleVarianceQ, 0.0, "sample variance is not positive");

  // Compute unified covariance matrix
  if (useOnlyInter0Comm) {
    if (env.inter0Rank() >= 0) {
      unsigned int unifiedNumSamples = 0;
      env.inter0Comm().template Allreduce<unsigned int>(&subNumSamples, &unifiedNumSamples, (int) 1, RawValue_MPI_SUM,
                                 "ComputeCovCorrMatricesBetweenVectorSequences()",
                                 "failed MPI.Allreduce() for subNumSamples");

      for (unsigned i = 0; i < numRowsLocal; ++i) {
        for (unsigned j = 0; j < numCols; ++j) {
          double aux = 0.;
          env.inter0Comm().template Allreduce<double>(&pqCovMatrix(i,j), &aux, (int) 1, RawValue_MPI_SUM,
                                     "ComputeCovCorrMatricesBetweenVectorSequences()",
                                     "failed MPI.Allreduce() for a matrix position");
          pqCovMatrix(i,j) = aux/((double) (unifiedNumSamples-1)); // Yes, '-1' in order to compensate for the 'N-1' denominator factor in the calculations of sample variances above (whose square roots will be used below)
        }
      }

      for (unsigned i = 0; i < numRowsLocal; ++i) {
        for (unsigned j = 0; j < numCols; ++j) {
          pqCorrMatrix(i,j) = pqCovMatrix(i,j)/std::sqrt(unifiedSampleVarianceP[i])/std::sqrt(unifiedSampleVarianceQ[j]);
          if (((pqCorrMatrix(i,j) + 1.) < -1.e-8) ||
              ((pqCorrMatrix(i,j) - 1.) >  1.e-8)) {
            if (env.inter0Rank() == 0) {
              std::cerr << "In ComputeCovCorrMatricesBetweenVectorSequences()"
                        << ": worldRank = "            << env.worldRank()
                        << ", i = "                   << i
                        << ", j = "                   << j
                        << ", pqCorrMatrix(i,j)+1 = " << pqCorrMatrix(i,j)+1.
                        << ", pqCorrMatrix(i,j)-1 = " << pqCorrMatrix(i,j)-1.
                        << std::endl;
            }
            env.inter0Comm().Barrier();
          }
          queso_require_greater_equal_msg
            (pqCorrMatrix(i,j), -1. - 1.e-8,
             "computed correlation is out of range");
          queso_require_less_equal_msg
            (pqCorrMatrix(i,j), 1. + 1.e-8,
             "computed correlation is out of range");
        }
      }
    }
    else {
      // Node not in the 'inter0' communicator: do nothing extra
    }
  }
  else {
    queso_require_msg(useOnlyInter0Comm, "parallel vectors not supported yet (2)");
  }

  return;
}

template<class T >

void QUESO::ComputeSubGaussian2dKde	(	const ScalarSequence< T > &	scalarSeq1,
		const ScalarSequence< T > &	scalarSeq2,
		unsigned int	initialPos,
		double	scaleValue1,
		double	scaleValue2,
		const std::vector< T > &	evaluationPositions1,
		const std::vector< T > &	evaluationPositions2,
		std::vector< double > &	densityValues
	)

Definition at line 3963 of file ScalarSequence.C.

References ComputeCovCorrBetweenScalarSequences(), k, queso_require_equal_to_msg, queso_require_msg, and QUESO::ScalarSequence< T >::subSequenceSize().

Referenced by ComputeUnifiedGaussian2dKde().

{
  queso_require_equal_to_msg(initialPos, 0, "not implemented yet for initialPos != 0");

  double covValue  = 0.;
  double corrValue = 0.;
  ComputeCovCorrBetweenScalarSequences(scalarSeq1,
                                         scalarSeq2,
                                         scalarSeq1.subSequenceSize(),
                                         covValue,
                                         corrValue);

  bool bRC = ((initialPos                   <  scalarSeq1.subSequenceSize()) &&
              (scalarSeq1.subSequenceSize() == scalarSeq2.subSequenceSize()) &&
              (0                            <  evaluationPositions1.size() ) &&
              (evaluationPositions1.size()  == evaluationPositions2.size() ) &&
              (evaluationPositions1.size()  == densityValues.size()        ));
  queso_require_msg(bRC, "invalid input data");

  unsigned int dataSize = scalarSeq1.subSequenceSize() - initialPos;
  unsigned int numEvals = evaluationPositions1.size();

  double scale1Inv = 1./scaleValue1;
  double scale2Inv = 1./scaleValue2;
  //corrValue = 0.;
  double r = 1. - corrValue*corrValue;
  if (r <= 0.) { // prudencio 2010-07-23
    std::cerr << "In ComputeSubGaussian2dKde()"
              << ": WARNING, r = " << r
              << std::endl;
  }

  //                    scalarSeq1.env().worldRank(),
  //                    "ComputeSubGaussian2dKde()",
  //                    "negative r");
  for (unsigned int j = 0; j < numEvals; ++j) {
    double x1 = evaluationPositions1[j];
    double x2 = evaluationPositions2[j];
    double value = 0.;
    for (unsigned int k = 0; k < dataSize; ++k) {
      double d1k = scale1Inv*(x1 - scalarSeq1[initialPos+k]);
      double d2k = scale2Inv*(x2 - scalarSeq2[initialPos+k]);
      value += exp(-.5*( d1k*d1k + 2*corrValue*d1k*d2k + d2k*d2k )/r);
    }
    densityValues[j] = scale1Inv * scale2Inv * (value/(double) dataSize) / 2. / M_PI / sqrt(r);
  }

  return;
}

template<class T >

void QUESO::ComputeUnifiedGaussian2dKde	(	bool	useOnlyInter0Comm,
		const ScalarSequence< T > &	scalarSeq1,
		const ScalarSequence< T > &	scalarSeq2,
		unsigned int	initialPos,
		double	unifiedScaleValue1,
		double	unifiedScaleValue2,
		const std::vector< T > &	unifiedEvaluationPositions1,
		const std::vector< T > &	unifiedEvaluationPositions2,
		std::vector< double > &	unifiedDensityValues
	)

Definition at line 4022 of file ScalarSequence.C.

References ComputeSubGaussian2dKde(), QUESO::ScalarSequence< T >::env(), QUESO::BaseEnvironment::inter0Rank(), QUESO::BaseEnvironment::numSubEnvironments(), and queso_error_msg.

{
  if (scalarSeq1.env().numSubEnvironments() == 1) {
    return ComputeSubGaussian2dKde(scalarSeq1,
                                     scalarSeq2,
                                     initialPos,
                                     unifiedScaleValue1,
                                     unifiedScaleValue2,
                                     unifiedEvaluationPositions1,
                                     unifiedEvaluationPositions2,
                                     unifiedDensityValues);
  }

  // As of 14/Nov/2009, this routine needs to be checked if it requires sub sequences to have equal size. Good.

  if (useOnlyInter0Comm) {
    if (scalarSeq1.env().inter0Rank() >= 0) {
      queso_error_msg("inter0 case not supported yet");
    }
    else {
      // Node not in the 'inter0' communicator
      ComputeSubGaussian2dKde(scalarSeq1,
                                scalarSeq2,
                                initialPos,
                                unifiedScaleValue1,
                                unifiedScaleValue2,
                                unifiedEvaluationPositions1,
                                unifiedEvaluationPositions2,
                                unifiedDensityValues);
    }
  }
  else {
    queso_error_msg("parallel vectors not supported yet");
  }

  //scalarSeq1.env().fullComm().Barrier();

  return;
}

template<class V , class M >

void QUESO::CovCond	(	double	condNumber,
		const V &	direction,
		M &	covMatrix,
		M &	precMatrix
	)

Definition at line 30 of file CovCond.C.

References leftDiagScaling(), and matrixProduct().

{
  //std::cout << "Entering CovCond()"
  //          << std::endl;

  V v1(direction);
  //std::cout << "In CovCond(), v1 contents are:"
  //          << std::endl
  //          << v1
  //          << std::endl;

  V v2(direction,condNumber,1.0); // MATLAB linspace
  v2.cwInvert();
  v2.sort();
  //std::cout << "In CovCond(), v2 contents are:"
  //          << std::endl
  //          << v2
  //          << std::endl;

  double v1Norm2 = v1.norm2();
  if (v1[0] >=0) v1[0] += v1Norm2;
  else           v1[0] -= v1Norm2;
  double v1Norm2Sq = v1.norm2Sq();

  M Z(direction,1.0);
  Z -= (2./v1Norm2Sq) * matrixProduct(v1,v1);
  //std::cout << "In CovCond(), Z contents are:"
  //          << std::endl
  //          << Z
  //          << std::endl;

  M Zt(Z.transpose());
  covMatrix  = Z * leftDiagScaling(v2,   Zt);
  precMatrix = Z * leftDiagScaling(1./v2,Zt);

  //std::cout << "Leaving CovCond()"
  //          << std::endl;
}

int QUESO::GRVY_CheckDir

(

const char *

dirname

)

Definition at line 456 of file Miscellaneous.C.

Referenced by CheckFilePath().

{
  struct stat st;

  if(stat(dirname,&st) != 0)
    {
      if( mkdir(dirname,0700) != 0 )
        {
          std::cerr << __func__ << ": error - unable to create directory " << dirname << std::endl;
          return -1;
        }
    }
  else if (!S_ISDIR(st.st_mode))
    {
      std::cerr << __func__ << ": error - entry exists, but is not a directory " << dirname << std::endl;
      return -1;
    }

  return 0;
}

template<class T >

double QUESO::horizontalDistance	(	const BaseScalarCdf< T > &	cdf1,
		const BaseScalarCdf< T > &	cdf2,
		double	epsilon
	)

It calculated the maximum horizontal distance between two CDFs.

Definition at line 96 of file ScalarCdf.C.

References QUESO::BaseEnvironment::displayVerbosity(), QUESO::BaseScalarCdf< T >::env(), QUESO::BaseScalarCdf< T >::inverse(), QUESO::BaseScalarCdf< T >::prefix(), QUESO::BaseEnvironment::subDisplayFile(), and QUESO::BaseScalarCdf< T >::value().

Referenced by horizontalDistances().

{
  double maxDistance     = 0.;
  double xForMaxDistance = 0.;

  double x1 = cdf1.inverse(epsilon*.5);
  double x2 = cdf1.inverse(1.-epsilon*.5);
  if (cdf1.env().subDisplayFile()) {
    *cdf1.env().subDisplayFile() << "In horizontalDistance()"
                                 << ", cdf1.prefix() = " << cdf1.prefix()
                                 << ", cdf2.prefix() = " << cdf2.prefix()
                                 << ", epsilon = "       << epsilon
                                 << ": x1 = "            << x1
                                 << ", x2 = "            << x2
                                 << std::endl;
  }

  //if (cdf1.env().subDisplayFile()) {
  //  *cdf1.env().subDisplayFile() << "In horizontalDistance: x1 = " << x1
  //                              << ", x2 = " << x2
  //                              << std::endl;
  //}

  double numEvaluationPoints = 1001.;
  for (double i = 0.; i < numEvaluationPoints; ++i) {
    double ratio = i/(numEvaluationPoints-1.); // IMPORTANT: Yes, '-1.'
    double x = (1.-ratio)*x1 + ratio*x2;
    double y = cdf2.inverse(cdf1.value(x));
    double d = fabs(x-y);
    if ((cdf1.env().subDisplayFile()) && (cdf1.env().displayVerbosity() >= 3)) {
      *cdf1.env().subDisplayFile() << "In horizontalDistance"
                                   << ": i = "                  << i
                                   << ", x = "                  << x
                                   << ", cdf1.value(x) = "      << cdf1.value(x)
                                   << ", y = "                  << y
                                   << ", d = "                  << d
                                   << ", currentMaxDistance = " << maxDistance
                                   << std::endl;
    }
    if (maxDistance < d) {
      maxDistance     = d;
      xForMaxDistance = x;
      if ((cdf1.env().subDisplayFile()) && (cdf1.env().displayVerbosity() >= 3)) {
        *cdf1.env().subDisplayFile() << "In horizontalDistance"
                                     << ": i = "               << i
                                     << ", NOW maxDistance = " << maxDistance
                                     << ", xForMaxDistance = " << xForMaxDistance
                                     << std::endl;
      }
    }
  }

  if (cdf1.env().subDisplayFile()) {
    *cdf1.env().subDisplayFile() << "In horizontalDistance()"
                                 << ", cdf1.prefix() = "   << cdf1.prefix()
                                 << ", cdf2.prefix() = "   << cdf2.prefix()
                                 << ", epsilon = "         << epsilon
                                 << ": maxDistance = "     << maxDistance
                                 << ", xForMaxDistance = " << xForMaxDistance
                                 << std::endl;
  }

  return maxDistance;
}

template<class V , class M >

void QUESO::horizontalDistances	(	const BaseVectorCdf< V, M > &	cdf1,
		const BaseVectorCdf< V, M > &	cdf2,
		const V &	epsilonVec,
		V &	distances
	)

It calculated the maximum horizontal distances between two vector CDFs.

Definition at line 84 of file VectorCdf.C.

References QUESO::BaseVectorCdf< V, M >::cdf(), horizontalDistance(), and QUESO::BaseVectorCdf< V, M >::pdfSupport().

{
  for (unsigned int i = 0; i < cdf1.pdfSupport().vectorSpace().dimLocal(); ++i) {
    distances[i] = horizontalDistance(cdf1.cdf(i),
                                      cdf2.cdf(i),
                                      epsilonVec[i]);
  }

  return;
}

template<class V , class M >

VectorSet< V, M > * QUESO::InstantiateIntersection	(	const VectorSet< V, M > &	domain1,
		const VectorSet< V, M > &	domain2
	)

This method calculates the intersection of domain1 and domain2.

It is used, for instance, to calculate the domain of the Posterior PDF, which is the intersection of the domain of the Prior PDF and of the likelihood function.

Definition at line 37 of file InstantiateIntersection.C.

References QUESO::VectorSpace< V, M >::dimGlobal(), QUESO::VectorSpace< V, M >::env(), QUESO::BoxSubset< V, M >::maxValues(), QUESO::BoxSubset< V, M >::minValues(), QUESO::VectorSet< V, M >::prefix(), queso_error_msg, QUESO::VectorSubset< V, M >::vectorSpace(), and QUESO::VectorSet< V, M >::vectorSpace().

Referenced by QUESO::GpmsaComputerModel< S_V, S_M, D_V, D_M, P_V, P_M, Q_V, Q_M >::calibrateWithBayesMetropolisHastings(), QUESO::GpmsaComputerModel< S_V, S_M, D_V, D_M, P_V, P_M, Q_V, Q_M >::calibrateWithBayesMLSampling(), QUESO::StatisticalInverseProblem< P_V, P_M >::solveWithBayesMetropolisHastings(), and QUESO::StatisticalInverseProblem< P_V, P_M >::solveWithBayesMLSampling().

{
  VectorSet<V,M>* result = NULL;

  unsigned int dim1 = domain1.vectorSpace().dimGlobal();
  unsigned int dim2 = domain2.vectorSpace().dimGlobal();

  if (result == NULL) {
    const VectorSpace<V,M>* tmp1 = dynamic_cast<const VectorSpace<V,M>* >(&domain1);
    const VectorSpace<V,M>* tmp2 = dynamic_cast<const VectorSpace<V,M>* >(&domain2);

    if ((tmp1 != NULL) && (tmp2 != NULL)) {
      if (dim1 < dim2) {
        result = new VectorSpace<V,M>(tmp1->env(),
                                             tmp1->prefix().c_str(),
                                             tmp1->dimGlobal(),
                                             NULL);//tmp1->componentsNames());
      }
      else if (dim1 == dim2) {
        result = new VectorSpace<V,M>(tmp1->env(),
                                             tmp1->prefix().c_str(),
                                             tmp1->dimGlobal(),
                                             NULL);//tmp1->componentsNames());
      }
      else {
        result = new VectorSpace<V,M>(tmp2->env(),
                                             tmp2->prefix().c_str(),
                                             tmp2->dimGlobal(),
                                             NULL);//tmp2->componentsNames());
      }
    }
  }

  if (result == NULL) {
    const VectorSubset<V,M>* tmp1 = dynamic_cast<const VectorSubset<V,M>* >(&domain1);
    const VectorSubset<V,M>* tmp2 = dynamic_cast<const VectorSubset<V,M>* >(&domain2);

    if ((tmp1 != NULL) && (tmp2 != NULL)) {
      if (dim1 == dim2) {
        const BoxSubset<V,M>* box1 = dynamic_cast<const BoxSubset<V,M>* >(&domain1);
        const BoxSubset<V,M>* box2 = dynamic_cast<const BoxSubset<V,M>* >(&domain2);

        if ((box1 != NULL) && (box2 != NULL)) {
          V minV(box1->minValues());
          V maxV(box1->maxValues());
          for (unsigned int i = 0; i < dim1; ++i) {
            minV[i] = std::max(box1->minValues()[i],
                               box2->minValues()[i]);
          }
          for (unsigned int i = 0; i < dim1; ++i) {
            maxV[i] = std::min(box1->maxValues()[i],
                               box2->maxValues()[i]);
          }
          result = new BoxSubset<V,M>(box1->prefix().c_str(),
                                             box1->vectorSpace(),
                                             minV,
                                             maxV);
        }
        else {
          result = new IntersectionSubset<V,M>(tmp1->prefix().c_str(),
                                                      tmp1->vectorSpace(),
                                                      0., // FIX ME
                                                      domain1,
                                                      domain2);
        }
      }
      else {
        queso_error_msg("situation 001");
      }
    }
  }

  if (result == NULL) {
    const VectorSubset<V,M>* tmp1 = dynamic_cast<const VectorSubset<V,M>* >(&domain1);
    const VectorSpace <V,M>* tmp2 = dynamic_cast<const VectorSpace <V,M>* >(&domain2);

    if ((tmp1 != NULL) && (tmp2 != NULL)) {
      if (dim1 == dim2) {
        const BoxSubset<V,M>* box1 = dynamic_cast<const BoxSubset<V,M>* >(&domain1);
        if (box1 != NULL) {
          result = new BoxSubset<V,M>(box1->prefix().c_str(),
                                             box1->vectorSpace(),
                                             box1->minValues(),
                                             box1->maxValues());
        }
        else {
          queso_error_msg("situation 002");
        }
      }
      else {
        queso_error_msg("situation 003");
      }
    }
  }

  if (result == NULL) {
    const VectorSpace <V,M>* tmp1 = dynamic_cast<const VectorSpace <V,M>* >(&domain1);
    const VectorSubset<V,M>* tmp2 = dynamic_cast<const VectorSubset<V,M>* >(&domain2);

    if ((tmp1 != NULL) && (tmp2 != NULL)) {
      if (dim1 == dim2) {
        const BoxSubset<V,M>* box2 = dynamic_cast<const BoxSubset<V,M>* >(&domain2);
        if (box2 != NULL) {
          result = new BoxSubset<V,M>(box2->prefix().c_str(),
                                             box2->vectorSpace(),
                                             box2->minValues(),
                                             box2->maxValues());
        }
        else {
          queso_error_msg("situation 004");
        }
      }
      else {
        queso_error_msg("situation 005");
      }
    }
  }

  if (result == NULL) {
    queso_error_msg("situation 006");
  }

  return result;
}

GslMatrix QUESO::leftDiagScaling	(	const GslVector &	vec,
		const GslMatrix &	mat
	)

Definition at line 2052 of file GslMatrix.C.

References QUESO::GslMatrix::numCols(), QUESO::GslMatrix::numRowsLocal(), queso_require_equal_to_msg, and QUESO::GslVector::sizeLocal().

Referenced by CovCond().

{
  unsigned int vSize = vec.sizeLocal();
  unsigned int mRows = mat.numRowsLocal();
  unsigned int mCols = mat.numCols();

  queso_require_equal_to_msg(vSize, mRows, "size of vector is different from the number of rows in matrix");

  queso_require_equal_to_msg(mCols, mRows, "routine currently works for square matrices only");

  GslMatrix answer(mat);
  for (unsigned int i = 0; i < mRows; ++i) {
    double vecValue = vec[i];
    for (unsigned int j = 0; j < mCols; ++j) {
      answer(i,j) *= vecValue;
    }
  }

  return answer;
}

GslMatrix QUESO::matrixProduct	(	const GslVector &	v1,
		const GslVector &	v2
	)

Definition at line 2036 of file GslMatrix.C.

References QUESO::Vector::env(), QUESO::Vector::map(), and QUESO::GslVector::sizeLocal().

Referenced by CovCond(), QUESO::SequenceOfVectors< V, M >::estimateConvBrooksGelman(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step04_inter0(), and QUESO::MetropolisHastingsSG< P_V, P_M >::updateAdaptedCovMatrix().

{
  unsigned int nRows = v1.sizeLocal();
  unsigned int nCols = v2.sizeLocal();
  GslMatrix answer(v1.env(),v1.map(),nCols);

  for (unsigned int i = 0; i < nRows; ++i) {
    double value1 = v1[i];
    for (unsigned int j = 0; j < nCols; ++j) {
      answer(i,j) = value1*v2[j];
    }
  }

  return answer;
}

template<class T >

bool QUESO::MiscCheckForSameValueInAllNodes	(	T &	inputValue,
		double	acceptableTreshold,
		const MpiComm &	comm,
		const char *	whereString
	)

Definition at line 479 of file Miscellaneous.C.

References QUESO::MpiComm::Allreduce(), QUESO::MpiComm::Barrier(), QUESO::MpiComm::Bcast(), QUESO::MpiComm::MyPID(), QUESO::MpiComm::NumProc(), queso_require_less_equal_msg, RawValue_MPI_DOUBLE, and RawValue_MPI_SUM.

Referenced by QUESO::MLSampling< P_V, P_M >::generateSequence_Step03_inter0(), and QUESO::MLSampling< P_V, P_M >::generateSequence_Step09_all().

{
  // Filter out those nodes that should not participate
  if (comm.MyPID() < 0) return true;

  double localValue = (double) inputValue;
  double sumValue = 0.;
  comm.Allreduce<double>(&localValue, &sumValue, (int) 1, RawValue_MPI_SUM,
                 whereString,
                 "failed MPI on 'sumValue' inside MiscCheckForSameValueInAllNodes()");

  double totalNumNodes = (double) comm.NumProc();
  double testValue = fabs(1. - localValue/(sumValue/totalNumNodes));
  unsigned int boolSum = 0;
#if 1
  unsigned int boolResult = 0;
  if (testValue > acceptableTreshold) boolResult = 1;
  comm.Allreduce<unsigned int>(&boolResult, &boolSum, (int) 1, RawValue_MPI_SUM,
                 whereString,
                 "failed MPI on 'boolSum' inside MiscCheckForSameValueInAllNodes()");

  if (boolSum > 0) {
    comm.Barrier();
    for (int i = 0; i < comm.NumProc(); ++i) {
      if (i == comm.MyPID()) {
        std::cerr << "WARNING, "
                  << whereString
                  << ", inside MiscCheckForSameValueInAllNodes()"
                  << ", rank (in this communicator) = " << i
                  << ": boolSum = "       << boolSum
                  << ", localValue = "    << localValue
                  << ", sumValue = "      << sumValue
                  << ", totalNumNodes = " << totalNumNodes
                  << ", avgValue = "      << (sumValue/totalNumNodes)
                  << ", relativeTest = "  << testValue
                  << std::endl;
      }
      comm.Barrier();
    }
    comm.Barrier();

    comm.Bcast((void *) &localValue, (int) 1, RawValue_MPI_DOUBLE, 0,
               whereString,
               "failed MPI on 'boolSum' inside MiscCheckForSameValueInAllNodes()");
    inputValue = localValue; // IMPORTANT
  }
#else
  queso_require_less_equal_msg(testValue, acceptableTreshold, "not all nodes have the same value inside MiscCheckForSameValueInAllNodes()");
#endif

  return (boolSum == 0);
}

template<class V1 , class V2 >

void QUESO::MiscCheckTheParallelEnvironment	(	const V1 &	vec1,
		const V2 &	vec2
	)

Definition at line 564 of file Miscellaneous.C.

References QUESO::BaseEnvironment::fullComm(), QUESO::MpiComm::NumProc(), QUESO::BaseEnvironment::numSubEnvironments(), queso_error_msg, queso_require_equal_to_msg, QUESO::BaseEnvironment::subComm(), and QUESO::BaseEnvironment::subRank().

{
  const BaseEnvironment& env = vec1.env();

  if (env.numSubEnvironments() == (unsigned int) env.fullComm().NumProc()) {
    queso_require_equal_to_msg(env.subRank(), 0, "there should exist only one processor per sub environment");
    queso_require_equal_to_msg(vec1.numOfProcsForStorage(), 1,
      "only 1 processor (per sub environment) should be necessary for the storage of a parameter vector");
    queso_require_equal_to_msg(vec2.numOfProcsForStorage(), 1,
      "only 1 processor (per sub environment) should be necessary for the storage of a parameter vector");
  }
  else if (env.numSubEnvironments() < (unsigned int) env.fullComm().NumProc()) {
    queso_require_equal_to_msg(env.fullComm().NumProc()%env.numSubEnvironments(), 0, "total number of processors should be a multiple of the number of sub environments");
    unsigned int numProcsPerSubEnvironment = env.fullComm().NumProc()/env.numSubEnvironments();
    queso_require_equal_to_msg(env.subComm().NumProc(), (int) numProcsPerSubEnvironment, "inconsistent number of processors per sub environment");
    if ((vec1.numOfProcsForStorage() == 1) &&
        (vec2.numOfProcsForStorage() == 1)) {
      // Ok
    }
    else if ((vec1.numOfProcsForStorage() == numProcsPerSubEnvironment) &&
             (vec2.numOfProcsForStorage() == numProcsPerSubEnvironment)) {
      queso_error_msg("parallel vectors are not supported yet");
    }
    else {
      queso_error_msg("number of processors required for a vector storage should be equal to either 1 or to the number of processors in the sub environment");
    }
  }
  else {
    queso_error_msg("number of processors per sub environment is less than 1!");
  }

  return;
}

template<class V >

void QUESO::MiscComputePositionsBetweenMinMax	(	V	minValues,
		V	maxValues,
		std::vector< V * > &	positions
	)

Definition at line 537 of file Miscellaneous.C.

{
  double factor = 0.5;
  switch (positions.size()) {
    case 0:
      // Do nothing
    break;

    case 1:
      positions[0] = new V((1. - factor) * minValues + factor * maxValues);
    break;

    default:
      for (unsigned int i = 0; i < positions.size(); ++i) {
        factor = ((double) i)/(((double) positions.size()) - 1.);
        positions[i] = new V((1. - factor) * minValues + factor * maxValues);
      }
    break;
  }

  return;
}

double QUESO::MiscDoubleDebugMessage	(	double	value,
		const char *	message
	)

Definition at line 334 of file Miscellaneous.C.

{
  if (message) {
    std::cout << "Passing in MiscDoubleDebugMessage(), value = " << value << ", message = " << message << std::endl;
  }
  return value;
}

double QUESO::MiscGammar	(	double	a,
		double	b,
		const RngBase *	rngObject
	)

Definition at line 248 of file Miscellaneous.C.

References QUESO::RngBase::gaussianSample(), and QUESO::RngBase::uniformSample().

{
  double result = 0.;
  if (a < 1.) {
    result = MiscGammar(1.+a,b,rngObject)*std::pow( rngObject->uniformSample(),1./a );
  }
  else {
    double d = a-1./3.;
    double c = 1./std::sqrt(9.*d);
    double x = 0.;
    double w = 0.;
    while (1) {
      while (1) {
        x = rngObject->gaussianSample(1.);
        w = 1.+c*x;
        if (w > 0.) break;
      }
      w = std::pow(w,3.);
      double u = rngObject->uniformSample();
      double compValue = 1.-0.0331*std::pow(x,4.);
      if (u < compValue) break;
      compValue = 0.5*std::pow(x,2.)+d*(1.-w+log(w));
      if (log(u) < compValue) break;
    }
    result = b*d*w;
  }

  return result;
}

double QUESO::MiscGaussianDensity	(	double	x,
		double	mu,
		double	sigma
	)

Definition at line 306 of file Miscellaneous.C.

Referenced by QUESO::ArrayOfSequences< V, M >::gaussianKDE(), QUESO::ScalarSequence< T >::subGaussian1dKde(), and QUESO::ScalarSequence< T >::unifiedGaussian1dKde().

{
  double sigma2 = sigma*sigma;
  double diff   = x-mu;

  return (1./std::sqrt(2*M_PI*sigma2))*std::exp(-.5*diff*diff/sigma2);
}

double QUESO::MiscGetEllapsedSeconds

(

struct timeval *

timeval0

)

Definition at line 282 of file Miscellaneous.C.

Referenced by QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::actualGenerateSequence(), QUESO::MetropolisHastingsSG< P_V, P_M >::adapt(), QUESO::GpmsaComputerModel< S_V, S_M, D_V, D_M, P_V, P_M, Q_V, Q_M >::calibrateWithBayesMetropolisHastings(), QUESO::GpmsaComputerModel< S_V, S_M, D_V, D_M, P_V, P_M, Q_V, Q_M >::calibrateWithBayesMLSampling(), QUESO::GpmsaComputerModel< S_V, S_M, D_V, D_M, P_V, P_M, Q_V, Q_M >::calibrateWithLanlMcmc(), QUESO::MetropolisHastingsSG< P_V, P_M >::delayedRejection(), QUESO::MLSampling< P_V, P_M >::generateBalLinkedChains_all(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateFullChain(), QUESO::MLSampling< P_V, P_M >::generateSequence(), QUESO::MLSampling< P_V, P_M >::generateSequence_Level0_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step01_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step02_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step03_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step04_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step05_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step06_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step07_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step08_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step09_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step10_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step11_inter0(), QUESO::MLSampling< P_V, P_M >::generateUnbLinkedChains_all(), QUESO::MLSampling< P_V, P_M >::justBalance_proc0(), QUESO::GpmsaComputerModel< S_V, S_M, D_V, D_M, P_V, P_M, Q_V, Q_M >::likelihoodRoutine(), QUESO::GpmsaComputerModel< S_V, S_M, D_V, D_M, P_V, P_M, Q_V, Q_M >::predictVUsAtGridPoint(), QUESO::GpmsaComputerModel< S_V, S_M, D_V, D_M, P_V, P_M, Q_V, Q_M >::predictWsAtGridPoint(), QUESO::SequenceOfVectors< V, M >::unifiedReadContents(), QUESO::ScalarSequence< T >::unifiedReadContents(), QUESO::SequenceOfVectors< V, M >::unifiedWriteContents(), and QUESO::ScalarSequence< T >::unifiedWriteContents().

{
  double result = 0.;

  struct timeval timevalNow;
  /*int iRC;*/
  /*iRC = */gettimeofday(&timevalNow, NULL);

  result  = (double) (timevalNow.tv_sec  - timeval0->tv_sec );
  result *= 1.e+6;
  result += (double) (timevalNow.tv_usec - timeval0->tv_usec);
  result *= 1.e-6;

  return result;
}

double QUESO::MiscHammingWindow	(	unsigned int	N,
		unsigned int	j
	)

Definition at line 298 of file Miscellaneous.C.

{
  double angle = 2.*M_PI*((double) j)/((double) N);
  double result = 0.53836 - 0.46164*cos(angle);

  return result;
}

int QUESO::MiscIntDebugMessage	(	int	value,
		const char *	message
	)

Definition at line 324 of file Miscellaneous.C.

{
  if (message) {
    std::cout << "Passing in MiscIntDebugMessage(), value = " << value << ", message = " << message << std::endl;
  }
  return value;
}

int QUESO::MiscReadCharsAndDoubleFromFile	(	std::ifstream &	ifs,
		std::string &	termString,
		double *	termValue,
		bool &	endOfLineAchieved
	)

Definition at line 191 of file Miscellaneous.C.

References UQ_FAILED_READING_FILE_RC, and UQ_OK_RC.

Referenced by QUESO::AsciiTable< V, M >::readColumnsFromFile().

{
  int iRC = UQ_OK_RC;
  endOfLineAchieved = false;

  char c = ' ';
  while (c == ' ') {
    ifs.get(c);
    if ((ifs.rdstate() & std::ifstream::failbit)) {
      iRC = UQ_FAILED_READING_FILE_RC;
      break;
    }
  };

  char term[512];
  unsigned int pos = 0;

  if (!iRC) {
    while ((pos < 512) && (c != '\n') && (c != '\0') && (c != ' ')) {
      term[pos++] = c;
      if ((ifs.rdstate() & std::ifstream::failbit)) {
        iRC = UQ_FAILED_READING_FILE_RC;
        break;
      }
      ifs.get(c);
    };
  }

  if (!iRC) {
    if (c == '\n') endOfLineAchieved = true;
    term[pos] = '\0';
    termString = term;
    //std::cout << "Read chars = " << termString << std::endl;
    if (termValue) {
      if (termString == std::string("inf")) {
        *termValue = INFINITY;
      }
      else if (termString == std::string("-inf")) {
        *termValue = -INFINITY;
      }
      else if (termString == std::string("nan")) {
        *termValue = nan("");
      }
      else {
        *termValue = strtod(termString.c_str(),NULL);
      }
    }
  }

  return iRC;
}

void QUESO::MiscReadDoublesFromString	(	const std::string &	inputString,
		std::vector< double > &	outputDoubles
	)

Definition at line 40 of file Miscellaneous.C.

References queso_require_not_equal_to_msg.

Referenced by BoostInputOptionsParser::getOption< std::vector< double, std::allocator< double > > >(), QUESO::ExperimentModelOptions::getMyOptionValues(), QUESO::SimulationModelOptions::getMyOptionValues(), QUESO::GpmsaComputerModelOptions::getMyOptionValues(), QUESO::StatisticalForwardProblemOptions::getMyOptionValues(), QUESO::StatisticalInverseProblemOptions::getMyOptionValues(), QUESO::MonteCarloSGOptions::getMyOptionValues(), QUESO::EnvironmentOptions::getMyOptionValues(), QUESO::MetropolisHastingsSGOptions::getMyOptionValues(), and QUESO::BoostInputOptionsParser::getOption().

{
  //std::cout << "In MiscReadDoublesFromString()"
  //          << ": inputString = " << inputString
  //          << std::endl;
  outputDoubles.clear();
  bool aDoubleIsBeingRead = false;
  std::string::size_type positionOfFirstChar = 0;
  std::string::size_type numberOfChars = 0;
  for (std::string::size_type i = 0; i < inputString.size(); ++i) {
    queso_require_not_equal_to_msg(inputString[i], '\0', "character '\0' should not be found!");
    if (inputString[i] == ' ') {
      if (aDoubleIsBeingRead == true) {
        // We just finished reading the current string/double. Convert string to double now.
        char tmpVar[numberOfChars+1];
        for (std::string::size_type j = 0; j < numberOfChars; ++j) {
          tmpVar[j] = inputString[positionOfFirstChar+j];
        }
        tmpVar[numberOfChars] = '\0';
        outputDoubles.push_back(strtod(tmpVar,NULL));

        // Continue loop
        aDoubleIsBeingRead = false;
        positionOfFirstChar = 0;
        numberOfChars = 0;
      }
    }
    else {
      if (aDoubleIsBeingRead == false) {
        aDoubleIsBeingRead = true;
        positionOfFirstChar = i;
      }
      numberOfChars++;
    }
  } // for
  if (aDoubleIsBeingRead == true) {
    // We just finished reading the current string/double. Convert string to double now.
    char tmpVar[numberOfChars+1];
    for (std::string::size_type j = 0; j < numberOfChars; ++j) {
      tmpVar[j] = inputString[positionOfFirstChar+j];
    }
    tmpVar[numberOfChars] = '\0';
    outputDoubles.push_back(strtod(tmpVar,NULL));
  }
  std::vector<double>(outputDoubles).swap(outputDoubles);

  return;
}

int QUESO::MiscReadStringAndDoubleFromFile	(	std::ifstream &	ifs,
		std::string &	termString,
		double *	termValue
	)

Definition at line 160 of file Miscellaneous.C.

References UQ_FAILED_READING_FILE_RC, and UQ_OK_RC.

Referenced by QUESO::AsciiTable< V, M >::readColumnsFromFile().

{
  int iRC = UQ_OK_RC;

  ifs >> termString;
  if ((ifs.rdstate() & std::ifstream::failbit)) {
    iRC = UQ_FAILED_READING_FILE_RC;
  }
  else if (termValue) {
    if (termString == std::string("inf")) {
      *termValue = INFINITY;
    }
    else if (termString == std::string("-inf")) {
      *termValue = -INFINITY;
    }
    else if (termString == std::string("nan")) {
      *termValue = nan("");
    }
    else {
      *termValue = strtod(termString.c_str(),NULL);
    }
  }
  //if (!iRC) std::cout << "Read termString = " << termString << std::endl;

  return iRC;
}

void QUESO::MiscReadWordsFromString	(	const std::string &	inputString,
		std::vector< std::string > &	outputWords
	)

Definition at line 92 of file Miscellaneous.C.

References queso_require_not_equal_to_msg.

{
  //std::cout << "In MiscReadWordsFromString()"
  //          << ": inputString = " << inputString
  //          << std::endl;
  outputWords.clear();
  bool aWordIsBeingRead = false;
  std::string::size_type positionOfFirstChar = 0;
  std::string::size_type numberOfChars = 0;
  for (std::string::size_type i = 0; i < inputString.size(); ++i) {
    queso_require_not_equal_to_msg(inputString[i], '\0', "character '\0' should not be found!");
    if (inputString[i] == ' ') {
      if (aWordIsBeingRead == true) {
        // We just finished reading the current string/word.
        char tmpVar[numberOfChars+1];
        for (std::string::size_type j = 0; j < numberOfChars; ++j) {
          tmpVar[j] = inputString[positionOfFirstChar+j];
        }
        tmpVar[numberOfChars] = '\0';
        outputWords.push_back(tmpVar);

        // Continue loop
        aWordIsBeingRead = false;
        positionOfFirstChar = 0;
        numberOfChars = 0;
      }
    }
    else {
      if (aWordIsBeingRead == false) {
        aWordIsBeingRead = true;
        positionOfFirstChar = i;
      }
      numberOfChars++;
    }
  } // for
  if (aWordIsBeingRead == true) {
    // We just finished reading the current string/word.
    char tmpVar[numberOfChars+1];
    for (std::string::size_type j = 0; j < numberOfChars; ++j) {
      tmpVar[j] = inputString[positionOfFirstChar+j];
    }
    tmpVar[numberOfChars] = '\0';
    outputWords.push_back(tmpVar);
  }
  std::vector<std::string>(outputWords).swap(outputWords);

  return;
}

unsigned int QUESO::MiscUintDebugMessage	(	unsigned int	value,
		const char *	message
	)

Definition at line 314 of file Miscellaneous.C.

{
  if (message) {
    std::cout << "Passing in MiscUintDebugMessage(), value = " << value << ", message = " << message << std::endl;
  }
  return value;
}

int QUESO::MyWorldfullRank

(

)

Returns the rank of the calling process in the communicator.

Definition at line 33 of file Defines.C.

                      {
  int result = 0;
#ifdef QUESO_HAS_MPI
  int iRC;
  iRC = MPI_Comm_rank(MPI_COMM_WORLD,&result);
  if (iRC) {}; // just to remove compiler warning
#endif
  return result;
}

GslVector QUESO::operator*	(	double	a,
		const GslVector &	x
	)

Definition at line 1120 of file GslVector.C.

{
  GslVector answer(x);
  answer *= a;

  return answer;
}

GslVector QUESO::operator*	(	const GslVector &	x,
		const GslVector &	y
	)

Definition at line 1128 of file GslVector.C.

{
  GslVector answer(x);
  answer *= y;

  return answer;
}

GslMatrix QUESO::operator*	(	double	a,
		const GslMatrix &	mat
	)

Definition at line 1982 of file GslMatrix.C.

{
  GslMatrix answer(mat);
  answer *= a;
  return answer;
}

GslVector QUESO::operator*	(	const GslMatrix &	mat,
		const GslVector &	vec
	)

Definition at line 1989 of file GslMatrix.C.

References QUESO::GslMatrix::multiply().

{
  return mat.multiply(vec);
}

GslMatrix QUESO::operator*	(	const GslMatrix &	m1,
		const GslMatrix &	m2
	)

Definition at line 1994 of file GslMatrix.C.

References QUESO::Matrix::env(), k, QUESO::Matrix::map(), QUESO::GslMatrix::numCols(), QUESO::GslMatrix::numRowsLocal(), and queso_require_equal_to_msg.

{
  unsigned int m1Rows = m1.numRowsLocal();
  unsigned int m1Cols = m1.numCols();
  unsigned int m2Rows = m2.numRowsLocal();
  unsigned int m2Cols = m2.numCols();

  queso_require_equal_to_msg(m1Cols, m2Rows, "different sizes m1Cols and m2Rows");

  GslMatrix mat(m1.env(),m1.map(),m2Cols);

  //std::cout << "In GslMatrix(mat * mat): m1Cols = " << m1Cols << std::endl;

  unsigned int commonSize = m1Cols;
  for (unsigned int row1 = 0; row1 < m1Rows; ++row1) {
    for (unsigned int col2 = 0; col2 < m2Cols; ++col2) {
      double result = 0.;
      for (unsigned int k = 0; k < commonSize; ++k) {
        result += m1(row1,k)*m2(k,col2);
      }
      mat(row1,col2) = result;
    }
    //std::cout << "In GslMatrix(mat * mat): ended row " << row1 << std::endl;
  }

  return mat;
}

GslVector QUESO::operator+	(	const GslVector &	x,
		const GslVector &	y
	)

Definition at line 1150 of file GslVector.C.

{
  GslVector answer(x);
  answer += y;

  return answer;
}

GslMatrix QUESO::operator+	(	const GslMatrix &	m1,
		const GslMatrix &	m2
	)

Definition at line 2022 of file GslMatrix.C.

{
  GslMatrix answer(m1);
  answer += m2;
  return answer;
}

GslVector QUESO::operator-	(	const GslVector &	x,
		const GslVector &	y
	)

Definition at line 1158 of file GslVector.C.

{
  GslVector answer(x);
  answer -= y;

  return answer;
}

GslMatrix QUESO::operator-	(	const GslMatrix &	m1,
		const GslMatrix &	m2
	)

Definition at line 2029 of file GslMatrix.C.

{
  GslMatrix answer(m1);
  answer -= m2;
  return answer;
}

GslVector QUESO::operator/	(	double	a,
		const GslVector &	x
	)

Definition at line 1103 of file GslVector.C.

References QUESO::GslVector::cwInvert().

{
  GslVector answer(x);
  answer.cwInvert();
  answer *= a;

  return answer;
}

GslVector QUESO::operator/	(	const GslVector &	x,
		const GslVector &	y
	)

Definition at line 1112 of file GslVector.C.

{
  GslVector answer(x);
  answer /= y;

  return answer;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const InfiniteDimensionalMCMCSamplerOptions &	obj
	)

Definition at line 105 of file InfiniteDimensionalMCMCSamplerOptions.C.

References QUESO::InfiniteDimensionalMCMCSamplerOptions::m_parser, and QUESO::InfiniteDimensionalMCMCSamplerOptions::print().

{
#ifndef DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#endif  // DISABLE_BOOST_PROGRAM_OPTIONS
  obj.print(os);
  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const GslBlockMatrix &	obj
	)

Definition at line 156 of file GslBlockMatrix.C.

References QUESO::GslBlockMatrix::print().

{
  obj.print(os);

  return os;
}

template<class V , class M >

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const ArrayOfOneDTables< V, M > &	obj
	)

Definition at line 112 of file ArrayOfOneDTables.C.

References QUESO::ArrayOfOneDTables< V, M >::print().

{
  obj.print(os);
  return os;
}

template<class V , class M >

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const BaseJointPdf< V, M > &	obj
	)

Definition at line 121 of file JointPdf.h.

{
  obj.print(os);
  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const ExperimentModelOptions &	obj
	)

Definition at line 410 of file ExperimentModelOptions.C.

References QUESO::ExperimentModelOptions::print(), and queso_deprecated.

{
  queso_deprecated();

  obj.print(os);

  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const BoostInputOptionsParser &	parser
	)

Definition at line 154 of file BoostInputOptionsParser.C.

References QUESO::BoostInputOptionsParser::m_optionsDescription, and queso_deprecated.

{
  queso_deprecated();
  os << *(parser.m_optionsDescription);
  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const SimulationModelOptions &	obj
	)

Definition at line 551 of file SimulationModelOptions.C.

References QUESO::SimulationModelOptions::print(), and queso_deprecated.

{
  queso_deprecated();

  obj.print(os);

  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const OptimizerOptions &	obj
	)

Definition at line 166 of file OptimizerOptions.C.

References QUESO::OptimizerOptions::m_fdfstepSize, QUESO::OptimizerOptions::m_finiteDifferenceStepSize, QUESO::OptimizerOptions::m_fstepSize, QUESO::OptimizerOptions::m_lineTolerance, QUESO::OptimizerOptions::m_maxIterations, QUESO::OptimizerOptions::m_option_fdfstepSize, QUESO::OptimizerOptions::m_option_finiteDifferenceStepSize, QUESO::OptimizerOptions::m_option_fstepSize, QUESO::OptimizerOptions::m_option_lineTolerance, QUESO::OptimizerOptions::m_option_maxIterations, QUESO::OptimizerOptions::m_option_solverType, QUESO::OptimizerOptions::m_option_tolerance, QUESO::OptimizerOptions::m_solverType, and QUESO::OptimizerOptions::m_tolerance.

{
  os << "\n" << obj.m_option_maxIterations << " = " << obj.m_maxIterations
     << "\n" << obj.m_option_tolerance << " = " << obj.m_tolerance;
  os << "\n" << obj.m_option_finiteDifferenceStepSize << " = "
             << obj.m_finiteDifferenceStepSize;
  os << "\n" << obj.m_option_solverType << " = " << obj.m_solverType;
  os << "\n" << obj.m_option_fstepSize << " = " << obj.m_fstepSize;
  os << "\n" << obj.m_option_fdfstepSize << " = " << obj.m_fdfstepSize;
  os << "\n" << obj.m_option_lineTolerance << " = " << obj.m_lineTolerance;
  os << std::endl;
  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const GPMSAOptions &	obj
	)

Definition at line 170 of file GPMSAOptions.C.

References QUESO::GPMSAOptions::m_parser, and QUESO::GPMSAOptions::print().

{
#ifndef DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#endif  // DISABLE_BOOST_PROGRAM_OPTIONS
  obj.print(os);
  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const SipOptionsValues &	obj
	)

Definition at line 172 of file StatisticalInverseProblemOptions.C.

References QUESO::SipOptionsValues::m_computeSolution, QUESO::SipOptionsValues::m_dataOutputAllowedSet, QUESO::SipOptionsValues::m_dataOutputFileName, QUESO::SipOptionsValues::m_option_computeSolution, QUESO::SipOptionsValues::m_option_dataOutputAllowedSet, and QUESO::SipOptionsValues::m_option_dataOutputFileName.

{
  os << "\n" << obj.m_option_computeSolution      << " = " << obj.m_computeSolution
     << "\n" << obj.m_option_dataOutputFileName   << " = " << obj.m_dataOutputFileName;
  os << "\n" << obj.m_option_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_dataOutputAllowedSet.begin(); setIt != obj.m_dataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
#ifdef UQ_SIP_READS_SOLVER_OPTION
     << "\n" << obj.m_option_solver << " = " << obj.m_solverString
#endif
  os << std::endl;
  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const MLSamplingOptions &	obj
	)

Definition at line 172 of file MLSamplingOptions.C.

References QUESO::MLSamplingOptions::m_parser, and QUESO::MLSamplingOptions::print().

{
#ifndef DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#endif  // DISABLE_BOOST_PROGRAM_OPTIONS

  obj.print(os);
  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const SfpOptionsValues &	obj
	)

Definition at line 177 of file StatisticalForwardProblemOptions.C.

References QUESO::SfpOptionsValues::m_computeCorrelations, QUESO::SfpOptionsValues::m_computeCovariances, QUESO::SfpOptionsValues::m_computeSolution, QUESO::SfpOptionsValues::m_dataOutputAllowedSet, QUESO::SfpOptionsValues::m_dataOutputFileName, QUESO::SfpOptionsValues::m_option_computeCorrelations, QUESO::SfpOptionsValues::m_option_computeCovariances, QUESO::SfpOptionsValues::m_option_computeSolution, QUESO::SfpOptionsValues::m_option_dataOutputAllowedSet, QUESO::SfpOptionsValues::m_option_dataOutputFileName, and QUESO::SfpOptionsValues::m_parser.

{
#ifndef DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#endif  // DISABLE_BOOST_PROGRAM_OPTIONS

  os <<         obj.m_option_computeSolution      << " = " << obj.m_computeSolution
     << "\n" << obj.m_option_computeCovariances   << " = " << obj.m_computeCovariances
     << "\n" << obj.m_option_computeCorrelations  << " = " << obj.m_computeCorrelations
     << "\n" << obj.m_option_dataOutputFileName   << " = " << obj.m_dataOutputFileName;
  os << "\n" << obj.m_option_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_dataOutputAllowedSet.begin(); setIt != obj.m_dataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
#ifdef UQ_SFP_READS_SOLVER_OPTION
       << "\n" << obj.m_option_solver << " = " << obj.m_solverString
#endif
  os << std::endl;
  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const GpmsaComputerModelOptions &	obj
	)

Definition at line 721 of file GpmsaComputerModelOptions.C.

References QUESO::GpmsaComputerModelOptions::print(), and queso_deprecated.

{
  queso_deprecated();

  obj.print(os);

  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const StatisticalForwardProblemOptions &	obj
	)

Prints the object obj, overloading an operator.

Definition at line 397 of file StatisticalForwardProblemOptions.C.

References QUESO::StatisticalForwardProblemOptions::print(), and queso_deprecated.

{
  queso_deprecated();

  obj.print(os);

  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const StatisticalInverseProblemOptions &	obj
	)

Prints the object obj, overloading an operator.

Definition at line 379 of file StatisticalInverseProblemOptions.C.

References QUESO::StatisticalInverseProblemOptions::print(), and queso_deprecated.

{
  queso_deprecated();
  obj.print(os);

  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const EnvOptionsValues &	obj
	)

Definition at line 236 of file EnvironmentOptions.C.

References QUESO::BaseEnvironment::input(), QUESO::EnvOptionsValues::m_checkingLevel, QUESO::EnvOptionsValues::m_displayVerbosity, QUESO::EnvOptionsValues::m_env, QUESO::EnvOptionsValues::m_identifyingString, QUESO::EnvOptionsValues::m_numSubEnvironments, QUESO::EnvOptionsValues::m_option_checkingLevel, QUESO::EnvOptionsValues::m_option_displayVerbosity, QUESO::EnvOptionsValues::m_option_identifyingString, QUESO::EnvOptionsValues::m_option_numSubEnvironments, QUESO::EnvOptionsValues::m_option_platformName, QUESO::EnvOptionsValues::m_option_rngType, QUESO::EnvOptionsValues::m_option_seed, QUESO::EnvOptionsValues::m_option_subDisplayAllowAll, QUESO::EnvOptionsValues::m_option_subDisplayAllowedSet, QUESO::EnvOptionsValues::m_option_subDisplayFileName, QUESO::EnvOptionsValues::m_option_syncVerbosity, QUESO::EnvOptionsValues::m_parser, QUESO::EnvOptionsValues::m_platformName, QUESO::EnvOptionsValues::m_rngType, QUESO::EnvOptionsValues::m_seed, QUESO::EnvOptionsValues::m_subDisplayAllowAll, QUESO::EnvOptionsValues::m_subDisplayAllowedSet, QUESO::EnvOptionsValues::m_subDisplayFileName, QUESO::EnvOptionsValues::m_syncVerbosity, and GetPot::print().

{
  // Print the parser
#ifndef DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#else
  obj.m_env->input().print(os);
#endif  // DISABLE_BOOST_PROGRAM_OPTIONS

  // Print the option names and current values
  os <<         obj.m_option_numSubEnvironments    << " = " << obj.m_numSubEnvironments
     << "\n" << obj.m_option_subDisplayFileName    << " = " << obj.m_subDisplayFileName
     << "\n" << obj.m_option_subDisplayAllowAll    << " = " << obj.m_subDisplayAllowAll
   //<< "\n" << obj.m_option_subDisplayAllowInter0 << " = " << obj.m_subDisplayAllowInter0
     << "\n" << obj.m_option_subDisplayAllowedSet  << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_subDisplayAllowedSet.begin(); setIt != obj.m_subDisplayAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
  os << "\n" << obj.m_option_displayVerbosity  << " = " << obj.m_displayVerbosity
     << "\n" << obj.m_option_syncVerbosity     << " = " << obj.m_syncVerbosity
     << "\n" << obj.m_option_checkingLevel     << " = " << obj.m_checkingLevel
     << "\n" << obj.m_option_rngType           << " = " << obj.m_rngType
     << "\n" << obj.m_option_seed              << " = " << obj.m_seed
     << "\n" << obj.m_option_platformName      << " = " << obj.m_platformName
     << "\n" << obj.m_option_identifyingString << " = " << obj.m_identifyingString
   //<< "\n" << obj.m_option_numDebugParams    << " = " << obj.m_numDebugParams
     << std::endl;
  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const GslVector &	obj
	)

Definition at line 1096 of file GslVector.C.

References QUESO::GslVector::print().

{
  obj.print(os);

  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const MonteCarloSGOptions &	obj
	)

Prints the object obj, overloading an operator.

Definition at line 706 of file MonteCarloSGOptions.C.

References QUESO::MonteCarloSGOptions::print(), and queso_deprecated.

{
  queso_deprecated();

  obj.print(os);

  return os;
}

template<class V , class M >

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const AsciiTable< V, M > &	obj
	)

Definition at line 301 of file AsciiTable.C.

{
  obj.print(os);

  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const McOptionsValues &	obj
	)

Definition at line 326 of file MonteCarloSGOptions.C.

References QUESO::McOptionsValues::m_dataOutputAllowedSet, QUESO::McOptionsValues::m_dataOutputFileName, QUESO::McOptionsValues::m_option_dataOutputAllowedSet, QUESO::McOptionsValues::m_option_dataOutputFileName, QUESO::McOptionsValues::m_option_pseq_dataOutputAllowedSet, QUESO::McOptionsValues::m_option_pseq_dataOutputFileName, QUESO::McOptionsValues::m_option_pseq_dataOutputFileType, QUESO::McOptionsValues::m_option_pseq_dataOutputPeriod, QUESO::McOptionsValues::m_option_qseq_dataInputFileName, QUESO::McOptionsValues::m_option_qseq_dataInputFileType, QUESO::McOptionsValues::m_option_qseq_dataOutputAllowedSet, QUESO::McOptionsValues::m_option_qseq_dataOutputFileName, QUESO::McOptionsValues::m_option_qseq_dataOutputFileType, QUESO::McOptionsValues::m_option_qseq_dataOutputPeriod, QUESO::McOptionsValues::m_option_qseq_displayPeriod, QUESO::McOptionsValues::m_option_qseq_measureRunTimes, QUESO::McOptionsValues::m_option_qseq_size, QUESO::McOptionsValues::m_parser, QUESO::McOptionsValues::m_pseqDataOutputAllowedSet, QUESO::McOptionsValues::m_pseqDataOutputFileName, QUESO::McOptionsValues::m_pseqDataOutputFileType, QUESO::McOptionsValues::m_pseqDataOutputPeriod, QUESO::McOptionsValues::m_qseqDataInputFileName, QUESO::McOptionsValues::m_qseqDataInputFileType, QUESO::McOptionsValues::m_qseqDataOutputAllowedSet, QUESO::McOptionsValues::m_qseqDataOutputFileName, QUESO::McOptionsValues::m_qseqDataOutputFileType, QUESO::McOptionsValues::m_qseqDataOutputPeriod, QUESO::McOptionsValues::m_qseqDisplayPeriod, QUESO::McOptionsValues::m_qseqMeasureRunTimes, and QUESO::McOptionsValues::m_qseqSize.

{
#ifndef DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#endif  // DISABLE_BOOST_PROGRAM_OPTIONS

  os <<         obj.m_option_dataOutputFileName   << " = " << obj.m_dataOutputFileName
     << "\n" << obj.m_option_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_dataOutputAllowedSet.begin(); setIt != obj.m_dataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
  os << "\n" << obj.m_option_pseq_dataOutputPeriod     << " = " << obj.m_pseqDataOutputPeriod
     << "\n" << obj.m_option_pseq_dataOutputFileName   << " = " << obj.m_pseqDataOutputFileName
     << "\n" << obj.m_option_pseq_dataOutputFileType   << " = " << obj.m_pseqDataOutputFileType
     << "\n" << obj.m_option_pseq_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_pseqDataOutputAllowedSet.begin(); setIt != obj.m_pseqDataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
  os
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
     << "\n" << obj.m_option_pseq_computeStats         << " = " << obj.m_pseqComputeStats
#endif
     << "\n" << obj.m_option_qseq_dataInputFileName    << " = " << obj.m_qseqDataInputFileName
     << "\n" << obj.m_option_qseq_dataInputFileType    << " = " << obj.m_qseqDataInputFileType
     << "\n" << obj.m_option_qseq_size                 << " = " << obj.m_qseqSize
     << "\n" << obj.m_option_qseq_displayPeriod        << " = " << obj.m_qseqDisplayPeriod
     << "\n" << obj.m_option_qseq_measureRunTimes      << " = " << obj.m_qseqMeasureRunTimes
     << "\n" << obj.m_option_qseq_dataOutputPeriod     << " = " << obj.m_qseqDataOutputPeriod
     << "\n" << obj.m_option_qseq_dataOutputFileName   << " = " << obj.m_qseqDataOutputFileName
     << "\n" << obj.m_option_qseq_dataOutputFileType   << " = " << obj.m_qseqDataOutputFileType
     << "\n" << obj.m_option_qseq_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_qseqDataOutputAllowedSet.begin(); setIt != obj.m_qseqDataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
  os << "\n" << obj.m_option_qseq_computeStats << " = " << obj.m_qseqComputeStats;
#endif

  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const EnvironmentOptions &	obj
	)

Print values of the options chosen.

Definition at line 538 of file EnvironmentOptions.C.

References QUESO::EnvironmentOptions::print(), and queso_deprecated.

{
  queso_deprecated();

  obj.print(os);

  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const GslMatrix &	obj
	)

Definition at line 1975 of file GslMatrix.C.

References QUESO::GslMatrix::print().

{
  obj.print(os);

  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const BaseEnvironment &	obj
	)

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const MhOptionsValues &	obj
	)

Definition at line 732 of file MetropolisHastingsSGOptions.C.

References QUESO::MhOptionsValues::m_algorithm, QUESO::MhOptionsValues::m_amAdaptedMatricesDataOutputAllowAll, QUESO::MhOptionsValues::m_amAdaptedMatricesDataOutputAllowedSet, QUESO::MhOptionsValues::m_amAdaptedMatricesDataOutputFileName, QUESO::MhOptionsValues::m_amAdaptedMatricesDataOutputFileType, QUESO::MhOptionsValues::m_amAdaptedMatricesDataOutputPeriod, QUESO::MhOptionsValues::m_amAdaptInterval, QUESO::MhOptionsValues::m_amEpsilon, QUESO::MhOptionsValues::m_amEta, QUESO::MhOptionsValues::m_amInitialNonAdaptInterval, QUESO::MhOptionsValues::m_amKeepInitialMatrix, QUESO::MhOptionsValues::m_BrooksGelmanLag, QUESO::MhOptionsValues::m_dataOutputAllowAll, QUESO::MhOptionsValues::m_dataOutputAllowedSet, QUESO::MhOptionsValues::m_dataOutputFileName, QUESO::MhOptionsValues::m_displayCandidates, QUESO::MhOptionsValues::m_doLogitTransform, QUESO::MhOptionsValues::m_drDuringAmNonAdaptiveInt, QUESO::MhOptionsValues::m_drMaxNumExtraStages, QUESO::MhOptionsValues::m_drScalesForExtraStages, QUESO::MhOptionsValues::m_enableBrooksGelmanConvMonitor, QUESO::MhOptionsValues::m_filteredChainDataOutputAllowAll, QUESO::MhOptionsValues::m_filteredChainDataOutputAllowedSet, QUESO::MhOptionsValues::m_filteredChainDataOutputFileName, QUESO::MhOptionsValues::m_filteredChainDataOutputFileType, QUESO::MhOptionsValues::m_filteredChainDiscardedPortion, QUESO::MhOptionsValues::m_filteredChainGenerate, QUESO::MhOptionsValues::m_filteredChainLag, QUESO::MhOptionsValues::m_initialPositionDataInputFileName, QUESO::MhOptionsValues::m_initialPositionDataInputFileType, QUESO::MhOptionsValues::m_initialProposalCovMatrixDataInputFileName, QUESO::MhOptionsValues::m_initialProposalCovMatrixDataInputFileType, QUESO::MhOptionsValues::m_option_algorithm, QUESO::MhOptionsValues::m_option_am_adaptedMatrices_dataOutputAllowAll, QUESO::MhOptionsValues::m_option_am_adaptedMatrices_dataOutputAllowedSet, QUESO::MhOptionsValues::m_option_am_adaptedMatrices_dataOutputFileName, QUESO::MhOptionsValues::m_option_am_adaptedMatrices_dataOutputFileType, QUESO::MhOptionsValues::m_option_am_adaptedMatrices_dataOutputPeriod, QUESO::MhOptionsValues::m_option_am_adaptInterval, QUESO::MhOptionsValues::m_option_am_epsilon, QUESO::MhOptionsValues::m_option_am_eta, QUESO::MhOptionsValues::m_option_am_initialNonAdaptInterval, QUESO::MhOptionsValues::m_option_am_keepInitialMatrix, QUESO::MhOptionsValues::m_option_BrooksGelmanLag, QUESO::MhOptionsValues::m_option_dataOutputAllowAll, QUESO::MhOptionsValues::m_option_dataOutputAllowedSet, QUESO::MhOptionsValues::m_option_dataOutputFileName, QUESO::MhOptionsValues::m_option_displayCandidates, QUESO::MhOptionsValues::m_option_doLogitTransform, QUESO::MhOptionsValues::m_option_dr_duringAmNonAdaptiveInt, QUESO::MhOptionsValues::m_option_dr_listOfScalesForExtraStages, QUESO::MhOptionsValues::m_option_dr_maxNumExtraStages, QUESO::MhOptionsValues::m_option_enableBrooksGelmanConvMonitor, QUESO::MhOptionsValues::m_option_filteredChain_dataOutputAllowAll, QUESO::MhOptionsValues::m_option_filteredChain_dataOutputAllowedSet, QUESO::MhOptionsValues::m_option_filteredChain_dataOutputFileName, QUESO::MhOptionsValues::m_option_filteredChain_dataOutputFileType, QUESO::MhOptionsValues::m_option_filteredChain_discardedPortion, QUESO::MhOptionsValues::m_option_filteredChain_generate, QUESO::MhOptionsValues::m_option_filteredChain_lag, QUESO::MhOptionsValues::m_option_initialPosition_dataInputFileName, QUESO::MhOptionsValues::m_option_initialPosition_dataInputFileType, QUESO::MhOptionsValues::m_option_initialProposalCovMatrix_dataInputFileName, QUESO::MhOptionsValues::m_option_initialProposalCovMatrix_dataInputFileType, QUESO::MhOptionsValues::m_option_listOfDisabledParameters, QUESO::MhOptionsValues::m_option_outputLogLikelihood, QUESO::MhOptionsValues::m_option_outputLogTarget, QUESO::MhOptionsValues::m_option_putOutOfBoundsInChain, QUESO::MhOptionsValues::m_option_rawChain_dataInputFileName, QUESO::MhOptionsValues::m_option_rawChain_dataInputFileType, QUESO::MhOptionsValues::m_option_rawChain_dataOutputAllowAll, QUESO::MhOptionsValues::m_option_rawChain_dataOutputAllowedSet, QUESO::MhOptionsValues::m_option_rawChain_dataOutputFileName, QUESO::MhOptionsValues::m_option_rawChain_dataOutputFileType, QUESO::MhOptionsValues::m_option_rawChain_dataOutputPeriod, QUESO::MhOptionsValues::m_option_rawChain_displayPeriod, QUESO::MhOptionsValues::m_option_rawChain_generateExtra, QUESO::MhOptionsValues::m_option_rawChain_measureRunTimes, QUESO::MhOptionsValues::m_option_rawChain_size, QUESO::MhOptionsValues::m_option_tk, QUESO::MhOptionsValues::m_option_tk_useLocalHessian, QUESO::MhOptionsValues::m_option_tk_useNewtonComponent, QUESO::MhOptionsValues::m_option_totallyMute, QUESO::MhOptionsValues::m_outputLogLikelihood, QUESO::MhOptionsValues::m_outputLogTarget, QUESO::MhOptionsValues::m_parameterDisabledSet, QUESO::MhOptionsValues::m_parser, QUESO::MhOptionsValues::m_putOutOfBoundsInChain, QUESO::MhOptionsValues::m_rawChainDataInputFileName, QUESO::MhOptionsValues::m_rawChainDataInputFileType, QUESO::MhOptionsValues::m_rawChainDataOutputAllowAll, QUESO::MhOptionsValues::m_rawChainDataOutputAllowedSet, QUESO::MhOptionsValues::m_rawChainDataOutputFileName, QUESO::MhOptionsValues::m_rawChainDataOutputFileType, QUESO::MhOptionsValues::m_rawChainDataOutputPeriod, QUESO::MhOptionsValues::m_rawChainDisplayPeriod, QUESO::MhOptionsValues::m_rawChainGenerateExtra, QUESO::MhOptionsValues::m_rawChainMeasureRunTimes, QUESO::MhOptionsValues::m_rawChainSize, QUESO::MhOptionsValues::m_tk, QUESO::MhOptionsValues::m_tkUseLocalHessian, QUESO::MhOptionsValues::m_tkUseNewtonComponent, and QUESO::MhOptionsValues::m_totallyMute.

{
#ifndef DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#endif  // DISABLE_BOOST_PROGRAM_OPTIONS

  os <<         obj.m_option_dataOutputFileName                         << " = " << obj.m_dataOutputFileName
     << "\n" << obj.m_option_dataOutputAllowAll                         << " = " << obj.m_dataOutputAllowAll
     << "\n" << obj.m_option_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_dataOutputAllowedSet.begin(); setIt != obj.m_dataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
  os << "\n" << obj.m_option_totallyMute                                << " = " << obj.m_totallyMute
     << "\n" << obj.m_option_initialPosition_dataInputFileName          << " = " << obj.m_initialPositionDataInputFileName
     << "\n" << obj.m_option_initialPosition_dataInputFileType          << " = " << obj.m_initialPositionDataInputFileType
     << "\n" << obj.m_option_initialProposalCovMatrix_dataInputFileName << " = " << obj.m_initialProposalCovMatrixDataInputFileName
     << "\n" << obj.m_option_initialProposalCovMatrix_dataInputFileType << " = " << obj.m_initialProposalCovMatrixDataInputFileType
     << "\n" << obj.m_option_listOfDisabledParameters                   << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_parameterDisabledSet.begin(); setIt != obj.m_parameterDisabledSet.end(); ++setIt) {
    os << *setIt << " ";
  }
  os << "\n" << obj.m_option_rawChain_dataInputFileName                 << " = " << obj.m_rawChainDataInputFileName
     << "\n" << obj.m_option_rawChain_dataInputFileType                 << " = " << obj.m_rawChainDataInputFileType
     << "\n" << obj.m_option_rawChain_size                              << " = " << obj.m_rawChainSize
     << "\n" << obj.m_option_rawChain_generateExtra                     << " = " << obj.m_rawChainGenerateExtra
     << "\n" << obj.m_option_rawChain_displayPeriod                     << " = " << obj.m_rawChainDisplayPeriod
     << "\n" << obj.m_option_rawChain_measureRunTimes                   << " = " << obj.m_rawChainMeasureRunTimes
     << "\n" << obj.m_option_rawChain_dataOutputPeriod                  << " = " << obj.m_rawChainDataOutputPeriod
     << "\n" << obj.m_option_rawChain_dataOutputFileName                << " = " << obj.m_rawChainDataOutputFileName
     << "\n" << obj.m_option_rawChain_dataOutputFileType                << " = " << obj.m_rawChainDataOutputFileType
     << "\n" << obj.m_option_rawChain_dataOutputAllowAll                << " = " << obj.m_rawChainDataOutputAllowAll
     << "\n" << obj.m_option_rawChain_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_rawChainDataOutputAllowedSet.begin(); setIt != obj.m_rawChainDataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
  os
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
     << "\n" << obj.m_option_rawChain_computeStats                      << " = " << obj.m_rawChainComputeStats
#endif
     << "\n" << obj.m_option_filteredChain_generate                     << " = " << obj.m_filteredChainGenerate
     << "\n" << obj.m_option_filteredChain_discardedPortion             << " = " << obj.m_filteredChainDiscardedPortion
     << "\n" << obj.m_option_filteredChain_lag                          << " = " << obj.m_filteredChainLag
     << "\n" << obj.m_option_filteredChain_dataOutputFileName           << " = " << obj.m_filteredChainDataOutputFileName
     << "\n" << obj.m_option_filteredChain_dataOutputFileType           << " = " << obj.m_filteredChainDataOutputFileType
     << "\n" << obj.m_option_filteredChain_dataOutputAllowAll           << " = " << obj.m_filteredChainDataOutputAllowAll
     << "\n" << obj.m_option_filteredChain_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_filteredChainDataOutputAllowedSet.begin(); setIt != obj.m_filteredChainDataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
  os
#ifdef QUESO_USES_SEQUENCE_STATISTICAL_OPTIONS
     << "\n" << obj.m_option_filteredChain_computeStats                 << " = " << obj.m_filteredChainComputeStats
#endif
     << "\n" << obj.m_option_displayCandidates                          << " = " << obj.m_displayCandidates
     << "\n" << obj.m_option_putOutOfBoundsInChain                      << " = " << obj.m_putOutOfBoundsInChain
     << "\n" << obj.m_option_tk_useLocalHessian                         << " = " << obj.m_tkUseLocalHessian
     << "\n" << obj.m_option_tk_useNewtonComponent                      << " = " << obj.m_tkUseNewtonComponent
     << "\n" << obj.m_option_dr_maxNumExtraStages                       << " = " << obj.m_drMaxNumExtraStages
     << "\n" << obj.m_option_dr_listOfScalesForExtraStages << " = ";
  for (unsigned int i = 0; i < obj.m_drScalesForExtraStages.size(); ++i) {
    os << obj.m_drScalesForExtraStages[i] << " ";
  }
  os << "\n" << obj.m_option_dr_duringAmNonAdaptiveInt                  << " = " << obj.m_drDuringAmNonAdaptiveInt
     << "\n" << obj.m_option_am_keepInitialMatrix                       << " = " << obj.m_amKeepInitialMatrix
     << "\n" << obj.m_option_am_initialNonAdaptInterval                 << " = " << obj.m_amInitialNonAdaptInterval
     << "\n" << obj.m_option_am_adaptInterval                           << " = " << obj.m_amAdaptInterval
     << "\n" << obj.m_option_am_adaptedMatrices_dataOutputPeriod        << " = " << obj.m_amAdaptedMatricesDataOutputPeriod
     << "\n" << obj.m_option_am_adaptedMatrices_dataOutputFileName      << " = " << obj.m_amAdaptedMatricesDataOutputFileName
     << "\n" << obj.m_option_am_adaptedMatrices_dataOutputFileType      << " = " << obj.m_amAdaptedMatricesDataOutputFileType
     << "\n" << obj.m_option_am_adaptedMatrices_dataOutputAllowAll      << " = " << obj.m_amAdaptedMatricesDataOutputAllowAll
     << "\n" << obj.m_option_am_adaptedMatrices_dataOutputAllowedSet << " = ";
  for (std::set<unsigned int>::iterator setIt = obj.m_amAdaptedMatricesDataOutputAllowedSet.begin(); setIt != obj.m_amAdaptedMatricesDataOutputAllowedSet.end(); ++setIt) {
    os << *setIt << " ";
  }
  os << "\n" << obj.m_option_am_eta                                     << " = " << obj.m_amEta
     << "\n" << obj.m_option_am_epsilon                                 << " = " << obj.m_amEpsilon
     << "\n" << obj.m_option_enableBrooksGelmanConvMonitor              << " = " << obj.m_enableBrooksGelmanConvMonitor
     << "\n" << obj.m_option_BrooksGelmanLag                            << " = " << obj.m_BrooksGelmanLag
     << "\n" << obj.m_option_outputLogLikelihood                        << " = " << obj.m_outputLogLikelihood
     << "\n" << obj.m_option_outputLogTarget                            << " = " << obj.m_outputLogTarget
     << "\n" << obj.m_option_doLogitTransform                           << " = " << obj.m_doLogitTransform
     << "\n" << obj.m_option_algorithm                                  << " = " << obj.m_algorithm
     << "\n" << obj.m_option_tk                                         << " = " << obj.m_tk
     << std::endl;

  return os;
}

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const MLSamplingLevelOptions &	obj
	)

Definition at line 835 of file MLSamplingLevelOptions.C.

References QUESO::MLSamplingLevelOptions::m_parser, and QUESO::MLSamplingLevelOptions::print().

{
#ifndef DISABLE_BOOST_PROGRAM_OPTIONS
  os << (*(obj.m_parser)) << std::endl;
#endif  // DISABLE_BOOST_PROGRAM_OPTIONS
  obj.print(os);
  return os;
}

std::ostream & QUESO::operator<<	(	std::ostream &	os,
		const MetropolisHastingsSGOptions &	obj
	)

Definition at line 1701 of file MetropolisHastingsSGOptions.C.

References QUESO::MetropolisHastingsSGOptions::print(), and queso_deprecated.

{
  queso_deprecated();

  obj.print(os);

  return os;
}

template<class P_V , class P_M >

std::ostream& QUESO::operator<<	(	std::ostream &	os,
		const MLSampling< P_V, P_M > &	obj
	)

Definition at line 4822 of file MLSampling.C.

{
  obj.print(os);

  return os;
}

bool QUESO::operator==	(	const GslVector &	lhs,
		const GslVector &	rhs
	)

Definition at line 1167 of file GslVector.C.

References queso_require_equal_to_msg, and QUESO::GslVector::sizeLocal().

{
  bool answer = true;

  unsigned int size1 = lhs.sizeLocal();
  unsigned int size2 = rhs.sizeLocal();
  queso_require_equal_to_msg(size1, size2, "different sizes of lhs and rhs");

  for (unsigned int i = 0; i < size1; ++i) {
    if (lhs[i] != rhs[i]) {
      answer = false;
      break;
    }
  }

  return answer;
}

int QUESO::QUESO_get_numeric_version

(

)

Definition at line 84 of file Environment.C.

Referenced by QUESO_version_print().

  {
    // Note: return format follows the versioning convention xx.yy.z where
    //
    // xx = major version number
    // yy = minor version number
    // zz = micro version number
    //
    // For example:
    // v.    0.23  -> 002300 = 2300
    // v.   0.23.1 -> 002301 = 2301
    // v.  10.23.2 -> 102302

    int major_version = 0;
    int minor_version = 0;
    int micro_version = 0;

#ifdef QUESO_MAJOR_VERSION
    major_version = QUESO_MAJOR_VERSION;
#endif

#ifdef QUESO_MINOR_VERSION
    minor_version = QUESO_MINOR_VERSION;
#endif

#ifdef QUESO_MICRO_VERSION
    micro_version = QUESO_MICRO_VERSION;
#endif

    return(major_version*10000 + minor_version*100 + micro_version);
  }

template<typename T >

bool QUESO::queso_isfinite

(

T

arg

)

Definition at line 51 of file math_macros.h.

Referenced by QUESO::InvLogitGaussianJointPdf< V, M >::lnValue(), QUESO::UniformVectorRealizer< V, M >::realization(), QUESO::InvLogitGaussianVectorRealizer< V, M >::realization(), QUESO::MetropolisHastingsSG< P_V, P_M >::transformInitialCovMatrixToGaussianSpace(), and QUESO::TransformedScaledCovMatrixTKGroup< V, M >::transformToGaussianSpace().

  {
#ifdef QUESO_HAVE_CXX11_ISFINITE
    return std::isfinite(arg);
#elif QUESO_HAVE_BOOST_MATH_SPECIAL_FUNCTIONS_HPP
    return (boost::math::isfinite)(arg);
#else
#     error "No valid definition for isfinite found!"
#endif
  }

template<typename T >

bool QUESO::queso_isnan

(

T

arg

)

Definition at line 39 of file math_macros.h.

Referenced by QUESO::Algorithm< V, M >::acceptance_ratio(), QUESO::UniformJointPdf< V, M >::actualValue(), QUESO::MetropolisHastingsSG< P_V, P_M >::alpha(), QUESO::BaseJointPdf< V, M >::commonComputeLogOfNormalizationFactor(), QUESO::PoweredJointPdf< V, M >::computeLogOfNormalizationFactor(), QUESO::BayesianJointPdf< V, M >::computeLogOfNormalizationFactor(), QUESO::ConcatenatedJointPdf< V, M >::computeLogOfNormalizationFactor(), QUESO::UniformJointPdf< V, M >::lnValue(), and QUESO::GPMSAEmulator< V, M >::lnValue().

  {
#ifdef QUESO_HAVE_CXX11_ISNAN
    return std::isnan(arg);
#elif QUESO_HAVE_BOOST_MATH_SPECIAL_FUNCTIONS_HPP
    return (boost::math::isnan)(arg);
#else
#     error "No valid definition for is_nan found!"
#endif
  }

QUESO::QUESO_STANDARD_TYPE	(	char	,
		MPI_CHAR
	)

QUESO::QUESO_STANDARD_TYPE	(	int	,
		MPI_INT
	)

QUESO::QUESO_STANDARD_TYPE	(	unsigned	int,
		MPI_UNSIGNED
	)

QUESO::QUESO_STANDARD_TYPE	(	double	,
		MPI_DOUBLE
	)

void QUESO::queso_terminate_handler

(

)

Function for unhandled exceptions in Queso.

queso_terminate_handler This function deals with unhandled exceptions encountered in Queso. It provides a call to MPI_abort using the global communicator.

Definition at line 1722 of file Environment.C.

References old_terminate_handler.

Referenced by QUESO::FullEnvironment::construct().

{
#ifdef QUESO_HAS_MPI
  int mpi_initialized;
  MPI_Initialized (&mpi_initialized);

  if (mpi_initialized)
    {
      //MPI_Abort(m_fullComm->Comm(), 1);
      MPI_Abort(MPI_COMM_WORLD, 1);
    }
  else
    {
      // The system terminate_handler may do useful things like printing
      // uncaught exception information, or the user may have created
      // their own terminate handler that we want to call.
      old_terminate_handler();
    }
#else
  old_terminate_handler();
#endif
  exit(1);
}

void QUESO::QUESO_version_print

(

std::ostream &

os

)

Definition at line 54 of file Environment.C.

References QUESO_get_numeric_version().

Referenced by QUESO::FullEnvironment::construct(), and main().

  {
    {
      os << "------------------------------------------------------------------------------------------" ;
      os << "--------------------" << std::endl;
      os << "QUESO Library: Version = " << QUESO_LIB_VERSION;
      os << " (" << QUESO_get_numeric_version() << ")" << std::endl << std::endl;

      os << QUESO_LIB_RELEASE << std::endl << std::endl;

      os << "Build Date   = " << QUESO_BUILD_DATE     << std::endl;
      os << "Build Host   = " << QUESO_BUILD_HOST     << std::endl;
      os << "Build User   = " << QUESO_BUILD_USER     << std::endl;
      os << "Build Arch   = " << QUESO_BUILD_ARCH     << std::endl;
      os << "Build Rev    = " << QUESO_BUILD_VERSION  << std::endl     << std::endl;

      os << "C++ Config   = " << QUESO_CXX << " " << QUESO_CXXFLAGS    << std::endl;
      os << std::endl;
      os << "Trilinos DIR = " << QUESO_TRILINOS_DIR << std::endl;
      os << "GSL Libs     = " << QUESO_GSL_DIR  << std::endl;
      os << "GRVY DIR     = " << QUESO_GRVY_DIR << std::endl;
      os << "GLPK DIR     = " << QUESO_GLPK_DIR << std::endl;
      os << "HDF5 DIR     = " << QUESO_HDF5_DIR << std::endl;
      os << "------------------------------------------------------------------------------------------" ;
      os << "--------------------" << std::endl;
    }

    return;
  }

GslMatrix QUESO::rightDiagScaling	(	const GslMatrix &	mat,
		const GslVector &	vec
	)

Definition at line 2073 of file GslMatrix.C.

References QUESO::GslMatrix::numCols(), QUESO::GslMatrix::numRowsLocal(), queso_require_equal_to_msg, and QUESO::GslVector::sizeLocal().

{
  unsigned int vSize = vec.sizeLocal();
  unsigned int mRows = mat.numRowsLocal();
  unsigned int mCols = mat.numCols();

  queso_require_equal_to_msg(vSize, mCols, "size of vector is different from the number of cols in matrix");

  queso_require_equal_to_msg(mCols, mRows, "routine currently works for square matrices only");

  GslMatrix answer(mat);
  for (unsigned int j = 0; j < mCols; ++j) {
    double vecValue = vec[j];
    for (unsigned int i = 0; i < mRows; ++i) {
      answer(i,j) *= vecValue;
    }
  }

  return answer;
}

double QUESO::scalarProduct	(	const GslVector &	x,
		const GslVector &	y
	)

Definition at line 1136 of file GslVector.C.

References queso_require_equal_to_msg, and QUESO::GslVector::sizeLocal().

Referenced by QUESO::GcmJointInfo< S_V, S_M, D_V, D_M, P_V, P_M, Q_V, Q_M >::GcmJointInfo(), QUESO::GcmJointTildeInfo< S_V, S_M, D_V, D_M, P_V, P_M, Q_V, Q_M >::GcmJointTildeInfo(), QUESO::GcmSimulationInfo< S_V, S_M, P_V, P_M, Q_V, Q_M >::GcmSimulationInfo(), QUESO::GcmSimulationTildeInfo< S_V, S_M, P_V, P_M, Q_V, Q_M >::GcmSimulationTildeInfo(), QUESO::GcmZTildeInfo< S_V, S_M, D_V, D_M, P_V, P_M, Q_V, Q_M >::GcmZTildeInfo(), QUESO::GpmsaComputerModel< S_V, S_M, D_V, D_M, P_V, P_M, Q_V, Q_M >::likelihoodRoutine(), QUESO::GslVector::norm2Sq(), and QUESO::GPMSAFactory< V, M >::setUpHyperpriors().

{
  unsigned int size1 = x.sizeLocal();
  unsigned int size2 = y.sizeLocal();
  queso_require_equal_to_msg(size1, size2, "different sizes of x and y");

  double result = 0.;
  for (unsigned int i = 0; i < size1; ++i) {
    result += x[i]*y[i];
  }

  return result;
}

template<class T >

double QUESO::SubF1F2Gaussian2dKdeIntegral	(	const ScalarSequence< T > &	scalarSeq1,
		const ScalarSequence< T > &	scalarSeq2,
		unsigned int	initialPos,
		double	scaleValue1,
		double	scaleValue2,
		const Base1D1DFunction &	func1,
		const Base1D1DFunction &	func2,
		unsigned int	quadratureOrder
	)

Calculates the integral of a 2D Gaussian KDE.

This function performs numerical integration (via Hermite-Gauss quadrature, see GaussianHermite1DQuadrature), of a bi-variate Gaussian KDE (refer to ScalarSequence::subGaussian1dKde(), ArrayOfSequences::gaussianKDE(), or SequenceOfVectors::subGaussian1dKde().

Definition at line 875 of file 1D1DFunction.C.

References k, queso_require_equal_to_msg, QUESO::ScalarSequence< T >::subSequenceSize(), and QUESO::Base1D1DFunction::value().

{
  double resultValue = 0.;

  queso_require_equal_to_msg(initialPos, 0, "not implemented yet for initialPos != 0");
  queso_require_equal_to_msg(scalarSeq1.subSequenceSize(), scalarSeq2.subSequenceSize(), "different sizes");

  GaussianHermite1DQuadrature quadObj(0.,1.,quadratureOrder);
  const std::vector<double>& quadPositions = quadObj.positions();
  const std::vector<double>& quadWeights   = quadObj.weights  ();
  queso_require_equal_to_msg(quadPositions.size(), quadWeights.size(), "quadObj has invalid state");

  unsigned int numQuadraturePositions = quadPositions.size();
  unsigned int dataSize = scalarSeq1.subSequenceSize();
  for (unsigned int k = 0; k < dataSize; ++k) {
    double value1 = 0.;
    double value2 = 0.;
    double x1k = scalarSeq1[k];
    double x2k = scalarSeq2[k];
    for (unsigned int j = 0; j < numQuadraturePositions; ++j) {
      value1 += func1.value(scaleValue1*quadPositions[j]+x1k)*quadWeights[j];
      value2 += func2.value(scaleValue2*quadPositions[j]+x2k)*quadWeights[j];
    }
    resultValue += value1*value2;
  }
  resultValue *= 1./(2.*M_PI)/((double) dataSize);

  return resultValue;
}

Variable Documentation

AlgorithmFactoryImp<Algorithm<GslVector, GslMatrix> > QUESO::logit_random_walk_alg("logit_random_walk")

std::terminate_handler QUESO::old_terminate_handler

Definition at line 135 of file Environment.C.

Referenced by QUESO::FullEnvironment::construct(), and queso_terminate_handler().

AlgorithmFactoryImp<Algorithm<GslVector, GslMatrix> > QUESO::random_walk_alg("random_walk")

TKFactoryLogitRandomWalk<TransformedScaledCovMatrixTKGroup<GslVector, GslMatrix> > QUESO::tk_factory_logit_random_walk("logit_random_walk")

TKFactoryMALA<MetropolisAdjustedLangevinTK<GslVector, GslMatrix> > QUESO::tk_factory_mala("mala")

TKFactoryRandomWalk<ScaledCovMatrixTKGroup<GslVector, GslMatrix> > QUESO::tk_factory_random_walk("random_walk")

TKFactoryStochasticNewton<HessianCovMatricesTKGroup<GslVector, GslMatrix> > QUESO::tk_factory_stochastic_newton("stochastic_newton")

const int QUESO::UQ_FAILED_READING_FILE_RC = -9

Definition at line 98 of file Defines.h.

Referenced by MiscReadCharsAndDoubleFromFile(), and MiscReadStringAndDoubleFromFile().

const int QUESO::UQ_FAILED_TO_OPEN_FILE_RC = -7

Definition at line 96 of file Defines.h.

const int QUESO::UQ_INCOMPLETE_IMPLEMENTATION_RC = -1

Definition at line 90 of file Defines.h.

Referenced by QUESO::MetropolisHastingsSG< P_V, P_M >::adapt().

const int QUESO::UQ_INVALID_INTERNAL_RESULT_RC = -5

Definition at line 94 of file Defines.h.

const int QUESO::UQ_INVALID_INTERNAL_STATE_RC = -6

Definition at line 95 of file Defines.h.

const int QUESO::UQ_INVALID_OBSERVABLE_SPEC_RC = -3

Definition at line 92 of file Defines.h.

const int QUESO::UQ_INVALID_PARAMETER_SPEC_RC = -2

Definition at line 91 of file Defines.h.

const int QUESO::UQ_INVALID_QOI_SPEC_RC = -4

Definition at line 93 of file Defines.h.

const int QUESO::UQ_INVALID_SPACE_COMPONENT_ID_RC = -10

Definition at line 99 of file Defines.h.

const int QUESO::UQ_MATRIX_IS_NOT_POS_DEFINITE_RC = -8

Definition at line 97 of file Defines.h.

Referenced by QUESO::MetropolisHastingsSG< P_V, P_M >::adapt(), and QUESO::GslMatrix::chol().

const int QUESO::UQ_MATRIX_SVD_FAILED_RC = -11

Definition at line 100 of file Defines.h.

Referenced by QUESO::GslMatrix::internalSvd().

const int QUESO::UQ_OK_RC = 0

Definition at line 89 of file Defines.h.

Referenced by QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::actualGenerateSequence(), QUESO::MetropolisHastingsSG< P_V, P_M >::adapt(), QUESO::MetropolisHastingsSG< P_V, P_M >::delayedRejection(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateFullChain(), QUESO::MLSampling< P_V, P_M >::generateSequence(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateSequence(), QUESO::MLSampling< P_V, P_M >::generateSequence_Level0_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step01_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step02_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step03_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step04_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step05_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step06_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step07_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step08_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step09_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step10_all(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step11_inter0(), QUESO::MLSampling< P_V, P_M >::justBalance_proc0(), MiscReadCharsAndDoubleFromFile(), MiscReadStringAndDoubleFromFile(), QUESO::SequenceOfVectors< V, M >::unifiedReadContents(), QUESO::ScalarSequence< T >::unifiedReadContents(), QUESO::SequenceOfVectors< V, M >::unifiedWriteContents(), QUESO::ScalarSequence< T >::unifiedWriteContents(), and QUESO::MetropolisHastingsSG< P_V, P_M >::writeInfo().

const int QUESO::UQ_UNAVAILABLE_RANK = -1

Definition at line 87 of file Defines.h.