queso-0.53.0
Protected Member Functions | Protected Attributes | List of all members
QUESO::BaseVectorSequence< V, M > Class Template Referenceabstract

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

#include <VectorSequence.h>

Inheritance diagram for QUESO::BaseVectorSequence< V, M >:
Inheritance graph
[legend]
Collaboration diagram for QUESO::BaseVectorSequence< V, M >:
Collaboration graph
[legend]

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 = GslVector, class M = GslMatrix>
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 56 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.

38  :
39  m_env (vectorSpace.env()),
40  m_vectorSpace (vectorSpace),
41  m_name (name),
42  m_fftObj (new Fft<double>(m_env)),
43  m_subMinPlain (NULL),
44  m_unifiedMinPlain (NULL),
45  m_subMaxPlain (NULL),
46  m_unifiedMaxPlain (NULL),
47  m_subMeanPlain (NULL),
48  m_unifiedMeanPlain (NULL),
49  m_subMedianPlain (NULL),
50  m_unifiedMedianPlain (NULL),
51  m_subSampleVariancePlain (NULL),
52  m_unifiedSampleVariancePlain(NULL),
53  m_subBoxPlain (NULL),
54  m_unifiedBoxPlain (NULL)
55 {
56  if (subSequenceSize) {}; // just to avoid compiler warning
57 }
QUESO::BaseVectorSequence::m_env
const BaseEnvironment & m_env
Definition: VectorSequence.h:431
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::BaseVectorSequence::m_unifiedBoxPlain
BoxSubset< V, M > * m_unifiedBoxPlain
Definition: VectorSequence.h:447
QUESO::BaseVectorSequence::m_subBoxPlain
BoxSubset< V, M > * m_subBoxPlain
Definition: VectorSequence.h:446
QUESO::BaseVectorSequence::vectorSpace
const VectorSpace< V, M > & vectorSpace() const
Vector space; access to protected attribute VectorSpace&lt;V,M&gt;&amp; m_vectorSpace.
Definition: VectorSequence.C:111
QUESO::BaseVectorSequence::name
const std::string & name() const
Access to protected attribute m_name: name of the sequence of vectors.
Definition: VectorSequence.C:118
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
template<class V , class M >
QUESO::BaseVectorSequence< V, M >::~BaseVectorSequence ( )
virtual

Destructor.

Definition at line 60 of file VectorSequence.C.

61 {
62  //clear();
63  this->deleteStoredVectors();
64  if (m_fftObj != NULL) delete m_fftObj;
65 }
QUESO::BaseVectorSequence::deleteStoredVectors
void deleteStoredVectors()
Deletes all the stored vectors.
Definition: VectorSequence.C:298

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 354 of file VectorSequence.C.

References QUESO::BaseVectorSequence< V, M >::getPositionValues(), queso_require_greater_equal_msg, QUESO::BaseVectorSequence< V, M >::subSequenceSize(), 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().

358 {
359  queso_require_greater_equal_msg(src.subSequenceSize(), (initialPos+1), "initialPos is too big");
360 
361  queso_require_greater_equal_msg(src.subSequenceSize(), (initialPos+numPos), "numPos is too big");
362 
363  this->deleteStoredVectors();
364  unsigned int currentSize = this->subSequenceSize();
365  this->resizeSequence(currentSize+numPos);
366  V tmpVec(src.vectorSpace().zeroVector());
367  for (unsigned int i = 0; i < numPos; ++i) {
368  src.getPositionValues(initialPos+i,tmpVec);
369  this->setPositionValues(currentSize+i,tmpVec);
370  }
371 
372  return;
373 }
QUESO::BaseVectorSequence::deleteStoredVectors
void deleteStoredVectors()
Deletes all the stored vectors.
Definition: VectorSequence.C:298
QUESO::BaseVectorSequence::resizeSequence
virtual void resizeSequence(unsigned int newSubSequenceSize)=0
Resize the sequence. See template specialization.
queso_require_greater_equal_msg
#define queso_require_greater_equal_msg(expr1, expr2, msg)
Definition: asserts.h:90
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
QUESO::BaseVectorSequence::setPositionValues
virtual void setPositionValues(unsigned int posId, const V &vec)=0
Set the values in vec at position posId of the sequence. See template specialization.
template<class V = GslVector, class M = GslMatrix>
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 = GslVector, class M = GslMatrix>
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 = GslVector, class M = GslMatrix>
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 = GslVector, class M = GslMatrix>
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 133 of file VectorSequence.C.

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

134 {
135  unsigned int numPos = this->subSequenceSize();
136  if (numPos) {
137  this->resetValues(0,numPos);
138  this->resizeSequence(0);
139  }
140 
141  return;
142 }
QUESO::BaseVectorSequence::resetValues
virtual void resetValues(unsigned int initialPos, unsigned int numPos)=0
Reset the values of the sequence. See template specialization.
QUESO::BaseVectorSequence::resizeSequence
virtual void resizeSequence(unsigned int newSubSequenceSize)=0
Resize the sequence. See template specialization.
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
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 614 of file VectorSequence.C.

References queso_require_msg.

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().

618 {
619  if (m_env.subDisplayFile()) {
620  *m_env.subDisplayFile() << "\n"
621  << "\n-----------------------------------------------------"
622  << "\n Computing filter parameters for chain '" << m_name << "' ..."
623  << "\n-----------------------------------------------------"
624  << "\n"
625  << std::endl;
626  }
627 
628  bool okSituation = ((passedOfs == NULL ) ||
629  ((passedOfs != NULL) && (m_env.subRank() >= 0)));
630  queso_require_msg(!(!okSituation), "unexpected combination of file pointer and subRank");
631 
632  //initialPos = 0;
633  spacing = 1;
634 
635  if (m_env.subDisplayFile()) {
636  *m_env.subDisplayFile() << "\n-----------------------------------------------------"
637  << "\n Finished computing filter parameters for chain '" << m_name << "'"
638  << ": initialPos = " << initialPos
639  << ", spacing = " << spacing
640  << "\n-----------------------------------------------------"
641  << "\n"
642  << std::endl;
643  }
644 
645  return;
646 }
QUESO::BaseVectorSequence::m_env
const BaseEnvironment & m_env
Definition: VectorSequence.h:431
QUESO::BaseEnvironment::subRank
int subRank() const
Access function for sub-rank.
Definition: Environment.C:241
queso_require_msg
#define queso_require_msg(asserted, msg)
Definition: asserts.h:69
QUESO::BaseEnvironment::subDisplayFile
std::ofstream * subDisplayFile() const
Access function for m_subDisplayFile (displays file on stream).
Definition: Environment.C:274
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 651 of file VectorSequence.C.

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

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

652 {
653  // FIX ME: should check environments as well ???
654 
655  queso_require_equal_to_msg(m_vectorSpace.dimLocal(), src.m_vectorSpace.dimLocal(), "incompatible vector space dimensions");
656 
657  m_name = src.m_name;
658  this->deleteStoredVectors();
659 
660  return;
661 }
QUESO::BaseVectorSequence::deleteStoredVectors
void deleteStoredVectors()
Deletes all the stored vectors.
Definition: VectorSequence.C:298
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
queso_require_equal_to_msg
#define queso_require_equal_to_msg(expr1, expr2, msg)
Definition: asserts.h:85
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 298 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().

299 {
300  if (m_subMinPlain) {
301  delete m_subMinPlain;
302  m_subMinPlain = NULL;
303  }
304  if (m_unifiedMinPlain) {
305  delete m_unifiedMinPlain;
306  m_unifiedMinPlain = NULL;
307  }
308  if (m_subMaxPlain) {
309  delete m_subMaxPlain;
310  m_subMaxPlain = NULL;
311  }
312  if (m_unifiedMaxPlain) {
313  delete m_unifiedMaxPlain;
314  m_unifiedMaxPlain = NULL;
315  }
316  if (m_subMeanPlain) {
317  delete m_subMeanPlain;
318  m_subMeanPlain = NULL;
319  }
320  if (m_unifiedMeanPlain) {
321  delete m_unifiedMeanPlain;
322  m_unifiedMeanPlain = NULL;
323  }
324  if (m_subMedianPlain) {
325  delete m_subMedianPlain;
326  m_subMedianPlain = NULL;
327  }
328  if (m_unifiedMedianPlain) {
329  delete m_unifiedMedianPlain;
330  m_unifiedMedianPlain = NULL;
331  }
332  if (m_subSampleVariancePlain) {
333  delete m_subSampleVariancePlain;
334  m_subSampleVariancePlain = NULL;
335  }
336  if (m_unifiedSampleVariancePlain) {
337  delete m_unifiedSampleVariancePlain;
338  m_unifiedSampleVariancePlain = NULL;
339  }
340  if (m_subBoxPlain) {
341  delete m_subBoxPlain;
342  m_subBoxPlain = NULL;
343  }
344  if (m_unifiedBoxPlain) {
345  delete m_unifiedBoxPlain;
346  m_unifiedBoxPlain = NULL;
347  }
348 
349  return;
350 }
QUESO::BaseVectorSequence::m_unifiedBoxPlain
BoxSubset< V, M > * m_unifiedBoxPlain
Definition: VectorSequence.h:447
QUESO::BaseVectorSequence::m_subBoxPlain
BoxSubset< V, M > * m_subBoxPlain
Definition: VectorSequence.h:446
template<class V = GslVector, class M = GslMatrix>
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 >, QUESO::SequenceOfVectors< S_V, S_M >, QUESO::SequenceOfVectors< P_V, P_M >, QUESO::SequenceOfVectors< Q_V, Q_M >, and QUESO::ArrayOfSequences< V, M >.

template<class V = GslVector, class M = GslMatrix>
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 >, QUESO::SequenceOfVectors< S_V, S_M >, QUESO::SequenceOfVectors< P_V, P_M >, and QUESO::SequenceOfVectors< Q_V, Q_M >.

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

template<class V = GslVector, class M = GslMatrix>
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 >, QUESO::SequenceOfVectors< S_V, S_M >, QUESO::SequenceOfVectors< P_V, P_M >, QUESO::SequenceOfVectors< Q_V, Q_M >, and QUESO::ArrayOfSequences< V, M >.

template<class V = GslVector, class M = GslMatrix>
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 >, QUESO::SequenceOfVectors< S_V, S_M >, QUESO::SequenceOfVectors< P_V, P_M >, QUESO::SequenceOfVectors< Q_V, Q_M >, and QUESO::ArrayOfSequences< V, M >.

template<class V = GslVector, class M = GslMatrix>
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 >, QUESO::SequenceOfVectors< S_V, S_M >, QUESO::SequenceOfVectors< P_V, P_M >, QUESO::SequenceOfVectors< Q_V, Q_M >, and QUESO::ArrayOfSequences< V, M >.

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

template<class V = GslVector, class M = GslMatrix>
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::MetropolisHastingsSG< P_V, P_M >::adapt(), QUESO::BaseVectorSequence< V, M >::append(), QUESO::ComputeCovCorrMatricesBetweenVectorSequences(), 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 118 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().

119 {
120  return m_name;
121 }
template<class V = GslVector, class M = GslMatrix>
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 >, QUESO::SequenceOfVectors< S_V, S_M >, QUESO::SequenceOfVectors< P_V, P_M >, QUESO::SequenceOfVectors< Q_V, Q_M >, and QUESO::ArrayOfSequences< V, M >.

template<class V = GslVector, class M = GslMatrix>
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 >, QUESO::SequenceOfVectors< S_V, S_M >, QUESO::SequenceOfVectors< P_V, P_M >, QUESO::SequenceOfVectors< Q_V, Q_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 = GslVector, class M = GslMatrix>
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 >, QUESO::SequenceOfVectors< S_V, S_M >, QUESO::SequenceOfVectors< P_V, P_M >, QUESO::SequenceOfVectors< Q_V, Q_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 584 of file VectorSequence.C.

585 {
586  V gaussianVector(m_vectorSpace.zeroVector());
587  for (unsigned int j = 0; j < this->subSequenceSize(); ++j) {
588  gaussianVector.cwSetGaussian(meanVec,stdDevVec);
589  this->setPositionValues(j,gaussianVector);
590  }
591 
592  this->deleteStoredVectors();
593 
594  return;
595 }
QUESO::BaseVectorSequence::deleteStoredVectors
void deleteStoredVectors()
Deletes all the stored vectors.
Definition: VectorSequence.C:298
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
QUESO::BaseVectorSequence::setPositionValues
virtual void setPositionValues(unsigned int posId, const V &vec)=0
Set the values in vec at position posId of the sequence. See template specialization.
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 125 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().

126 {
127  m_name = newName;
128  return;
129 }
template<class V = GslVector, class M = GslMatrix>
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 599 of file VectorSequence.C.

600 {
601  V uniformVector(m_vectorSpace.zeroVector());
602  for (unsigned int j = 0; j < this->subSequenceSize(); ++j) {
603  uniformVector.cwSetUniform(aVec,bVec);
604  this->setPositionValues(j,uniformVector);
605  }
606 
607  this->deleteStoredVectors();
608 
609  return;
610 }
QUESO::BaseVectorSequence::deleteStoredVectors
void deleteStoredVectors()
Deletes all the stored vectors.
Definition: VectorSequence.C:298
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
QUESO::BaseVectorSequence::setPositionValues
virtual void setPositionValues(unsigned int posId, const V &vec)=0
Set the values in vec at position posId of the sequence. See template specialization.
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 270 of file VectorSequence.C.

271 {
272  if (m_subBoxPlain == NULL) {
273  m_subBoxPlain = new BoxSubset<V,M>(m_name.c_str(),
274  m_vectorSpace,
275  this->subMinPlain(),
276  this->subMaxPlain());
277  }
278 
279  return *m_subBoxPlain;
280 }
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::BaseVectorSequence::subMaxPlain
const V & subMaxPlain() const
Finds the maximum value of the sub-sequence.
Definition: VectorSequence.C:172
QUESO::BaseVectorSequence::m_subBoxPlain
BoxSubset< V, M > * m_subBoxPlain
Definition: VectorSequence.h:446
QUESO::BaseVectorSequence::subMinPlain
const V & subMinPlain() const
Finds the minimum value of the sub-sequence.
Definition: VectorSequence.C:146
template<class V = GslVector, class M = GslMatrix>
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 = GslVector, class M = GslMatrix>
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 = GslVector, class M = GslMatrix>
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 172 of file VectorSequence.C.

Referenced by QUESO::SimulationModel< S_V, S_M, P_V, P_M, Q_V, Q_M >::SimulationModel().

173 {
174  if (m_subMaxPlain == NULL) {
175  if (m_subMinPlain == NULL) m_subMinPlain = m_vectorSpace.newVector();
176  m_subMaxPlain = m_vectorSpace.newVector();
177  subMinMaxExtra(0,this->subSequenceSize(),*m_subMinPlain,*m_subMaxPlain);
178  }
179 
180  return *m_subMaxPlain;
181 }
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::BaseVectorSequence::subMinMaxExtra
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 a...
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
template<class V = GslVector, class M = GslMatrix>
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 198 of file VectorSequence.C.

Referenced by QUESO::SimulationModel< S_V, S_M, P_V, P_M, Q_V, Q_M >::SimulationModel(), and QUESO::MetropolisHastingsSG< P_V, P_M >::updateAdaptedCovMatrix().

199 {
200  if (m_subMeanPlain == NULL) {
201  m_subMeanPlain = m_vectorSpace.newVector();
202  subMeanExtra(0,subSequenceSize(),*m_subMeanPlain);
203  }
204 
205  return *m_subMeanPlain;
206 }
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::BaseVectorSequence::subMeanExtra
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 initialPo...
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
template<class V = GslVector, class M = GslMatrix>
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 222 of file VectorSequence.C.

223 {
224  if (m_subMedianPlain == NULL) {
225  m_subMedianPlain = m_vectorSpace.newVector();
226  subMedianExtra(0, subSequenceSize(), *m_subMedianPlain);
227  }
228 
229  return *m_subMedianPlain;
230 }
QUESO::BaseVectorSequence::subMedianExtra
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 initial...
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
template<class V = GslVector, class M = GslMatrix>
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 146 of file VectorSequence.C.

Referenced by QUESO::SimulationModel< S_V, S_M, P_V, P_M, Q_V, Q_M >::SimulationModel().

147 {
148  if (m_subMinPlain == NULL) {
149  m_subMinPlain = m_vectorSpace.newVector();
150  if (m_subMaxPlain == NULL) m_subMaxPlain = m_vectorSpace.newVector();
151  subMinMaxExtra(0,this->subSequenceSize(),*m_subMinPlain,*m_subMaxPlain);
152  }
153 
154  return *m_subMinPlain;
155 }
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::BaseVectorSequence::subMinMaxExtra
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 a...
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
template<class V = GslVector, class M = GslMatrix>
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 377 of file VectorSequence.C.

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

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

380 {
381  if (m_env.subDisplayFile()) {
382  *m_env.subDisplayFile() << "Entering BaseVectorSequence<V,M>::subPositionsOfMaximum()"
383  << ": subCorrespondingScalarValues,subSequenceSize() = " << subCorrespondingScalarValues.subSequenceSize()
384  << ", this->subSequenceSize = " << this->subSequenceSize()
385  << std::endl;
386  }
387 
388  queso_require_equal_to_msg(subCorrespondingScalarValues.subSequenceSize(), this->subSequenceSize(), "invalid input");
389 
390  double subMaxValue = subCorrespondingScalarValues.subMaxPlain();
391  unsigned int iMax = subCorrespondingScalarValues.subSequenceSize();
392 
393  unsigned int subNumPos = 0;
394  for (unsigned int i = 0; i < iMax; ++i) {
395  if (subCorrespondingScalarValues[i] == subMaxValue) {
396  subNumPos++;
397  }
398  }
399 
400  V tmpVec(this->vectorSpace().zeroVector());
401  subPositionsOfMaximum.resizeSequence(subNumPos);
402  unsigned int j = 0;
403  for (unsigned int i = 0; i < iMax; ++i) {
404  if (subCorrespondingScalarValues[i] == subMaxValue) {
405  this->getPositionValues (i,tmpVec);
406  subPositionsOfMaximum.setPositionValues(j,tmpVec);
407  j++;
408  }
409  }
410 
411  if (m_env.subDisplayFile()) {
412  *m_env.subDisplayFile() << "Leaving BaseVectorSequence<V,M>::subPositionsOfMaximum()"
413  << std::endl;
414  }
415 
416  return subMaxValue;
417 }
QUESO::BaseVectorSequence::m_env
const BaseEnvironment & m_env
Definition: VectorSequence.h:431
QUESO::BaseVectorSequence::subPositionsOfMaximum
double subPositionsOfMaximum(const ScalarSequence< double > &subCorrespondingScalarValues, BaseVectorSequence< V, M > &subPositionsOfMaximum)
Finds the positions where the maximum element occurs in the sub-sequence.
Definition: VectorSequence.C:377
QUESO::ScalarSequence::subMaxPlain
const T & subMaxPlain() const
Finds the maximum value of the sub-sequence of scalars.
Definition: ScalarSequence.C:367
queso_require_equal_to_msg
#define queso_require_equal_to_msg(expr1, expr2, msg)
Definition: asserts.h:85
QUESO::BaseVectorSequence::vectorSpace
const VectorSpace< V, M > & vectorSpace() const
Vector space; access to protected attribute VectorSpace&lt;V,M&gt;&amp; m_vectorSpace.
Definition: VectorSequence.C:111
QUESO::BaseEnvironment::subDisplayFile
std::ofstream * subDisplayFile() const
Access function for m_subDisplayFile (displays file on stream).
Definition: Environment.C:274
QUESO::BaseVectorSequence::getPositionValues
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...
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
QUESO::ScalarSequence::subSequenceSize
unsigned int subSequenceSize() const
Size of the sub-sequence of scalars.
Definition: ScalarSequence.C:136
template<class V = GslVector, class M = GslMatrix>
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 246 of file VectorSequence.C.

247 {
248  if (m_subSampleVariancePlain == NULL) {
249  m_subSampleVariancePlain = m_vectorSpace.newVector();
250  subSampleVarianceExtra(0,subSequenceSize(),subMeanPlain(),*m_subSampleVariancePlain);
251  }
252 
253  return *m_subSampleVariancePlain;
254 }
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::BaseVectorSequence::subSampleVarianceExtra
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 init...
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
QUESO::BaseVectorSequence::subMeanPlain
const V & subMeanPlain() const
Finds the mean value of the sub-sequence.
Definition: VectorSequence.C:198
template<class V = GslVector, class M = GslMatrix>
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 = GslVector, class M = GslMatrix>
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 >, QUESO::SequenceOfVectors< S_V, S_M >, QUESO::SequenceOfVectors< P_V, P_M >, QUESO::SequenceOfVectors< Q_V, Q_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 = GslVector, class M = GslMatrix>
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 >, QUESO::SequenceOfVectors< S_V, S_M >, QUESO::SequenceOfVectors< P_V, P_M >, and QUESO::SequenceOfVectors< Q_V, Q_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 = GslVector, class M = GslMatrix>
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 >, QUESO::SequenceOfVectors< S_V, S_M >, QUESO::SequenceOfVectors< P_V, P_M >, and QUESO::SequenceOfVectors< Q_V, Q_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 284 of file VectorSequence.C.

285 {
286  if (m_unifiedBoxPlain == NULL) {
287  m_unifiedBoxPlain = new BoxSubset<V,M>(m_name.c_str(),
288  m_vectorSpace,
289  this->unifiedMinPlain(),
290  this->unifiedMaxPlain());
291  }
292 
293  return *m_unifiedBoxPlain;
294 }
QUESO::BaseVectorSequence::unifiedMaxPlain
const V & unifiedMaxPlain() const
Finds the maximum value of the unified sequence.
Definition: VectorSequence.C:185
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::BaseVectorSequence::m_unifiedBoxPlain
BoxSubset< V, M > * m_unifiedBoxPlain
Definition: VectorSequence.h:447
QUESO::BaseVectorSequence::unifiedMinPlain
const V & unifiedMinPlain() const
Finds the minimum value of the unified sequence.
Definition: VectorSequence.C:159
template<class V = GslVector, class M = GslMatrix>
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 = GslVector, class M = GslMatrix>
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 = GslVector, class M = GslMatrix>
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 185 of file VectorSequence.C.

186 {
187  if (m_unifiedMaxPlain == NULL) {
188  if (m_unifiedMinPlain == NULL) m_unifiedMinPlain = m_vectorSpace.newVector();
189  m_unifiedMaxPlain = m_vectorSpace.newVector();
190  unifiedMinMaxExtra(0,this->subSequenceSize(),*m_unifiedMinPlain,*m_unifiedMaxPlain);
191  }
192 
193  return *m_unifiedMaxPlain;
194 }
QUESO::BaseVectorSequence::unifiedMinMaxExtra
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 starti...
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
template<class V = GslVector, class M = GslMatrix>
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 210 of file VectorSequence.C.

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().

211 {
212  if (m_unifiedMeanPlain == NULL) {
213  m_unifiedMeanPlain = m_vectorSpace.newVector();
214  unifiedMeanExtra(0,subSequenceSize(),*m_unifiedMeanPlain);
215  }
216 
217  return *m_unifiedMeanPlain;
218 }
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::BaseVectorSequence::unifiedMeanExtra
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...
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
template<class V = GslVector, class M = GslMatrix>
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 234 of file VectorSequence.C.

235 {
236  if (m_unifiedMedianPlain == NULL) {
237  m_unifiedMedianPlain = m_vectorSpace.newVector();
238  unifiedMedianExtra(0, subSequenceSize(), *m_unifiedMedianPlain);
239  }
240 
241  return *m_unifiedMedianPlain;
242 }
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::BaseVectorSequence::unifiedMedianExtra
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 ini...
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
template<class V = GslVector, class M = GslMatrix>
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 159 of file VectorSequence.C.

160 {
161  if (m_unifiedMinPlain == NULL) {
162  m_unifiedMinPlain = m_vectorSpace.newVector();
163  if (m_unifiedMaxPlain == NULL) m_unifiedMaxPlain = m_vectorSpace.newVector();
164  unifiedMinMaxExtra(0,this->subSequenceSize(),*m_unifiedMinPlain,*m_unifiedMaxPlain);
165  }
166 
167  return *m_unifiedMinPlain;
168 }
QUESO::BaseVectorSequence::unifiedMinMaxExtra
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 starti...
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
template<class V = GslVector, class M = GslMatrix>
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
thisThe underlying sequence of vectors
subCorrespondingScalarValuesFor a given process, a scalar sequence where element i corresponds to element i of this.
unifiedPositionsOfMaximumUpon 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 421 of file VectorSequence.C.

References QUESO::BaseVectorSequence< V, M >::getPositionValues(), queso_require_equal_to_msg, 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(), and QUESO::ScalarSequence< T >::subSequenceSize().

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

424 {
425  if (m_env.subDisplayFile()) {
426  *m_env.subDisplayFile() << "Entering BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()"
427  << ": subCorrespondingScalarValues,subSequenceSize() = " << subCorrespondingScalarValues.subSequenceSize()
428  << ", this->subSequenceSize = " << this->subSequenceSize()
429  << std::endl;
430  }
431 
432  queso_require_equal_to_msg(subCorrespondingScalarValues.subSequenceSize(), this->subSequenceSize(), "invalid input");
433 
434  // Compute the max on each process
435  double subMaxValue = subCorrespondingScalarValues.subMaxPlain();
436 
437  //******************************************************************
438  // Get overall max
439  //******************************************************************
440  double unifiedMaxValue;
441  std::vector<double> sendbufPos(1,0.);
442  for (unsigned int i = 0; i < sendbufPos.size(); ++i) {
443  sendbufPos[i] = subMaxValue;
444  }
445  m_env.inter0Comm().Allreduce((void *) &sendbufPos[0], (void *) &unifiedMaxValue, (int) sendbufPos.size(), RawValue_MPI_DOUBLE, RawValue_MPI_MAX,
446  "BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()",
447  "failed MPI.Allreduce() for max");
448 
449  // Find number of elements (subNumPos) on each process that attain the
450  // global max. This could be zero.
451  unsigned int iMax = subCorrespondingScalarValues.subSequenceSize();
452  int subNumPos = 0; // Yes, 'int', due to MPI to be used soon
453  for (unsigned int i = 0; i < iMax; ++i) {
454  if (subCorrespondingScalarValues[i] == unifiedMaxValue) {
455  subNumPos++;
456  }
457  }
458 
459  // Fill up unifiedPositionsOfMaximum with the states that attain maxima
460  // (if they exist)
461  V tmpVec(this->vectorSpace().zeroVector());
462  unifiedPositionsOfMaximum.resizeSequence(subNumPos); // subNumPos could be 0
463  unsigned int j = 0;
464  for (unsigned int i = 0; i < iMax; ++i) {
465  // This 'if' statement is false if subNumPos == 0
466  if (subCorrespondingScalarValues[i] == unifiedMaxValue) {
467  this->getPositionValues (i,tmpVec);
468  unifiedPositionsOfMaximum.setPositionValues(j,tmpVec);
469  j++;
470  }
471  }
472 
473  // Compute total (over all processes) number of elements that attain maxima
474  std::vector<int> auxBuf(1,0);
475  int unifiedNumPos = 0; // Yes, 'int', due to MPI to be used soon
476  auxBuf[0] = subNumPos;
477  m_env.inter0Comm().Allreduce((void *) &auxBuf[0], (void *) &unifiedNumPos, (int) auxBuf.size(), RawValue_MPI_INT, RawValue_MPI_SUM,
478  "BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()",
479  "failed MPI.Allreduce() for sum");
480 
481  // Resize positions to hold all elements that attain maxima
482  unifiedPositionsOfMaximum.resizeSequence(unifiedNumPos);
483 
484  //******************************************************************
485  // Use MPI_Gatherv for number of positions
486  //******************************************************************
487  // Gather up *number* of maxima on each chain and store in recvcntsPos
488  unsigned int Np = (unsigned int) m_env.inter0Comm().NumProc();
489 
490  std::vector<int> recvcntsPos(Np,0); // '0' is NOT the correct value for recvcntsPos[0]
491  m_env.inter0Comm().Gather((void *) &subNumPos, 1, RawValue_MPI_INT, (void *) &recvcntsPos[0], (int) 1, RawValue_MPI_INT, 0,
492  "BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()",
493  "failed MPI.Gatherv()");
494  if (m_env.inter0Rank() == 0) {
495  queso_require_equal_to_msg(recvcntsPos[0], (int) subNumPos, "failed MPI.Gather() result at proc 0 (recvcntsPos[0])");
496  }
497 
498  // Construct offset indices based on number of maxima
499  std::vector<int> displsPos(Np,0);
500  for (unsigned int nodeId = 1; nodeId < Np; ++nodeId) { // Yes, from '1' on
501  displsPos[nodeId] = displsPos[nodeId-1] + recvcntsPos[nodeId-1];
502  }
503  if (m_env.inter0Rank() == 0) {
504  queso_require_equal_to_msg(unifiedNumPos, (displsPos[Np - 1] + recvcntsPos[Np - 1]), "failed MPI.Gather() result at proc 0 (unifiedNumPos)");
505  }
506 
507  //******************************************************************
508  // Use MPI_Gatherv for number of doubles
509  //******************************************************************
510  // Gather up number of states that attain maxima multiplied by the size of
511  // the state (on each process). Store this in recvcntsDbs.
512  // So recvcntsDbs[i] is the number of states that attain maxima on chain i
513  // multiplied by the size of the state (a state could be a vector of length
514  // > 1).
515  unsigned int dimSize = m_vectorSpace.dimLocal();
516  int subNumDbs = subNumPos * dimSize; // Yes, 'int', due to MPI to be used soon
517  std::vector<int> recvcntsDbs(Np,0); // '0' is NOT the correct value for recvcntsDbs[0]
518  m_env.inter0Comm().Gather((void *) &subNumDbs, 1, RawValue_MPI_INT, (void *) &recvcntsDbs[0], (int) 1, RawValue_MPI_INT, 0,
519  "BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()",
520  "failed MPI.Gatherv()");
521  if (m_env.inter0Rank() == 0) {
522  queso_require_equal_to_msg(recvcntsDbs[0], (int) subNumDbs, "failed MPI.Gather() result at proc 0 (recvcntsDbs[0])");
523  }
524 
525  // Now gather up the offsets based on the number of states (mulitplied by the
526  // size of the state)
527  std::vector<int> displsDbs(Np,0);
528  for (unsigned int nodeId = 1; nodeId < Np; ++nodeId) { // Yes, from '1' on
529  displsDbs[nodeId] = displsDbs[nodeId-1] + recvcntsDbs[nodeId-1];
530  }
531  if (m_env.inter0Rank() == 0) {
532  queso_require_equal_to_msg(((int) (unifiedNumPos*dimSize)), (displsDbs[Np - 1] + recvcntsDbs[Np - 1]), "failed MPI.Gather() result at proc 0 (unifiedNumPos*dimSize)");
533  }
534 
535  //******************************************************************
536  // Prepare counters and buffers for gatherv of maximum positions
537  //******************************************************************
538  // Take all the states on all chains that attain maxima, and put them in a
539  // send buffer ready for MPI
540  std::vector<double> sendbufDbs(subNumDbs,0.);
541  for (unsigned int i = 0; i < (unsigned int) subNumPos; ++i) {
542  unifiedPositionsOfMaximum.getPositionValues(i,tmpVec);
543  for (unsigned int j = 0; j < dimSize; ++j) {
544  sendbufDbs[i*dimSize + j] = tmpVec[j];
545  }
546  }
547 
548  std::vector<double> recvbufDbs(unifiedNumPos * dimSize);
549 
550  // Gather up all states that attain maxima and store then in recvbufDbs
551  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,
552  "BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()",
553  "failed MPI.Gatherv()");
554 
555  //******************************************************************
556  // Transfer data from 'recvbuf' to 'unifiedPositionsOfMaximum'
557  //******************************************************************
558  // Copy over all the gathered states to the unifiedPositionsOfMaximum
559  // variable on process 0. Process 0 now contains everything.
560  if (m_env.inter0Rank() == (int) 0) {
561  for (unsigned int i = 0; i < (unsigned int) unifiedNumPos; ++i) {
562  for (unsigned int j = 0; j < dimSize; ++j) {
563  tmpVec[j] = recvbufDbs[i*dimSize + j];
564  }
565  unifiedPositionsOfMaximum.setPositionValues(i,tmpVec);
566  }
567  }
568  else {
569  // Process zero has all the states that attain maxima, so let's nuke the
570  // others rather than letting them contain NULL pointers
571  unifiedPositionsOfMaximum.resizeSequence(0);
572  }
573 
574  if (m_env.subDisplayFile()) {
575  *m_env.subDisplayFile() << "Leaving BaseVectorSequence<V,M>::unifiedPositionsOfMaximum()"
576  << std::endl;
577  }
578 
579  return unifiedMaxValue;
580 }
RawValue_MPI_SUM
#define RawValue_MPI_SUM
Definition: MpiComm.h:52
QUESO::BaseVectorSequence::m_env
const BaseEnvironment & m_env
Definition: VectorSequence.h:431
QUESO::BaseVectorSequence::unifiedPositionsOfMaximum
double unifiedPositionsOfMaximum(const ScalarSequence< double > &subCorrespondingScalarValues, BaseVectorSequence< V, M > &unifiedPositionsOfMaximum)
Finds the positions where the maximum element occurs in the unified sequence.
Definition: VectorSequence.C:421
QUESO::MpiComm::NumProc
int NumProc() const
Returns total number of processes.
Definition: MpiComm.C:103
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::ScalarSequence::subMaxPlain
const T & subMaxPlain() const
Finds the maximum value of the sub-sequence of scalars.
Definition: ScalarSequence.C:367
QUESO::BaseEnvironment::inter0Rank
int inter0Rank() const
Returns the process inter0 rank.
Definition: Environment.C:261
queso_require_equal_to_msg
#define queso_require_equal_to_msg(expr1, expr2, msg)
Definition: asserts.h:85
QUESO::BaseVectorSequence::vectorSpace
const VectorSpace< V, M > & vectorSpace() const
Vector space; access to protected attribute VectorSpace&lt;V,M&gt;&amp; m_vectorSpace.
Definition: VectorSequence.C:111
QUESO::BaseEnvironment::subDisplayFile
std::ofstream * subDisplayFile() const
Access function for m_subDisplayFile (displays file on stream).
Definition: Environment.C:274
QUESO::MpiComm::Gatherv
void Gatherv(void *sendbuf, int sendcnt, RawType_MPI_Datatype sendtype, void *recvbuf, int *recvcnts, int *displs, RawType_MPI_Datatype recvtype, int root, const char *whereMsg, const char *whatMsg) const
Gathers into specified locations from all processes in a group.
Definition: MpiComm.C:158
RawValue_MPI_INT
#define RawValue_MPI_INT
Definition: MpiComm.h:47
RawValue_MPI_MAX
#define RawValue_MPI_MAX
Definition: MpiComm.h:51
QUESO::BaseEnvironment::inter0Comm
const MpiComm & inter0Comm() const
Access function for MpiComm inter0-communicator.
Definition: Environment.C:267
QUESO::BaseVectorSequence::getPositionValues
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...
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
QUESO::ScalarSequence::subSequenceSize
unsigned int subSequenceSize() const
Size of the sub-sequence of scalars.
Definition: ScalarSequence.C:136
QUESO::MpiComm::Gather
void Gather(void *sendbuf, int sendcnt, RawType_MPI_Datatype sendtype, void *recvbuf, int recvcount, RawType_MPI_Datatype recvtype, int root, const char *whereMsg, const char *whatMsg) const
Gather values from each process to collect on all processes.
Definition: MpiComm.C:141
RawValue_MPI_DOUBLE
#define RawValue_MPI_DOUBLE
Definition: MpiComm.h:48
QUESO::MpiComm::Allreduce
void Allreduce(void *sendbuf, void *recvbuf, int count, RawType_MPI_Datatype datatype, RawType_MPI_Op op, const char *whereMsg, const char *whatMsg) const
Combines values from all processes and distributes the result back to all processes.
Definition: MpiComm.C:113
template<class V = GslVector, class M = GslMatrix>
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 >, QUESO::SequenceOfVectors< S_V, S_M >, QUESO::SequenceOfVectors< P_V, P_M >, QUESO::SequenceOfVectors< Q_V, Q_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 = GslVector, class M = GslMatrix>
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 258 of file VectorSequence.C.

259 {
260  if (m_unifiedSampleVariancePlain == NULL) {
261  m_unifiedSampleVariancePlain = m_vectorSpace.newVector();
262  unifiedSampleVarianceExtra(0,subSequenceSize(),unifiedMeanPlain(),*m_unifiedSampleVariancePlain);
263  }
264 
265  return *m_unifiedSampleVariancePlain;
266 }
QUESO::BaseVectorSequence::unifiedMeanPlain
const V & unifiedMeanPlain() const
Finds the mean value of the unified sequence.
Definition: VectorSequence.C:210
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::BaseVectorSequence::unifiedSampleVarianceExtra
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 ...
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
template<class V = GslVector, class M = GslMatrix>
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 queso_require_msg, RawValue_MPI_SUM, and RawValue_MPI_UNSIGNED.

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

71 {
72  unsigned int unifiedNumSamples = 0;
73 
74  bool useOnlyInter0Comm = (m_vectorSpace.numOfProcsForStorage() == 1);
75 
76  if (useOnlyInter0Comm) {
77  if (m_env.inter0Rank() >= 0) {
78  unsigned int subNumSamples = this->subSequenceSize();
79  m_env.inter0Comm().Allreduce((void *) &subNumSamples, (void *) &unifiedNumSamples, (int) 1, RawValue_MPI_UNSIGNED, RawValue_MPI_SUM,
80  "BaseVectorSequence<V,M>::unifiedSequenceSize()",
81  "failed MPI.Allreduce() for unifiedSequenceSize()");
82  }
83  else {
84  // Node not in the 'inter0' communicator
85  unifiedNumSamples = this->subSequenceSize();
86  }
87  }
88  else {
89  queso_require_msg(useOnlyInter0Comm, "parallel vectors not supported yet");
90  }
91 
92  return unifiedNumSamples;
93 }
RawValue_MPI_SUM
#define RawValue_MPI_SUM
Definition: MpiComm.h:52
QUESO::BaseVectorSequence::m_env
const BaseEnvironment & m_env
Definition: VectorSequence.h:431
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
QUESO::BaseEnvironment::inter0Rank
int inter0Rank() const
Returns the process inter0 rank.
Definition: Environment.C:261
queso_require_msg
#define queso_require_msg(asserted, msg)
Definition: asserts.h:69
QUESO::BaseEnvironment::inter0Comm
const MpiComm & inter0Comm() const
Access function for MpiComm inter0-communicator.
Definition: Environment.C:267
QUESO::BaseVectorSequence::subSequenceSize
virtual unsigned int subSequenceSize() const =0
Size of the sub-sequence of vectors. See template specialization.
QUESO::MpiComm::Allreduce
void Allreduce(void *sendbuf, void *recvbuf, int count, RawType_MPI_Datatype datatype, RawType_MPI_Op op, const char *whereMsg, const char *whatMsg) const
Combines values from all processes and distributes the result back to all processes.
Definition: MpiComm.C:113
RawValue_MPI_UNSIGNED
#define RawValue_MPI_UNSIGNED
Definition: MpiComm.h:49
template<class V = GslVector, class M = GslMatrix>
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 >, QUESO::SequenceOfVectors< S_V, S_M >, QUESO::SequenceOfVectors< P_V, P_M >, QUESO::SequenceOfVectors< Q_V, Q_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 104 of file VectorSequence.C.

105 {
106  return m_vectorSpace.dimGlobal();
107 }
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
template<class V , class M >
unsigned int QUESO::BaseVectorSequence< V, M >::vectorSizeLocal ( ) const

Local dimension (size) of the vector space.

Definition at line 97 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().

98 {
99  return m_vectorSpace.dimLocal();
100 }
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432
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 111 of file VectorSequence.C.

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

112 {
113  return m_vectorSpace;
114 }
QUESO::BaseVectorSequence::m_vectorSpace
const VectorSpace< V, M > & m_vectorSpace
Definition: VectorSequence.h:432

Member Data Documentation

template<class V = GslVector, class M = GslMatrix>
const BaseEnvironment& QUESO::BaseVectorSequence< V, M >::m_env
protected

Definition at line 431 of file VectorSequence.h.

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

template<class V = GslVector, class M = GslMatrix>
Fft<double>* QUESO::BaseVectorSequence< V, M >::m_fftObj
mutableprotected

Definition at line 435 of file VectorSequence.h.

template<class V = GslVector, class M = GslMatrix>
std::string QUESO::BaseVectorSequence< V, M >::m_name
protected

Definition at line 433 of file VectorSequence.h.

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

template<class V = GslVector, class M = GslMatrix>
BoxSubset<V,M>* QUESO::BaseVectorSequence< V, M >::m_subBoxPlain
mutableprotected

Definition at line 446 of file VectorSequence.h.

template<class V = GslVector, class M = GslMatrix>
V* QUESO::BaseVectorSequence< V, M >::m_subMaxPlain
mutableprotected

Definition at line 438 of file VectorSequence.h.

template<class V = GslVector, class M = GslMatrix>
V* QUESO::BaseVectorSequence< V, M >::m_subMeanPlain
mutableprotected

Definition at line 440 of file VectorSequence.h.

template<class V = GslVector, class M = GslMatrix>
V* QUESO::BaseVectorSequence< V, M >::m_subMedianPlain
mutableprotected

Definition at line 442 of file VectorSequence.h.

template<class V = GslVector, class M = GslMatrix>
V* QUESO::BaseVectorSequence< V, M >::m_subMinPlain
mutableprotected

Definition at line 436 of file VectorSequence.h.

template<class V = GslVector, class M = GslMatrix>
V* QUESO::BaseVectorSequence< V, M >::m_subSampleVariancePlain
mutableprotected

Definition at line 444 of file VectorSequence.h.

template<class V = GslVector, class M = GslMatrix>
BoxSubset<V,M>* QUESO::BaseVectorSequence< V, M >::m_unifiedBoxPlain
mutableprotected

Definition at line 447 of file VectorSequence.h.

template<class V = GslVector, class M = GslMatrix>
V* QUESO::BaseVectorSequence< V, M >::m_unifiedMaxPlain
mutableprotected

Definition at line 439 of file VectorSequence.h.

template<class V = GslVector, class M = GslMatrix>
V* QUESO::BaseVectorSequence< V, M >::m_unifiedMeanPlain
mutableprotected

Definition at line 441 of file VectorSequence.h.

template<class V = GslVector, class M = GslMatrix>
V* QUESO::BaseVectorSequence< V, M >::m_unifiedMedianPlain
mutableprotected

Definition at line 443 of file VectorSequence.h.

template<class V = GslVector, class M = GslMatrix>
V* QUESO::BaseVectorSequence< V, M >::m_unifiedMinPlain
mutableprotected

Definition at line 437 of file VectorSequence.h.

template<class V = GslVector, class M = GslMatrix>
V* QUESO::BaseVectorSequence< V, M >::m_unifiedSampleVariancePlain
mutableprotected

Definition at line 445 of file VectorSequence.h.

template<class V = GslVector, class M = GslMatrix>
const VectorSpace<V,M>& QUESO::BaseVectorSequence< V, M >::m_vectorSpace
protected

Definition at line 432 of file VectorSequence.h.

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

The documentation for this class was generated from the following files:
Generated on Thu Jun 11 2015 13:52:34 for queso-0.53.0 by  doxygen 1.8.5