Build interpolation-based surrogate. More...

#include <InterpolationSurrogateBuilder.h>

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

Public Member Functions
	InterpolationSurrogateBuilder (InterpolationSurrogateDataSet< V, M > &data)
	Constructor. More...

virtual	~InterpolationSurrogateBuilder ()

void	build_values ()
	Execute the user's model and populate m_values for the given n_points. More...

Public Member Functions inherited from QUESO::SurrogateBuilderBase< V >
	SurrogateBuilderBase ()

virtual	~SurrogateBuilderBase ()

virtual void	evaluate_model (const V &domainVector, std::vector< double > &values)=0

Protected Member Functions
void	partition_work ()
	Partition the workload of model evaluations across the subenvironments. More...

void	set_work_bounds (unsigned int &n_begin, unsigned int &n_end) const
	Set the starting and ending global indices for the current subenvironment. More...

void	sync_data (std::vector< unsigned int > &local_n, std::vector< double > &local_values, InterpolationSurrogateData< V, M > &data)
	Take the local values computed from each process and communicate. More...

void	set_domain_vector (unsigned int n, V &domain_vector) const
	Provide the spatial coordinates for the global index n. More...

void	compute_strides (std::vector< int > &strides) const
	Helper function to compute strides needed for MPI_Gatherv. More...

const InterpolationSurrogateData< V, M > &	get_default_data () const
	Helper function to grab representative dataset from m_data. More...

Protected Attributes
InterpolationSurrogateDataSet < V, M > &	m_data

std::vector< int >	m_njobs
	Cache the amount of work for each subenvironment. More...

Private Member Functions
	InterpolationSurrogateBuilder ()

Detailed Description

template<class V = GslVector, class M = GslMatrix>
class QUESO::InterpolationSurrogateBuilder< V, M >

Build interpolation-based surrogate.

Interpolation surrogates assume a structured grid. So, given the domain and the number of equally space points desired in each dimension, this class will handle calling the user's model to populate the values needed by the surrogate objects. User should subclass this object and implement the evaluate_model method.

Definition at line 43 of file InterpolationSurrogateBuilder.h.

Constructor & Destructor Documentation

template<class V , class M >

QUESO::InterpolationSurrogateBuilder< V, M >::InterpolationSurrogateBuilder ( InterpolationSurrogateDataSet< V, M > & data )

Constructor.

We do not take a const& to the data because we want to compute and set the values directly.

Definition at line 41 of file InterpolationSurrogateBuilder.C.

References QUESO::InterpolationSurrogateBuilder< V, M >::partition_work().

     : SurrogateBuilderBase<V>(),
     m_data(data),
     m_njobs(this->get_default_data().get_paramDomain().env().numSubEnvironments(), 0)
   {
     this->partition_work();
   }

template<class V = GslVector, class M = GslMatrix>

virtual QUESO::InterpolationSurrogateBuilder< V, M >::~InterpolationSurrogateBuilder ( )

inlinevirtual

Definition at line 52 of file InterpolationSurrogateBuilder.h.

52 {};

template<class V = GslVector, class M = GslMatrix>

QUESO::InterpolationSurrogateBuilder< V, M >::InterpolationSurrogateBuilder ( )

private

Member Function Documentation

template<class V , class M >

void QUESO::InterpolationSurrogateBuilder< V, M >::build_values ( )

Execute the user's model and populate m_values for the given n_points.

Definition at line 83 of file InterpolationSurrogateBuilder.C.

   {
     unsigned int n_begin, n_end;
     this->set_work_bounds( n_begin, n_end );
 
     // Cache each processors work, then we only need to do 1 Allgather
     std::vector<unsigned int> local_n(n_end-n_begin);
 
     // We need to cache (n_end-n_begin) values for each dataset,
     std::vector<std::vector<double> > local_values(this->m_data.size());
     for( std::vector<std::vector<double> >::iterator it = local_values.begin();
          it != local_values.end(); ++it )
       it->resize(n_end-n_begin);
 
     unsigned int count = 0;
 
     // vector to store current domain value
     V domain_vector(this->get_default_data().get_paramDomain().vectorSpace().zeroVector());
 
     // vector to store values evaluated at the current domain_vector
     std::vector<double> values(this->m_data.size());
 
     for( unsigned int n = n_begin; n < n_end; n++ )
       {
         this->set_domain_vector( n, domain_vector );
 
         this->evaluate_model( domain_vector, values );
 
         local_n[count] = n;
 
         for( unsigned int s = 0; s < this->m_data.size(); s++ )
           local_values[s][count] = values[s];
 
         count += 1;
       }
 
     /* Sync all the locally computed values between the subenvironments
        so all processes have all the computed values. We need to sync
        values for every data set. */
     for( unsigned int s = 0; s < this->m_data.size(); s++ )
       this->sync_data( local_n, local_values[s], this->m_data.get_dataset(s) );
   }

template<class V , class M >

void QUESO::InterpolationSurrogateBuilder< V, M >::compute_strides ( std::vector< int > & strides ) const

protected

Helper function to compute strides needed for MPI_Gatherv.

Definition at line 201 of file InterpolationSurrogateBuilder.C.

   {
     unsigned int n_subenvs = this->get_default_data().get_paramDomain().env().numSubEnvironments();
 
     strides.resize(n_subenvs);
 
     // Don't stride the first entry
     strides[0] = 0;
 
     int stride = 0;
     for( unsigned int n = 1; n < n_subenvs; n++ )
       {
         // The stride is measured agaisnt the beginning of the buffer
         // We want things packed tightly together so just stride
         // by the number of entries from the previous group.
         stride += this->m_njobs[n-1];
         strides[n] = stride;
       }
   }

template<class V = GslVector, class M = GslMatrix>

const InterpolationSurrogateData<V,M>& QUESO::InterpolationSurrogateBuilder< V, M >::get_default_data ( ) const

inlineprotected

Helper function to grab representative dataset from m_data.

We only grab the first data set since the environments are guaranteed to be consistent by the nature of constructing an InterpolationSurrogateDataSet.

Definition at line 89 of file InterpolationSurrogateBuilder.h.

References QUESO::InterpolationSurrogateBuilder< V, M >::m_data.

90 { return m_data.get_dataset(0); }

QUESO::InterpolationSurrogateBuilder::m_data

InterpolationSurrogateDataSet< V, M > & m_data

Definition: InterpolationSurrogateBuilder.h:59

template<class V , class M >

void QUESO::InterpolationSurrogateBuilder< V, M >::partition_work ( )

protected

Partition the workload of model evaluations across the subenvironments.

Definition at line 50 of file InterpolationSurrogateBuilder.C.

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

   {
     // Convenience
     unsigned int n_values = this->get_default_data().n_values();
     unsigned int n_workers = this->get_default_data().get_paramDomain().env().numSubEnvironments();
 
     unsigned int n_jobs = n_values/n_workers;
     unsigned int n_leftover = this->get_default_data().n_values() % n_workers;
 
     /* If the number of values is evenly divisible over all workers,
        then everyone gets the same amount work */
     if( n_leftover  == 0 )
       {
         for(unsigned int n = 0; n < n_workers; n++)
           this->m_njobs[n] = n_jobs;
       }
     /* Otherwise, some workers get more work than others*/
     else
       {
         for(unsigned int n = 0; n < n_workers; n++)
           {
             if( n < n_leftover )
               this->m_njobs[n] = n_jobs+1;
             else
               this->m_njobs[n] = n_jobs;
           }
       }
 
     // Sanity check
     queso_assert_equal_to( (int)n_values, std::accumulate( m_njobs.begin(), m_njobs.end(), 0 ) );
   }

template<class V , class M >

void QUESO::InterpolationSurrogateBuilder< V, M >::set_domain_vector	(	unsigned int	n,
		V &	domain_vector
	)		const

protected

Provide the spatial coordinates for the global index n.

Definition at line 187 of file InterpolationSurrogateBuilder.C.

References dim, and QUESO::MultiDimensionalIndexing::globalToCoord().

   {
     // Convert global index n to local coordinates in each dimension
     std::vector<unsigned int> indices(this->get_default_data().dim());
     MultiDimensionalIndexing::globalToCoord( n, this->get_default_data().get_n_points(), indices );
 
     // Use indices to get x coordinates and populate domain_vector
     for( unsigned int d = 0; d < this->get_default_data().dim(); d++ )
       {
         domain_vector[d] = this->get_default_data().get_x( d, indices[d] );
       }
   }

template<class V , class M >

void QUESO::InterpolationSurrogateBuilder< V, M >::set_work_bounds	(	unsigned int &	n_begin,
		unsigned int &	n_end
	)		const

protected

Set the starting and ending global indices for the current subenvironment.

This environment will evaluate the model for indices [n_begin,n_end)

Definition at line 127 of file InterpolationSurrogateBuilder.C.

   {
     unsigned int my_subid = this->get_default_data().get_paramDomain().env().subId();
 
     /* Starting index will be the sum of the all the previous num jobs */
     n_begin = 0;
     for( unsigned int n = 0; n < my_subid; n++ )
       n_begin += m_njobs[n];
 
     n_end = n_begin + m_njobs[my_subid];
   }

template<class V , class M >

void QUESO::InterpolationSurrogateBuilder< V, M >::sync_data	(	std::vector< unsigned int > &	local_n,
		std::vector< double > &	local_values,
		InterpolationSurrogateData< V, M > &	data
	)

protected

Take the local values computed from each process and communicate.

The end result will be that all processes have all the data. I.e. m_values will be completely populated on all processes. This is done on the InterpolationSurrogateData passed to the function.

Todo:: Would be more efficient to pack local_n and local_values togethers and do Gatherv only once.

Definition at line 140 of file InterpolationSurrogateBuilder.C.

References QUESO::InterpolationSurrogateData< V, M >::get_paramDomain(), QUESO::InterpolationSurrogateData< V, M >::n_values(), QUESO::InterpolationSurrogateData< V, M >::set_value(), and QUESO::InterpolationSurrogateData< V, M >::sync_values().

   {
     // Only members of the inter0comm will do the communication of the local values
     unsigned int my_subrank = data.get_paramDomain().env().subRank();
 
     if( my_subrank == 0 )
       {
         std::vector<double> all_values(data.n_values());
 
         std::vector<unsigned int> all_indices(data.n_values());
 
         std::vector<int> strides;
         this->compute_strides( strides );
 
         const MpiComm& inter0comm = data.get_paramDomain().env().inter0Comm();
 
         inter0comm.template Gatherv<unsigned int>(&local_n[0], local_n.size(),
             &all_indices[0], &m_njobs[0], &strides[0],
             0 /*root*/, "InterpolationSurrogateBuilder::sync_data()",
             "MpiComm::gatherv() failed!");
 
         inter0comm.template Gatherv<double>(&local_values[0],
             local_values.size(), &all_values[0], &m_njobs[0], &strides[0],
             0 /*root*/, "InterpolationSurrogateBuilder::sync_data()",
             "MpiComm::gatherv() failed!");
 
         // Now set the values.
         /* PB: Although we are guaranteed per-rank ordering of the data we gathered,
            I'm not sure we can assume the same continuity of the inter0 ranks, i.e.
            I'm not sure how QUESO ordered the inter0 ranks. So, we go ahead and
            manually set the values. */
         if( data.get_paramDomain().env().subRank() == 0 )
           {
             for( unsigned int n = 0; n < data.n_values(); n++ )
               data.set_value( all_indices[n], all_values[n] );
           }
       }
 
     // Now broadcast the values data to all other processes
     data.sync_values( 0 /*root*/);
   }