QUESO::BaseVectorSequence< V, M > Class Template Reference

Base class for handling vector and array samples (sequence of vectors or arrays). More...

#include <VectorSequence.h>

Inheritance diagram for QUESO::BaseVectorSequence< V, M >:

Collaboration diagram for QUESO::BaseVectorSequence< V, M >:

Public Member Functions
Constructor/Destructor methods
	BaseVectorSequence (const VectorSpace< V, M > &vectorSpace, unsigned int subSequenceSize, const std::string &name)
	Default constructor. More...
virtual	~BaseVectorSequence ()
	Destructor. More...
Sequence methods
virtual unsigned int	subSequenceSize () const =0
	Size of the sub-sequence of vectors. See template specialization. More...
unsigned int	unifiedSequenceSize () const
	Calculates the size of the unified sequence of vectors. More...
unsigned int	vectorSizeLocal () const
	Local dimension (size) of the vector space. More...
unsigned int	vectorSizeGlobal () const
	Global dimension (size) of the vector space. More...
const VectorSpace< V, M > &	vectorSpace () const
	Vector space; access to protected attribute VectorSpace<V,M>& m_vectorSpace. More...
const std::string &	name () const
	Access to protected attribute m_name: name of the sequence of vectors. More...
void	setName (const std::string &newName)
	Changes the name of the sequence of vectors. More...
void	clear ()
	Reset the values and the size of the sequence of vectors. More...
const V &	subMinPlain () const
	Finds the minimum value of the sub-sequence. More...
const V &	unifiedMinPlain () const
	Finds the minimum value of the unified sequence. More...
const V &	subMaxPlain () const
	Finds the maximum value of the sub-sequence. More...
const V &	unifiedMaxPlain () const
	Finds the maximum value of the unified sequence. More...
const V &	subMeanPlain () const
	Finds the mean value of the sub-sequence. More...
const V &	unifiedMeanPlain () const
	Finds the mean value of the unified sequence. More...
const V &	subMedianPlain () const
	Finds the median value of the sub-sequence. More...
const V &	unifiedMedianPlain () const
	Finds the median value of the unified sequence. More...
const V &	subSampleVariancePlain () const
	Finds the variance of a sample of the sub-sequence. More...
const V &	unifiedSampleVariancePlain () const
	Finds the variance of a sample of the unified sequence. More...
const BoxSubset< V, M > &	subBoxPlain () const
	Finds a box subset of the sub-sequence (given by its min and max values calculated via subMinPlain and subMaxPlain). More...
const BoxSubset< V, M > &	unifiedBoxPlain () const
	Finds a box subset of the unified-sequence (given by the min and max values of the unified sequence calculated via unifiedMinPlain and unifiedMaxPlain). More...
void	deleteStoredVectors ()
	Deletes all the stored vectors. More...
void	append (const BaseVectorSequence< V, M > &src, unsigned int initialPos, unsigned int numPos)
	Appends the vector src to this vector. More...
double	subPositionsOfMaximum (const ScalarSequence< double > &subCorrespondingScalarValues, BaseVectorSequence< V, M > &subPositionsOfMaximum)
	Finds the positions where the maximum element occurs in the sub-sequence. More...
double	unifiedPositionsOfMaximum (const ScalarSequence< double > &subCorrespondingScalarValues, BaseVectorSequence< V, M > &unifiedPositionsOfMaximum)
	Finds the positions where the maximum element occurs in the unified sequence. More...
virtual void	resizeSequence (unsigned int newSubSequenceSize)=0
	Resize the sequence. See template specialization. More...
virtual void	resetValues (unsigned int initialPos, unsigned int numPos)=0
	Reset the values of the sequence. See template specialization. More...
virtual void	erasePositions (unsigned int initialPos, unsigned int numPos)=0
	Erase numPos positions in the sequence, starting at position initialPos. More...
virtual void	getPositionValues (unsigned int posId, V &vec) const =0
	Gets the values of the sequence at position posId and stores them at vec. See template specialization. More...
virtual void	setPositionValues (unsigned int posId, const V &vec)=0
	Set the values in vec at position posId of the sequence. See template specialization. More...
void	setGaussian (const V &meanVec, const V &stdDevVec)
	Sets the values of the sequence as a Gaussian distribution of mean given by meanVec and standard deviation by stdDevVec. More...
void	setUniform (const V &aVec, const V &bVec)
	Sets the values of the sequence as a uniform distribution between the values given by vectors aVec and bVec. More...
virtual void	subMeanExtra (unsigned int initialPos, unsigned int numPos, V &meanVec) const =0
	Finds the mean value of the sub-sequence, considering numPos positions starting at position initialPos. See template specialization. More...
virtual void	unifiedMeanExtra (unsigned int initialPos, unsigned int numPos, V &unifiedMeanVec) const =0
	Finds the mean value of the unified sequence of numPos positions starting at position initialPos. See template specialization. More...
virtual void	subMedianExtra (unsigned int initialPos, unsigned int numPos, V &medianVec) const =0
	Finds the median value of the sub-sequence, considering numPos positions starting at position initialPos. See template specialization. More...
virtual void	unifiedMedianExtra (unsigned int initialPos, unsigned int localNumPos, V &unifiedMedianVec) const =0
	Finds the median value of the unified sequence, considering numPos positions starting at position initialPos. See template specialization. More...
virtual void	subSampleVarianceExtra (unsigned int initialPos, unsigned int numPos, const V &meanVec, V &samVec) const =0
	Finds the sample variance of the sub-sequence, considering numPos positions starting at position initialPos and of mean meanVec. See template specialization. More...
virtual void	unifiedSampleVarianceExtra (unsigned int initialPos, unsigned int numPos, const V &unifiedMeanVec, V &unifiedSamVec) const =0
	Finds the sample variance of the unified sequence, considering numPos positions starting at position initialPos and of mean meanVec. See template specialization. More...
virtual void	subPopulationVariance (unsigned int initialPos, unsigned int numPos, const V &meanVec, V &popVec) const =0
	Finds the population variance of the sub-sequence, considering numPos positions starting at position initialPos and of mean meanVec. See template specialization. More...
virtual void	unifiedPopulationVariance (unsigned int initialPos, unsigned int numPos, const V &unifiedMeanVec, V &unifiedPopVec) const =0
	Finds the population variance of the unified-sequence, considering numPos positions starting at position initialPos and of mean meanVec. See template specialization. More...
virtual void	autoCovariance (unsigned int initialPos, unsigned int numPos, const V &meanVec, unsigned int lag, V &covVec) const =0
	Calculates the autocovariance. See template specialization. More...
virtual void	autoCorrViaDef (unsigned int initialPos, unsigned int numPos, unsigned int lag, V &corrVec) const =0
	Calculates autocorrelation via definition. See template specialization. More...
virtual void	autoCorrViaFft (unsigned int initialPos, unsigned int numPos, const std::vector< unsigned int > &lags, std::vector< V * > &corrVecs) const =0
	Calculates autocorrelation via Fast Fourier transforms (FFT). See template specialization. More...
virtual void	autoCorrViaFft (unsigned int initialPos, unsigned int numPos, unsigned int numSum, V &autoCorrsSumVec) const =0
	Calculates autocorrelation via Fast Fourier transforms (FFT). See template specialization. More...
virtual void	subMinMaxExtra (unsigned int initialPos, unsigned int numPos, V &minVec, V &maxVec) const =0
	Finds the minimum and the maximum values of the sub-sequence, considering numPos positions starting at position initialPos. See template specialization. More...
virtual void	unifiedMinMaxExtra (unsigned int initialPos, unsigned int numPos, V &unifiedMinVec, V &unifiedMaxVec) const =0
	Finds the minimum and the maximum values of the unified sequence, considering numPos positions starting at position initialPos. See template specialization. More...
virtual void	subHistogram (unsigned int initialPos, const V &minVec, const V &maxVec, std::vector< V * > &centersForAllBins, std::vector< V * > &quanttsForAllBins) const =0
	Calculates the histogram of the sub-sequence. See template specialization. More...
virtual void	unifiedHistogram (unsigned int initialPos, const V &unifiedMinVec, const V &unifiedMaxVec, std::vector< V * > &unifiedCentersForAllBins, std::vector< V * > &unifiedQuanttsForAllBins) const =0
	Calculates the histogram of the unified sequence. See template specialization. More...
virtual void	subInterQuantileRange (unsigned int initialPos, V &iqrVec) const =0
	Returns the interquartile range of the values in the sub-sequence. See template specialization. More...
virtual void	unifiedInterQuantileRange (unsigned int initialPos, V &unifiedIqrVec) const =0
	Returns the interquartile range of the values in the unified sequence. See template specialization. More...
virtual void	subScalesForKde (unsigned int initialPos, const V &iqrVec, unsigned int kdeDimension, V &scaleVec) const =0
	Selects the scales (bandwidth, scaleVec) for the kernel density estimation, considering only the sub-sequence. See template specialization. More...
virtual void	unifiedScalesForKde (unsigned int initialPos, const V &unifiedIqrVec, unsigned int kdeDimension, V &unifiedScaleVec) const =0
	Selects the scales (bandwidth) for the kernel density estimation, considering the unified sequence. See template specialization. More...
virtual void	subGaussian1dKde (unsigned int initialPos, const V &scaleVec, const std::vector< V * > &evaluationParamVecs, std::vector< V * > &densityVecs) const =0
	Gaussian kernel for the KDE estimate of the sub-sequence. See template specialization. More...
virtual void	unifiedGaussian1dKde (unsigned int initialPos, const V &unifiedScaleVec, const std::vector< V * > &unifiedEvaluationParamVecs, std::vector< V * > &unifiedDensityVecs) const =0
	Gaussian kernel for the KDE estimate of the unified sequence. See template specialization. More...
virtual void	subWriteContents (unsigned int initialPos, unsigned int numPos, const std::string &fileName, const std::string &fileType, const std::set< unsigned int > &allowedSubEnvIds) const =0
	Writes info of the sub-sequence to a file. See template specialization. More...
virtual void	subWriteContents (unsigned int initialPos, unsigned int numPos, std::ofstream &ofsvar, const std::string &fileType) const =0
	Writes info of the sub-sequence to a file. See template specialization. More...
virtual void	unifiedWriteContents (const std::string &fileName, const std::string &fileType) const =0
	Writes info of the unified sequence to a file. See template specialization. More...
virtual void	unifiedReadContents (const std::string &fileName, const std::string &fileType, const unsigned int subSequenceSize)=0
	Reads info of the unified sequence from a file. See template specialization. More...
virtual void	select (const std::vector< unsigned int > &idsOfUniquePositions)=0
	Select positions in the sequence of vectors. See template specialization. More...
virtual void	filter (unsigned int initialPos, unsigned int spacing)=0
	Filters positions in the sequence of vectors, starting at initialPos, and with spacing given by spacing. See template specialization. More...
void	computeFilterParams (std::ofstream *passedOfs, unsigned int &initialPos, unsigned int &spacing)
	Computes the filtering parameters spacing for the sequence of vectors. More...
virtual double	estimateConvBrooksGelman (unsigned int initialPos, unsigned int numPos) const =0
	Estimates convergence rate using Brooks & Gelman method. See template specialization. More...
virtual void	extractScalarSeq (unsigned int initialPos, unsigned int spacing, unsigned int numPos, unsigned int paramId, ScalarSequence< double > &scalarSeq) const =0
	Extracts a sequence of scalars of size numPos, starting at position initialPos, given spacing spacing. See template specialization. More...

Protected Member Functions
void	copy (const BaseVectorSequence< V, M > &src)
	Copies vector sequence src to this. More...
virtual void	extractRawData (unsigned int initialPos, unsigned int spacing, unsigned int numPos, unsigned int paramId, std::vector< double > &rawData) const =0
	Extracts the raw data. See template specialization. More...

Protected Attributes
const BaseEnvironment &	m_env
const VectorSpace< V, M > &	m_vectorSpace
std::string	m_name
Fft< double > *	m_fftObj
V *	m_subMinPlain
V *	m_unifiedMinPlain
V *	m_subMaxPlain
V *	m_unifiedMaxPlain
V *	m_subMeanPlain
V *	m_unifiedMeanPlain
V *	m_subMedianPlain
V *	m_unifiedMedianPlain
V *	m_subSampleVariancePlain
V *	m_unifiedSampleVariancePlain
BoxSubset< V, M > *	m_subBoxPlain
BoxSubset< V, M > *	m_unifiedBoxPlain

Detailed Description

template<class V, class M>
class QUESO::BaseVectorSequence< V, M >

Base class for handling vector and array samples (sequence of vectors or arrays).

This class handles either vector or array samples generated by an algorithm, as well as operations that can be carried over them, e.g., calculation of means, correlation and covariance matrices.

Definition at line 54 of file VectorSequence.h.

Constructor & Destructor Documentation

template<class V, class M>

QUESO::BaseVectorSequence< V, M >::BaseVectorSequence	(	const VectorSpace< V, M > &	vectorSpace,
		unsigned int	subSequenceSize,
		const std::string &	name
	)

Default constructor.

Definition at line 34 of file VectorSequence.C.

  :
  m_env                       (vectorSpace.env()),
  m_vectorSpace               (vectorSpace),
  m_name                      (name),
  m_fftObj                    (new Fft<double>(m_env)),
  m_subMinPlain               (NULL),
  m_unifiedMinPlain           (NULL),
  m_subMaxPlain               (NULL),
  m_unifiedMaxPlain           (NULL),
  m_subMeanPlain              (NULL),
  m_unifiedMeanPlain          (NULL),
  m_subMedianPlain            (NULL),
  m_unifiedMedianPlain        (NULL),
  m_subSampleVariancePlain    (NULL),
  m_unifiedSampleVariancePlain(NULL),
  m_subBoxPlain               (NULL),
  m_unifiedBoxPlain           (NULL)
{
  if (subSequenceSize) {}; // just to avoid compiler warning
}

template<class V , class M >

QUESO::BaseVectorSequence< V, M >::~BaseVectorSequence ( )

virtual

Destructor.

Definition at line 60 of file VectorSequence.C.

{
  //clear();
  this->deleteStoredVectors();
  if (m_fftObj != NULL) delete m_fftObj;
}

Member Function Documentation

template<class V, class M>

void QUESO::BaseVectorSequence< V, M >::append	(	const BaseVectorSequence< V, M > &	src,
		unsigned int	initialPos,
		unsigned int	numPos
	)

Appends the vector src to this vector.

This routine deletes all stored computed vectors

Definition at line 357 of file VectorSequence.C.

References QUESO::BaseVectorSequence< V, M >::getPositionValues(), QUESO::BaseVectorSequence< V, M >::subSequenceSize(), UQ_FATAL_TEST_MACRO, and QUESO::BaseVectorSequence< V, M >::vectorSpace().

Referenced by QUESO::MLSampling< P_V, P_M >::generateBalLinkedChains_all(), and QUESO::MLSampling< P_V, P_M >::generateUnbLinkedChains_all().

{
  UQ_FATAL_TEST_MACRO((src.subSequenceSize() < (initialPos+1)),
                      m_env.worldRank(),
                      "BaseVectorSequence<V,M>::append()",
                      "initialPos is too big");

  UQ_FATAL_TEST_MACRO((src.subSequenceSize() < (initialPos+numPos)),
                      m_env.worldRank(),
                      "BaseVectorSequence<V,M>::append()",
                      "numPos is too big");

  this->deleteStoredVectors();
  unsigned int currentSize = this->subSequenceSize();
  this->resizeSequence(currentSize+numPos);
  V tmpVec(src.vectorSpace().zeroVector());
  for (unsigned int i = 0; i < numPos; ++i) {
    src.getPositionValues(initialPos+i,tmpVec);
    this->setPositionValues(currentSize+i,tmpVec);
  }

  return;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::autoCorrViaDef ( unsigned int  initialPos, unsigned int  numPos, unsigned int  lag, V &  corrVec  ) const

pure virtual

Calculates autocorrelation via definition. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >, and QUESO::ArrayOfSequences< V, M >.

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::autoCorrViaFft ( unsigned int  initialPos, unsigned int  numPos, const std::vector< unsigned int > &  lags, std::vector< V * > &  corrVecs  ) const

pure virtual

Calculates autocorrelation via Fast Fourier transforms (FFT). See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >, and QUESO::ArrayOfSequences< V, M >.

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::autoCorrViaFft ( unsigned int  initialPos, unsigned int  numPos, unsigned int  numSum, V &  autoCorrsSumVec  ) const

pure virtual

Calculates autocorrelation via Fast Fourier transforms (FFT). See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >, and QUESO::ArrayOfSequences< V, M >.

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::autoCovariance ( unsigned int  initialPos, unsigned int  numPos, const V &  meanVec, unsigned int  lag, V &  covVec  ) const

pure virtual

Calculates the autocovariance. See template specialization.

The autocovariance is the covariance of a variable with itself at some other time. It is calculated over a sequence of vectors with initial position initialPos, considering numPos positions, a lag of lag, with mean given by meanVec. The results are saved in the output vector covVec/

Implemented in QUESO::SequenceOfVectors< V, M >, and QUESO::ArrayOfSequences< V, M >.

template<class V , class M >

void QUESO::BaseVectorSequence< V, M >::clear

(

)

Reset the values and the size of the sequence of vectors.

Definition at line 136 of file VectorSequence.C.

Referenced by QUESO::MLSampling< P_V, P_M >::generateSequence(), and QUESO::MLSampling< P_V, P_M >::generateSequence_Step02_inter0().

{
  unsigned int numPos = this->subSequenceSize();
  if (numPos) {
    this->resetValues(0,numPos);
    this->resizeSequence(0);
  }

  return;
}

template<class V , class M >

void QUESO::BaseVectorSequence< V, M >::computeFilterParams	(	std::ofstream *	passedOfs,
		unsigned int &	initialPos,
		unsigned int &	spacing
	)

Computes the filtering parameters spacing for the sequence of vectors.

Definition at line 641 of file VectorSequence.C.

References UQ_FATAL_TEST_MACRO.

Referenced by QUESO::MLSampling< P_V, P_M >::generateSequence(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateSequence(), and QUESO::MLSampling< P_V, P_M >::generateSequence_Step11_inter0().

{
  if (m_env.subDisplayFile()) {
    *m_env.subDisplayFile() << "\n"
                            << "\n-----------------------------------------------------"
                            << "\n Computing filter parameters for chain '" << m_name << "' ..."
                            << "\n-----------------------------------------------------"
                            << "\n"
                            << std::endl;
  }

  bool okSituation = ((passedOfs == NULL                            ) ||
                      ((passedOfs != NULL) && (m_env.subRank() >= 0)));
  UQ_FATAL_TEST_MACRO(!okSituation,
                      m_env.worldRank(),
                      "BaseVectorSequence<V,M>::computeFilterParams()",
                      "unexpected combination of file pointer and subRank");

  //initialPos = 0;
  spacing    = 1;

  if (m_env.subDisplayFile()) {
    *m_env.subDisplayFile() << "\n-----------------------------------------------------"
                            << "\n Finished computing filter parameters for chain '" << m_name << "'"
                            << ": initialPos = " << initialPos
                            << ", spacing = "    << spacing
                            << "\n-----------------------------------------------------"
                            << "\n"
                            << std::endl;
  }

  return;
}

template<class V, class M>

void QUESO::BaseVectorSequence< V, M >::copy ( const BaseVectorSequence< V, M > &  src )

protected

Copies vector sequence src to this.

This routine deletes all stored computed vectors

Definition at line 681 of file VectorSequence.C.

References QUESO::BaseVectorSequence< V, M >::m_name, QUESO::BaseVectorSequence< V, M >::m_vectorSpace, and UQ_FATAL_TEST_MACRO.

Referenced by QUESO::SequenceOfVectors< V, M >::copy().

{
  // FIX ME: should check environments as well ???

  UQ_FATAL_TEST_MACRO(m_vectorSpace.dimLocal() != src.m_vectorSpace.dimLocal(),
                      m_env.worldRank(),
                      "SequenceOfVectors<V,M>::copy()",
                      "incompatible vector space dimensions");

  m_name = src.m_name;
  this->deleteStoredVectors();

  return;
}

template<class V , class M >

void QUESO::BaseVectorSequence< V, M >::deleteStoredVectors

(

)

Deletes all the stored vectors.

It deletes all stored vectors and assigns NULL value to the pointers: m_subMinPlain, m_unifiedMinPlain, m_subMaxPlain, m_unifiedMaxPlain, m_subMeanPlain, m_unifiedMeanPlain, m_subMedianPlain, m_unifiedMedianPlain, m_subBoxPlain, m_unifiedBoxPlain, m_subSampleVariancePlain, m_unifiedSampleVariancePlain.

Definition at line 301 of file VectorSequence.C.

Referenced by QUESO::ArrayOfSequences< V, M >::erasePositions(), QUESO::SequenceOfVectors< V, M >::erasePositions(), QUESO::ArrayOfSequences< V, M >::resetValues(), QUESO::SequenceOfVectors< V, M >::resetValues(), QUESO::ArrayOfSequences< V, M >::resizeSequence(), QUESO::SequenceOfVectors< V, M >::resizeSequence(), QUESO::ArrayOfSequences< V, M >::setGaussian(), QUESO::ArrayOfSequences< V, M >::setPositionValues(), QUESO::SequenceOfVectors< V, M >::setPositionValues(), and QUESO::ArrayOfSequences< V, M >::setUniform().

{
  if (m_subMinPlain) {
    delete m_subMinPlain;
    m_subMinPlain                = NULL;
  }
  if (m_unifiedMinPlain) {
    delete m_unifiedMinPlain;
    m_unifiedMinPlain            = NULL;
  }
  if (m_subMaxPlain) {
    delete m_subMaxPlain;
    m_subMaxPlain                = NULL;
  }
  if (m_unifiedMaxPlain) {
    delete m_unifiedMaxPlain;
    m_unifiedMaxPlain            = NULL;
  }
  if (m_subMeanPlain) {
    delete m_subMeanPlain;
    m_subMeanPlain               = NULL;
  }
  if (m_unifiedMeanPlain) {
    delete m_unifiedMeanPlain;
    m_unifiedMeanPlain           = NULL;
  }
  if (m_subMedianPlain) {
    delete m_subMedianPlain;
    m_subMedianPlain             = NULL;
  }
  if (m_unifiedMedianPlain) {
    delete m_unifiedMedianPlain;
    m_unifiedMedianPlain         = NULL;
  }
  if (m_subSampleVariancePlain) {
    delete m_subSampleVariancePlain;
    m_subSampleVariancePlain     = NULL;
  }
  if (m_unifiedSampleVariancePlain) {
    delete m_unifiedSampleVariancePlain;
    m_unifiedSampleVariancePlain = NULL;
  }
  if (m_subBoxPlain) {
    delete m_subBoxPlain;
    m_subBoxPlain     = NULL;
  }
  if (m_unifiedBoxPlain) {
    delete m_unifiedBoxPlain;
    m_unifiedBoxPlain = NULL;
  }

  return;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::erasePositions ( unsigned int  initialPos, unsigned int  numPos  )

pure virtual

Erase numPos positions in the sequence, starting at position initialPos.

This routine deletes all stored computed vectors

Implemented in QUESO::SequenceOfVectors< V, M >, and QUESO::ArrayOfSequences< V, M >.

template<class V, class M>

virtual double QUESO::BaseVectorSequence< V, M >::estimateConvBrooksGelman ( unsigned int  initialPos, unsigned int  numPos  ) const

pure virtual

Estimates convergence rate using Brooks & Gelman method. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

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

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::extractRawData ( unsigned int  initialPos, unsigned int  spacing, unsigned int  numPos, unsigned int  paramId, std::vector< double > &  rawData  ) const

protectedpure virtual

Extracts the raw data. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >, and QUESO::ArrayOfSequences< V, M >.

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::extractScalarSeq ( unsigned int  initialPos, unsigned int  spacing, unsigned int  numPos, unsigned int  paramId, ScalarSequence< double > &  scalarSeq  ) const

pure virtual

Extracts a sequence of scalars of size numPos, starting at position initialPos, given spacing spacing. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >, and QUESO::ArrayOfSequences< V, M >.

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::filter ( unsigned int  initialPos, unsigned int  spacing  )

pure virtual

Filters positions in the sequence of vectors, starting at initialPos, and with spacing given by spacing. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >, and QUESO::ArrayOfSequences< V, M >.

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

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::getPositionValues ( unsigned int  posId, V &  vec  ) const

pure virtual

Gets the values of the sequence at position posId and stores them at vec. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >, and QUESO::ArrayOfSequences< V, M >.

Referenced by QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::actualGenerateSequence(), QUESO::BaseVectorSequence< V, M >::append(), QUESO::ComputeCovCorrMatricesBetweenVectorSequences(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateFullChain(), QUESO::BaseVectorSequence< V, M >::unifiedPositionsOfMaximum(), and QUESO::MetropolisHastingsSG< P_V, P_M >::updateAdaptedCovMatrix().

template<class V , class M >

const std::string & QUESO::BaseVectorSequence< V, M >::name

(

)

const

Access to protected attribute m_name: name of the sequence of vectors.

This method is used, for instance, to recover the name of a sequence of vector samples, such as the 'rawChain' for the raw chain of samples used in an Monte Carlo algorithm.

Definition at line 121 of file VectorSequence.C.

Referenced by QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::actualGenerateSequence(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateFullChain(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateSequence(), QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::internGenerateSequence(), and QUESO::MetropolisHastingsSG< P_V, P_M >::writeInfo().

{
  return m_name;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::resetValues ( unsigned int  initialPos, unsigned int  numPos  )

pure virtual

Reset the values of the sequence. See template specialization.

This routine deletes all stored computed vectors

Implemented in QUESO::SequenceOfVectors< V, M >, and QUESO::ArrayOfSequences< V, M >.

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::resizeSequence ( unsigned int  newSubSequenceSize )

pure virtual

Resize the sequence. See template specialization.

This routine deletes all stored computed vectors

Implemented in QUESO::SequenceOfVectors< V, M >, and QUESO::ArrayOfSequences< V, M >.

Referenced by QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::actualGenerateSequence(), QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::actualReadSequence(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateFullChain(), QUESO::MLSampling< P_V, P_M >::generateSequence(), QUESO::BaseVectorSequence< V, M >::subPositionsOfMaximum(), and QUESO::BaseVectorSequence< V, M >::unifiedPositionsOfMaximum().

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::select ( const std::vector< unsigned int > &  idsOfUniquePositions )

pure virtual

Select positions in the sequence of vectors. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >, and QUESO::ArrayOfSequences< V, M >.

template<class V, class M >

void QUESO::BaseVectorSequence< V, M >::setGaussian	(	const V &	meanVec,
		const V &	stdDevVec
	)

Sets the values of the sequence as a Gaussian distribution of mean given by meanVec and standard deviation by stdDevVec.

This routine deletes all stored computed vectors

Definition at line 611 of file VectorSequence.C.

{
  V gaussianVector(m_vectorSpace.zeroVector());
  for (unsigned int j = 0; j < this->subSequenceSize(); ++j) {
    gaussianVector.cwSetGaussian(meanVec,stdDevVec);
    this->setPositionValues(j,gaussianVector);
  }

  this->deleteStoredVectors();

  return;
}

template<class V , class M >

void QUESO::BaseVectorSequence< V, M >::setName

(

const std::string &

newName

)

Changes the name of the sequence of vectors.

Definition at line 128 of file VectorSequence.C.

Referenced by 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_Step02_inter0(), QUESO::MLSampling< P_V, P_M >::generateSequence_Step11_inter0(), and QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::internGenerateSequence().

{
  m_name = newName;
  return;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::setPositionValues ( unsigned int  posId, const V &  vec  )

pure virtual

Set the values in vec at position posId of the sequence. See template specialization.

This routine deletes all stored computed vectors

Implemented in QUESO::SequenceOfVectors< V, M >, and QUESO::ArrayOfSequences< V, M >.

Referenced by QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::actualGenerateSequence(), QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::actualReadSequence(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateFullChain(), QUESO::MLSampling< P_V, P_M >::generateSequence(), QUESO::BaseVectorSequence< V, M >::subPositionsOfMaximum(), and QUESO::BaseVectorSequence< V, M >::unifiedPositionsOfMaximum().

template<class V, class M >

void QUESO::BaseVectorSequence< V, M >::setUniform	(	const V &	aVec,
		const V &	bVec
	)

Sets the values of the sequence as a uniform distribution between the values given by vectors aVec and bVec.

This routine deletes all stored computed vectors

Definition at line 626 of file VectorSequence.C.

{
  V uniformVector(m_vectorSpace.zeroVector());
  for (unsigned int j = 0; j < this->subSequenceSize(); ++j) {
    uniformVector.cwSetUniform(aVec,bVec);
    this->setPositionValues(j,uniformVector);
  }

  this->deleteStoredVectors();

  return;
}

template<class V , class M >

const BoxSubset< V, M > & QUESO::BaseVectorSequence< V, M >::subBoxPlain

(

)

const

Finds a box subset of the sub-sequence (given by its min and max values calculated via subMinPlain and subMaxPlain).

Definition at line 273 of file VectorSequence.C.

{
  if (m_subBoxPlain == NULL) {
    m_subBoxPlain = new BoxSubset<V,M>(m_name.c_str(),
                                              m_vectorSpace,
                                              this->subMinPlain(),
                                              this->subMaxPlain());
  }

  return *m_subBoxPlain;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::subGaussian1dKde ( unsigned int  initialPos, const V &  scaleVec, const std::vector< V * > &  evaluationParamVecs, std::vector< V * > &  densityVecs  ) const

pure virtual

Gaussian kernel for the KDE estimate of the sub-sequence. See template specialization.

Computes a probability density estimate of the sample in this sub-sequence, starting at position initialPos. densityVecs is the vector of density values evaluated at the points in evaluationParamVecs. The estimate is based on Gaussian (normal) kernel function, using a window parameter (scaleVec).

Implemented in QUESO::SequenceOfVectors< V, M >.

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::subHistogram ( unsigned int  initialPos, const V &  minVec, const V &  maxVec, std::vector< V * > &  centersForAllBins, std::vector< V * > &  quanttsForAllBins  ) const

pure virtual

Calculates the histogram of the sub-sequence. See template specialization.

The IQR is a robust estimate of the spread of the data, since changes in the upper and lower 25% of the data do not affect it. If there are outliers in the data, then the IQR is more representative than the standard deviation as an estimate of the spread of the body of the data. The IQR is less efficient than the standard deviation as an estimate of the spread when the data is all from the normal distribution. (from Matlab)

Implemented in QUESO::SequenceOfVectors< V, M >.

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::subInterQuantileRange ( unsigned int  initialPos, V &  iqrVec  ) const

pure virtual

Returns the interquartile range of the values in the sub-sequence. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

template<class V , class M >

const V & QUESO::BaseVectorSequence< V, M >::subMaxPlain

(

)

const

Finds the maximum value of the sub-sequence.

Definition at line 175 of file VectorSequence.C.

{
  if (m_subMaxPlain == NULL) {
    if (m_subMinPlain == NULL) m_subMinPlain = m_vectorSpace.newVector();
    m_subMaxPlain = m_vectorSpace.newVector();
    subMinMaxExtra(0,this->subSequenceSize(),*m_subMinPlain,*m_subMaxPlain);
  }

  return *m_subMaxPlain;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::subMeanExtra ( unsigned int  initialPos, unsigned int  numPos, V &  meanVec  ) const

pure virtual

Finds the mean value of the sub-sequence, considering numPos positions starting at position initialPos. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

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

template<class V , class M >

const V & QUESO::BaseVectorSequence< V, M >::subMeanPlain

(

)

const

Finds the mean value of the sub-sequence.

Definition at line 201 of file VectorSequence.C.

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

{
  if (m_subMeanPlain == NULL) {
    m_subMeanPlain = m_vectorSpace.newVector();
    subMeanExtra(0,subSequenceSize(),*m_subMeanPlain);
  }

  return *m_subMeanPlain;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::subMedianExtra ( unsigned int  initialPos, unsigned int  numPos, V &  medianVec  ) const

pure virtual

Finds the median value of the sub-sequence, considering numPos positions starting at position initialPos. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

template<class V , class M >

const V & QUESO::BaseVectorSequence< V, M >::subMedianPlain

(

)

const

Finds the median value of the sub-sequence.

Definition at line 225 of file VectorSequence.C.

{
  if (m_subMedianPlain == NULL) {
    m_subMedianPlain = m_vectorSpace.newVector();
    subMedianExtra(0, subSequenceSize(), *m_subMedianPlain);
  }

  return *m_subMedianPlain;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::subMinMaxExtra ( unsigned int  initialPos, unsigned int  numPos, V &  minVec, V &  maxVec  ) const

pure virtual

Finds the minimum and the maximum values of the sub-sequence, considering numPos positions starting at position initialPos. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

template<class V , class M >

const V & QUESO::BaseVectorSequence< V, M >::subMinPlain

(

)

const

Finds the minimum value of the sub-sequence.

Definition at line 149 of file VectorSequence.C.

{
  if (m_subMinPlain == NULL) {
    m_subMinPlain = m_vectorSpace.newVector();
    if (m_subMaxPlain == NULL) m_subMaxPlain = m_vectorSpace.newVector();
    subMinMaxExtra(0,this->subSequenceSize(),*m_subMinPlain,*m_subMaxPlain);
  }

  return *m_subMinPlain;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::subPopulationVariance ( unsigned int  initialPos, unsigned int  numPos, const V &  meanVec, V &  popVec  ) const

pure virtual

Finds the population variance of the sub-sequence, considering numPos positions starting at position initialPos and of mean meanVec. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

template<class V, class M>

double QUESO::BaseVectorSequence< V, M >::subPositionsOfMaximum	(	const ScalarSequence< double > &	subCorrespondingScalarValues,
		BaseVectorSequence< V, M > &	subPositionsOfMaximum
	)

Finds the positions where the maximum element occurs in the sub-sequence.

Definition at line 386 of file VectorSequence.C.

References QUESO::BaseVectorSequence< V, M >::resizeSequence(), QUESO::BaseVectorSequence< V, M >::setPositionValues(), QUESO::ScalarSequence< T >::subMaxPlain(), QUESO::ScalarSequence< T >::subSequenceSize(), and UQ_FATAL_TEST_MACRO.

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

{
  if (m_env.subDisplayFile()) {
    *m_env.subDisplayFile() << "Entering BaseVectorSequence<V,M>::subPositionsOfMaximum()"
                            << ": subCorrespondingScalarValues,subSequenceSize() = " << subCorrespondingScalarValues.subSequenceSize()
                            << ", this->subSequenceSize = " << this->subSequenceSize()
                            << std::endl;
  }

  UQ_FATAL_TEST_MACRO(subCorrespondingScalarValues.subSequenceSize() != this->subSequenceSize(),
                      m_env.worldRank(),
                      "BaseVectorSequence<V,M>::subPositionsOfMaximum()",
                      "invalid input");

  double subMaxValue = subCorrespondingScalarValues.subMaxPlain();
  unsigned int iMax = subCorrespondingScalarValues.subSequenceSize();

  unsigned int subNumPos = 0;
  for (unsigned int i = 0; i < iMax; ++i) {
    if (subCorrespondingScalarValues[i] == subMaxValue) {
      subNumPos++;
    }
  }

  V tmpVec(this->vectorSpace().zeroVector());
  subPositionsOfMaximum.resizeSequence(subNumPos);
  unsigned int j = 0;
  for (unsigned int i = 0; i < iMax; ++i) {
    if (subCorrespondingScalarValues[i] == subMaxValue) {
      this->getPositionValues                (i,tmpVec);
      subPositionsOfMaximum.setPositionValues(j,tmpVec);
      j++;
    }
  }

  if (m_env.subDisplayFile()) {
    *m_env.subDisplayFile() << "Leaving BaseVectorSequence<V,M>::subPositionsOfMaximum()"
                            << std::endl;
  }

  return subMaxValue;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::subSampleVarianceExtra ( unsigned int  initialPos, unsigned int  numPos, const V &  meanVec, V &  samVec  ) const

pure virtual

Finds the sample variance of the sub-sequence, considering numPos positions starting at position initialPos and of mean meanVec. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

template<class V , class M >

const V & QUESO::BaseVectorSequence< V, M >::subSampleVariancePlain

(

)

const

Finds the variance of a sample of the sub-sequence.

Definition at line 249 of file VectorSequence.C.

{
  if (m_subSampleVariancePlain == NULL) {
    m_subSampleVariancePlain = m_vectorSpace.newVector();
    subSampleVarianceExtra(0,subSequenceSize(),subMeanPlain(),*m_subSampleVariancePlain);
  }

  return *m_subSampleVariancePlain;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::subScalesForKde ( unsigned int  initialPos, const V &  iqrVec, unsigned int  kdeDimension, V &  scaleVec  ) const

pure virtual

Selects the scales (bandwidth, scaleVec) for the kernel density estimation, considering only the sub-sequence. See template specialization.

The bandwidth of the kernel is a free parameter which exhibits a strong influence on the resulting estimate. Silverman (1986) suggests the following normal-based estimates: S1 = 1.06 × (standard deviation) × n^{-1/5} S2 = 0.79 × (iqrVec) × n^{-1/5}, where iqrVec is the interquartile range scaleVec = 0.90 × minimum(standard deviation, iqrVec /1.34) × n^{-1/5}. These estimates are popular due to their simplicity, and are used in QUESO with the adaptation of the exponent oven the sample size n (-1/5) with -1/(4 + kdeDimension) where kdeDimension is the KDE dimension.

Implemented in QUESO::SequenceOfVectors< V, M >.

template<class V, class M>

virtual unsigned int QUESO::BaseVectorSequence< V, M >::subSequenceSize ( ) const

pure virtual

Size of the sub-sequence of vectors. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >, and QUESO::ArrayOfSequences< V, M >.

Referenced by QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::actualGenerateSequence(), QUESO::BaseVectorSequence< V, M >::append(), QUESO::ComputeCovCorrMatricesBetweenVectorSequences(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateFullChain(), QUESO::MLSampling< P_V, P_M >::generateSequence(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateSequence(), QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::internGenerateSequence(), QUESO::MetropolisHastingsSG< P_V, P_M >::updateAdaptedCovMatrix(), and QUESO::MetropolisHastingsSG< P_V, P_M >::writeInfo().

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::subWriteContents ( unsigned int  initialPos, unsigned int  numPos, const std::string &  fileName, const std::string &  fileType, const std::set< unsigned int > &  allowedSubEnvIds  ) const

pure virtual

Writes info of the sub-sequence to a file. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

Referenced by QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::actualGenerateSequence(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateFullChain(), QUESO::MetropolisHastingsSG< P_V, P_M >::generateSequence(), and QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::internGenerateSequence().

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::subWriteContents ( unsigned int  initialPos, unsigned int  numPos, std::ofstream &  ofsvar, const std::string &  fileType  ) const

pure virtual

Writes info of the sub-sequence to a file. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

template<class V , class M >

const BoxSubset< V, M > & QUESO::BaseVectorSequence< V, M >::unifiedBoxPlain

(

)

const

Finds a box subset of the unified-sequence (given by the min and max values of the unified sequence calculated via unifiedMinPlain and unifiedMaxPlain).

Definition at line 287 of file VectorSequence.C.

{
  if (m_unifiedBoxPlain == NULL) {
    m_unifiedBoxPlain = new BoxSubset<V,M>(m_name.c_str(),
                                                  m_vectorSpace,
                                                  this->unifiedMinPlain(),
                                                  this->unifiedMaxPlain());
  }

  return *m_unifiedBoxPlain;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::unifiedGaussian1dKde ( unsigned int  initialPos, const V &  unifiedScaleVec, const std::vector< V * > &  unifiedEvaluationParamVecs, std::vector< V * > &  unifiedDensityVecs  ) const

pure virtual

Gaussian kernel for the KDE estimate of the unified sequence. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::unifiedHistogram ( unsigned int  initialPos, const V &  unifiedMinVec, const V &  unifiedMaxVec, std::vector< V * > &  unifiedCentersForAllBins, std::vector< V * > &  unifiedQuanttsForAllBins  ) const

pure virtual

Calculates the histogram of the unified sequence. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::unifiedInterQuantileRange ( unsigned int  initialPos, V &  unifiedIqrVec  ) const

pure virtual

Returns the interquartile range of the values in the unified sequence. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

template<class V , class M >

const V & QUESO::BaseVectorSequence< V, M >::unifiedMaxPlain

(

)

const

Finds the maximum value of the unified sequence.

Definition at line 188 of file VectorSequence.C.

{
  if (m_unifiedMaxPlain == NULL) {
    if (m_unifiedMinPlain == NULL) m_unifiedMinPlain = m_vectorSpace.newVector();
    m_unifiedMaxPlain = m_vectorSpace.newVector();
    unifiedMinMaxExtra(0,this->subSequenceSize(),*m_unifiedMinPlain,*m_unifiedMaxPlain);
  }

  return *m_unifiedMaxPlain;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::unifiedMeanExtra ( unsigned int  initialPos, unsigned int  numPos, V &  unifiedMeanVec  ) const

pure virtual

Finds the mean value of the unified sequence of numPos positions starting at position initialPos. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

Referenced by QUESO::ComputeCovCorrMatricesBetweenVectorSequences().

template<class V , class M >

const V & QUESO::BaseVectorSequence< V, M >::unifiedMeanPlain

(

)

const

Finds the mean value of the unified sequence.

Definition at line 213 of file VectorSequence.C.

{
  if (m_unifiedMeanPlain == NULL) {
    m_unifiedMeanPlain = m_vectorSpace.newVector();
    unifiedMeanExtra(0,subSequenceSize(),*m_unifiedMeanPlain);
  }

  return *m_unifiedMeanPlain;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::unifiedMedianExtra ( unsigned int  initialPos, unsigned int  localNumPos, V &  unifiedMedianVec  ) const

pure virtual

Finds the median value of the unified sequence, considering numPos positions starting at position initialPos. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

template<class V , class M >

const V & QUESO::BaseVectorSequence< V, M >::unifiedMedianPlain

(

)

const

Finds the median value of the unified sequence.

Definition at line 237 of file VectorSequence.C.

{
  if (m_unifiedMedianPlain == NULL) {
    m_unifiedMedianPlain = m_vectorSpace.newVector();
    unifiedMedianExtra(0, subSequenceSize(), *m_unifiedMedianPlain);
  }

  return *m_unifiedMedianPlain;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::unifiedMinMaxExtra ( unsigned int  initialPos, unsigned int  numPos, V &  unifiedMinVec, V &  unifiedMaxVec  ) const

pure virtual

Finds the minimum and the maximum values of the unified sequence, considering numPos positions starting at position initialPos. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

template<class V , class M >

const V & QUESO::BaseVectorSequence< V, M >::unifiedMinPlain

(

)

const

Finds the minimum value of the unified sequence.

Definition at line 162 of file VectorSequence.C.

{
  if (m_unifiedMinPlain == NULL) {
    m_unifiedMinPlain = m_vectorSpace.newVector();
    if (m_unifiedMaxPlain == NULL) m_unifiedMaxPlain = m_vectorSpace.newVector();
    unifiedMinMaxExtra(0,this->subSequenceSize(),*m_unifiedMinPlain,*m_unifiedMaxPlain);
  }

  return *m_unifiedMinPlain;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::unifiedPopulationVariance ( unsigned int  initialPos, unsigned int  numPos, const V &  unifiedMeanVec, V &  unifiedPopVec  ) const

pure virtual

Finds the population variance of the unified-sequence, considering numPos positions starting at position initialPos and of mean meanVec. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

template<class V, class M>

double QUESO::BaseVectorSequence< V, M >::unifiedPositionsOfMaximum	(	const ScalarSequence< double > &	subCorrespondingScalarValues,
		BaseVectorSequence< V, M > &	unifiedPositionsOfMaximum
	)

Finds the positions where the maximum element occurs in the unified sequence.

Parameters

this	The underlying sequence of vectors
subCorrespondingScalarValues	For a given process, a scalar sequence where element i corresponds to element i of this.
unifiedPositionsOfMaximum	Upon returning, on process 0 on chain 0, this will contain states that correspond to the unique maximum value in subCorrespondingScalarValues over all processes.

Returns

Maximum element of subCorrespondingScalarValues over all processes.

Definition at line 433 of file VectorSequence.C.

References QUESO::BaseVectorSequence< V, M >::getPositionValues(), RawValue_MPI_DOUBLE, RawValue_MPI_INT, RawValue_MPI_MAX, RawValue_MPI_SUM, QUESO::BaseVectorSequence< V, M >::resizeSequence(), QUESO::BaseVectorSequence< V, M >::setPositionValues(), QUESO::ScalarSequence< T >::subMaxPlain(), QUESO::ScalarSequence< T >::subSequenceSize(), and UQ_FATAL_TEST_MACRO.

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

{
  if (m_env.subDisplayFile()) {
    *m_env.subDisplayFile() << "Entering BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()"
                            << ": subCorrespondingScalarValues,subSequenceSize() = " << subCorrespondingScalarValues.subSequenceSize()
                            << ", this->subSequenceSize = " << this->subSequenceSize()
                            << std::endl;
  }

  UQ_FATAL_TEST_MACRO(subCorrespondingScalarValues.subSequenceSize() != this->subSequenceSize(),
                      m_env.worldRank(),
                      "BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()",
                      "invalid input");

  // Compute the max on each process
  double subMaxValue = subCorrespondingScalarValues.subMaxPlain();

  //******************************************************************
  // Get overall max
  //******************************************************************
  double unifiedMaxValue;
  std::vector<double> sendbufPos(1,0.);
  for (unsigned int i = 0; i < sendbufPos.size(); ++i) {
    sendbufPos[i] = subMaxValue;
  }
  m_env.inter0Comm().Allreduce((void *) &sendbufPos[0], (void *) &unifiedMaxValue, (int) sendbufPos.size(), RawValue_MPI_DOUBLE, RawValue_MPI_MAX,
                               "BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()",
                               "failed MPI.Allreduce() for max");

  // Find number of elements (subNumPos) on each process that attain the
  // global max.  This could be zero.
  unsigned int iMax = subCorrespondingScalarValues.subSequenceSize();
  int subNumPos = 0; // Yes, 'int', due to MPI to be used soon
  for (unsigned int i = 0; i < iMax; ++i) {
    if (subCorrespondingScalarValues[i] == unifiedMaxValue) {
      subNumPos++;
    }
  }

  // Fill up unifiedPositionsOfMaximum with the states that attain maxima
  // (if they exist)
  V tmpVec(this->vectorSpace().zeroVector());
  unifiedPositionsOfMaximum.resizeSequence(subNumPos);  // subNumPos could be 0
  unsigned int j = 0;
  for (unsigned int i = 0; i < iMax; ++i) {
    // This 'if' statement is false if subNumPos == 0
    if (subCorrespondingScalarValues[i] == unifiedMaxValue) {
      this->getPositionValues                    (i,tmpVec);
      unifiedPositionsOfMaximum.setPositionValues(j,tmpVec);
      j++;
    }
  }

  // Compute total (over all processes) number of elements that attain maxima
  std::vector<int> auxBuf(1,0);
  int unifiedNumPos = 0; // Yes, 'int', due to MPI to be used soon
  auxBuf[0] = subNumPos;
  m_env.inter0Comm().Allreduce((void *) &auxBuf[0], (void *) &unifiedNumPos, (int) auxBuf.size(), RawValue_MPI_INT, RawValue_MPI_SUM,
                               "BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()",
                               "failed MPI.Allreduce() for sum");

  // Resize positions to hold all elements that attain maxima
  unifiedPositionsOfMaximum.resizeSequence(unifiedNumPos);

  //******************************************************************
  // Use MPI_Gatherv for number of positions
  //******************************************************************
  // Gather up *number* of maxima on each chain and store in recvcntsPos
  unsigned int Np = (unsigned int) m_env.inter0Comm().NumProc();

  std::vector<int> recvcntsPos(Np,0); // '0' is NOT the correct value for recvcntsPos[0]
  m_env.inter0Comm().Gather((void *) &subNumPos, 1, RawValue_MPI_INT, (void *) &recvcntsPos[0], (int) 1, RawValue_MPI_INT, 0,
                            "BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()",
                            "failed MPI.Gatherv()");
  if (m_env.inter0Rank() == 0) {
    UQ_FATAL_TEST_MACRO(recvcntsPos[0] != (int) subNumPos,
                        m_env.worldRank(),
                        "BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()",
                        "failed MPI.Gather() result at proc 0 (recvcntsPos[0])");
  }

  // Construct offset indices based on number of maxima
  std::vector<int> displsPos(Np,0);
  for (unsigned int nodeId = 1; nodeId < Np; ++nodeId) { // Yes, from '1' on
    displsPos[nodeId] = displsPos[nodeId-1] + recvcntsPos[nodeId-1];
  }
  if (m_env.inter0Rank() == 0) {
    UQ_FATAL_TEST_MACRO(unifiedNumPos != (displsPos[Np - 1] + recvcntsPos[Np - 1]),
                        m_env.worldRank(),
                        "BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()",
                        "failed MPI.Gather() result at proc 0 (unifiedNumPos)");
  }

  //******************************************************************
  // Use MPI_Gatherv for number of doubles
  //******************************************************************
  // Gather up number of states that attain maxima multiplied by the size of
  // the state (on each process).  Store this in recvcntsDbs.
  // So recvcntsDbs[i] is the number of states that attain maxima on chain i
  // multiplied by the size of the state (a state could be a vector of length
  // > 1).
  unsigned int dimSize = m_vectorSpace.dimLocal();
  int subNumDbs = subNumPos * dimSize; // Yes, 'int', due to MPI to be used soon
  std::vector<int> recvcntsDbs(Np,0); // '0' is NOT the correct value for recvcntsDbs[0]
  m_env.inter0Comm().Gather((void *) &subNumDbs, 1, RawValue_MPI_INT, (void *) &recvcntsDbs[0], (int) 1, RawValue_MPI_INT, 0,
                            "BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()",
                            "failed MPI.Gatherv()");
  if (m_env.inter0Rank() == 0) {
    UQ_FATAL_TEST_MACRO(recvcntsDbs[0] != (int) subNumDbs,
                        m_env.worldRank(),
                        "BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()",
                        "failed MPI.Gather() result at proc 0 (recvcntsDbs[0])");
  }

  // Now gather up the offsets based on the number of states (mulitplied by the
  // size of the state)
  std::vector<int> displsDbs(Np,0);
  for (unsigned int nodeId = 1; nodeId < Np; ++nodeId) { // Yes, from '1' on
    displsDbs[nodeId] = displsDbs[nodeId-1] + recvcntsDbs[nodeId-1];
  }
  if (m_env.inter0Rank() == 0) {
    UQ_FATAL_TEST_MACRO(((int) (unifiedNumPos*dimSize)) != (displsDbs[Np - 1] + recvcntsDbs[Np - 1]),
                        m_env.worldRank(),
                        "BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()",
                        "failed MPI.Gather() result at proc 0 (unifiedNumPos*dimSize)");
  }

  //******************************************************************
  // Prepare counters and buffers for gatherv of maximum positions
  //******************************************************************
  // Take all the states on all chains that attain maxima, and put them in a
  // send buffer ready for MPI
  std::vector<double> sendbufDbs(subNumDbs,0.);
  for (unsigned int i = 0; i < (unsigned int) subNumPos; ++i) {
    unifiedPositionsOfMaximum.getPositionValues(i,tmpVec);
    for (unsigned int j = 0; j < dimSize; ++j) {
      sendbufDbs[i*dimSize + j] = tmpVec[j];
    }
  }

  std::vector<double> recvbufDbs(unifiedNumPos * dimSize);

  // Gather up all states that attain maxima and store then in recvbufDbs
  m_env.inter0Comm().Gatherv((void *) &sendbufDbs[0], (int) subNumDbs, RawValue_MPI_DOUBLE, (void *) &recvbufDbs[0], (int *) &recvcntsDbs[0], (int *) &displsDbs[0], RawValue_MPI_DOUBLE, 0,
                             "BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()",
                             "failed MPI.Gatherv()");

  //******************************************************************
  // Transfer data from 'recvbuf' to 'unifiedPositionsOfMaximum'
  //******************************************************************
  // Copy over all the gathered states to the unifiedPositionsOfMaximum
  // variable on process 0.  Process 0 now contains everything.
  if (m_env.inter0Rank() == (int) 0) {
    for (unsigned int i = 0; i < (unsigned int) unifiedNumPos; ++i) {
      for (unsigned int j = 0; j < dimSize; ++j) {
        tmpVec[j] = recvbufDbs[i*dimSize + j];
      }
      unifiedPositionsOfMaximum.setPositionValues(i,tmpVec);
    }
  }
  else {
    // Process zero has all the states that attain maxima, so let's nuke the
    // others rather than letting them contain NULL pointers
    unifiedPositionsOfMaximum.resizeSequence(0);
  }

  if (m_env.subDisplayFile()) {
    *m_env.subDisplayFile() << "Leaving BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()"
                            << std::endl;
  }

  return unifiedMaxValue;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::unifiedReadContents ( const std::string &  fileName, const std::string &  fileType, const unsigned int  subSequenceSize  )

pure virtual

Reads info of the unified sequence from a file. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >, and QUESO::ArrayOfSequences< V, M >.

Referenced by QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::actualReadSequence(), and QUESO::MetropolisHastingsSG< P_V, P_M >::readFullChain().

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::unifiedSampleVarianceExtra ( unsigned int  initialPos, unsigned int  numPos, const V &  unifiedMeanVec, V &  unifiedSamVec  ) const

pure virtual

Finds the sample variance of the unified sequence, considering numPos positions starting at position initialPos and of mean meanVec. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

Referenced by QUESO::ComputeCovCorrMatricesBetweenVectorSequences().

template<class V , class M >

const V & QUESO::BaseVectorSequence< V, M >::unifiedSampleVariancePlain

(

)

const

Finds the variance of a sample of the unified sequence.

Definition at line 261 of file VectorSequence.C.

{
  if (m_unifiedSampleVariancePlain == NULL) {
    m_unifiedSampleVariancePlain = m_vectorSpace.newVector();
    unifiedSampleVarianceExtra(0,subSequenceSize(),unifiedMeanPlain(),*m_unifiedSampleVariancePlain);
  }

  return *m_unifiedSampleVariancePlain;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::unifiedScalesForKde ( unsigned int  initialPos, const V &  unifiedIqrVec, unsigned int  kdeDimension, V &  unifiedScaleVec  ) const

pure virtual

Selects the scales (bandwidth) for the kernel density estimation, considering the unified sequence. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >.

template<class V , class M >

unsigned int QUESO::BaseVectorSequence< V, M >::unifiedSequenceSize

(

)

const

Calculates the size of the unified sequence of vectors.

TODO: this procedure does not support parallel vectors yet.

Definition at line 70 of file VectorSequence.C.

References RawValue_MPI_SUM, RawValue_MPI_UNSIGNED, and UQ_FATAL_TEST_MACRO.

Referenced by QUESO::MLSampling< P_V, P_M >::checkpointML(), and QUESO::MLSampling< P_V, P_M >::generateSequence_Step02_inter0().

{
  unsigned int unifiedNumSamples = 0;

  bool useOnlyInter0Comm = (m_vectorSpace.numOfProcsForStorage() == 1);

  if (useOnlyInter0Comm) {
    if (m_env.inter0Rank() >= 0) {
      unsigned int subNumSamples = this->subSequenceSize();
      m_env.inter0Comm().Allreduce((void *) &subNumSamples, (void *) &unifiedNumSamples, (int) 1, RawValue_MPI_UNSIGNED, RawValue_MPI_SUM,
                                   "BaseVectorSequence<V,M>::unifiedSequenceSize()",
                                   "failed MPI.Allreduce() for unifiedSequenceSize()");
    }
    else {
      // Node not in the 'inter0' communicator
      unifiedNumSamples = this->subSequenceSize();
    }
  }
  else {
    UQ_FATAL_TEST_MACRO((useOnlyInter0Comm == false),
                        m_env.worldRank(),
                        "BaseVectorSequence<V,M>::unifiedSequenceSize()",
                        "parallel vectors not supported yet");
  }

  return unifiedNumSamples;
}

template<class V, class M>

virtual void QUESO::BaseVectorSequence< V, M >::unifiedWriteContents ( const std::string &  fileName, const std::string &  fileType  ) const

pure virtual

Writes info of the unified sequence to a file. See template specialization.

Implemented in QUESO::SequenceOfVectors< V, M >, and QUESO::ArrayOfSequences< V, M >.

Referenced by QUESO::MetropolisHastingsSG< P_V, P_M >::generateSequence(), and QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::internGenerateSequence().

template<class V , class M >

unsigned int QUESO::BaseVectorSequence< V, M >::vectorSizeGlobal

(

)

const

Global dimension (size) of the vector space.

Definition at line 107 of file VectorSequence.C.

{
  return m_vectorSpace.dimGlobal();
}

template<class V , class M >

unsigned int QUESO::BaseVectorSequence< V, M >::vectorSizeLocal

(

)

const

Local dimension (size) of the vector space.

Definition at line 100 of file VectorSequence.C.

Referenced by QUESO::MonteCarloSG< P_V, P_M, Q_V, Q_M >::generateSequence(), and QUESO::MetropolisHastingsSG< P_V, P_M >::generateSequence().

{
  return m_vectorSpace.dimLocal();
}

template<class V , class M >

const VectorSpace< V, M > & QUESO::BaseVectorSequence< V, M >::vectorSpace

(

)

const

Vector space; access to protected attribute VectorSpace<V,M>& m_vectorSpace.

Definition at line 114 of file VectorSequence.C.

Referenced by QUESO::BaseVectorSequence< V, M >::append(), and QUESO::ComputeCovCorrMatricesBetweenVectorSequences().

{
  return m_vectorSpace;
}

Member Data Documentation

template<class V, class M>

const BaseEnvironment& QUESO::BaseVectorSequence< V, M >::m_env

protected

Definition at line 423 of file VectorSequence.h.

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

template<class V, class M>

Fft<double>* QUESO::BaseVectorSequence< V, M >::m_fftObj

mutableprotected

Definition at line 427 of file VectorSequence.h.

template<class V, class M>

std::string QUESO::BaseVectorSequence< V, M >::m_name

protected

Definition at line 425 of file VectorSequence.h.

Referenced by QUESO::BaseVectorSequence< V, M >::copy().

template<class V, class M>

BoxSubset<V,M>* QUESO::BaseVectorSequence< V, M >::m_subBoxPlain

mutableprotected

Definition at line 438 of file VectorSequence.h.

template<class V, class M>

V* QUESO::BaseVectorSequence< V, M >::m_subMaxPlain

mutableprotected

Definition at line 430 of file VectorSequence.h.

template<class V, class M>

V* QUESO::BaseVectorSequence< V, M >::m_subMeanPlain

mutableprotected

Definition at line 432 of file VectorSequence.h.

template<class V, class M>

V* QUESO::BaseVectorSequence< V, M >::m_subMedianPlain

mutableprotected

Definition at line 434 of file VectorSequence.h.

template<class V, class M>

V* QUESO::BaseVectorSequence< V, M >::m_subMinPlain

mutableprotected

Definition at line 428 of file VectorSequence.h.

template<class V, class M>

V* QUESO::BaseVectorSequence< V, M >::m_subSampleVariancePlain

mutableprotected

Definition at line 436 of file VectorSequence.h.

template<class V, class M>

BoxSubset<V,M>* QUESO::BaseVectorSequence< V, M >::m_unifiedBoxPlain

mutableprotected

Definition at line 439 of file VectorSequence.h.

template<class V, class M>

V* QUESO::BaseVectorSequence< V, M >::m_unifiedMaxPlain

mutableprotected

Definition at line 431 of file VectorSequence.h.

template<class V, class M>

V* QUESO::BaseVectorSequence< V, M >::m_unifiedMeanPlain

mutableprotected

Definition at line 433 of file VectorSequence.h.

template<class V, class M>

V* QUESO::BaseVectorSequence< V, M >::m_unifiedMedianPlain

mutableprotected

Definition at line 435 of file VectorSequence.h.

template<class V, class M>

V* QUESO::BaseVectorSequence< V, M >::m_unifiedMinPlain

mutableprotected

Definition at line 429 of file VectorSequence.h.

template<class V, class M>

V* QUESO::BaseVectorSequence< V, M >::m_unifiedSampleVariancePlain

mutableprotected

Definition at line 437 of file VectorSequence.h.

template<class V, class M>

const VectorSpace<V,M>& QUESO::BaseVectorSequence< V, M >::m_vectorSpace

protected

Definition at line 424 of file VectorSequence.h.

Referenced by QUESO::BaseVectorSequence< V, M >::copy().

---

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

• src/basic/inc/VectorSequence.h
• src/basic/src/VectorSequence.C