ordinal_type
Stokhos::PecosOneDOrthogPolyBasis<ordinal_type,value_type>::
pointGrowth(ordinal_type n) const
{
if (n % ordinal_type(2) == ordinal_type(1))
return n + ordinal_type(1);
return n;
}
void
Stokhos::LanczosPCEBasis<ordinal_type, value_type>::
transformCoeffsFromLanczos(const value_type *in, value_type *out) const
{
Teuchos::BLAS<ordinal_type, value_type> blas;
ordinal_type sz = fromStieltjesMat.numRows();
blas.GEMV(Teuchos::NO_TRANS, sz, this->p+1,
value_type(1.0), fromStieltjesMat.values(), sz,
in, ordinal_type(1), value_type(0.0), out, ordinal_type(1));
}
void
Stokhos::MonoProjPCEBasis<ordinal_type, value_type>::
transformCoeffs(const value_type *in, value_type *out) const
{
// Transform coefficients to normalized basis
Teuchos::BLAS<ordinal_type, value_type> blas;
blas.GEMV(Teuchos::NO_TRANS, pce_sz, this->p+1,
value_type(1.0), basis_vecs.values(), pce_sz,
in, ordinal_type(1), value_type(0.0), out, ordinal_type(1));
// Transform from normalized to original
for (ordinal_type i=0; i<pce_sz; i++)
out[i] /= pce_norms[i];
}
ordinal_type
Stokhos::RecurrenceBasis<ordinal_type,value_type>::
pointGrowth(ordinal_type n) const
{
if (growth == SLOW_GROWTH) {
if (n % ordinal_type(2) == ordinal_type(1))
return n + ordinal_type(1);
else
return n;
}
// else moderate
return n;
}
ordinal_type
Stokhos::RecurrenceBasis<ordinal_type,value_type>::
coefficientGrowth(ordinal_type n) const
{
if (growth == SLOW_GROWTH)
return n;
// else moderate
return ordinal_type(2)*n;
}
ordinal_type
Stokhos::GaussPattersonLegendreBasis<ordinal_type,value_type>::
quadDegreeOfExactness(ordinal_type n) const
{
// Based on the above structure, we find the largest l s.t. 2^{l+1}-1 <= n,
// which is floor(log2(n+1)-1) and compute p = 3*2^l-1
if (n == ordinal_type(1))
return 1;
ordinal_type l = std::floor(std::log(n+1.0)/std::log(2.0)-1.0);
return (3 << l) - 1; // 3*std::pow(2,l)-1;
}
void
Stokhos::GaussPattersonLegendreBasis<ordinal_type,value_type>::
getQuadPoints(ordinal_type quad_order,
Teuchos::Array<value_type>& quad_points,
Teuchos::Array<value_type>& quad_weights,
Teuchos::Array< Teuchos::Array<value_type> >& quad_values) const
{
#ifdef HAVE_STOKHOS_DAKOTA
// Gauss-Patterson points have the following structure
// (cf. http://people.sc.fsu.edu/~jburkardt/f_src/patterson_rule/patterson_rule.html):
// Level l Num points n Precision p
// -----------------------------------
// 0 1 1
// 1 3 5
// 2 7 11
// 3 15 23
// 4 31 47
// 5 63 95
// 6 127 191
// 7 255 383
// Thus for l > 0, n = 2^{l+1}-1 and p = 3*2^l-1. So for a given quadrature
// order p, we find the smallest l s.t. 3*s^l-1 >= p and then compute the
// number of points n from the above. In this case, l = ceil(log2((p+1)/3))
ordinal_type num_points;
if (quad_order <= ordinal_type(1))
num_points = 1;
else {
ordinal_type l = std::ceil(std::log((quad_order+1.0)/3.0)/std::log(2.0));
num_points = (1 << (l+1)) - 1; // std::pow(2,l+1)-1;
}
quad_points.resize(num_points);
quad_weights.resize(num_points);
quad_values.resize(num_points);
webbur::patterson_lookup(num_points, &quad_points[0], &quad_weights[0]);
for (ordinal_type i=0; i<num_points; i++) {
quad_weights[i] *= 0.5; // scale to unit measure
quad_values[i].resize(this->p+1);
this->evaluateBases(quad_points[i], quad_values[i]);
}
#else
TEUCHOS_TEST_FOR_EXCEPTION(
true, std::logic_error, "Clenshaw-Curtis requires TriKota to be enabled!");
#endif
}
ordinal_type
Stokhos::PecosOneDOrthogPolyBasis<ordinal_type,value_type>::
quadDegreeOfExactness(ordinal_type n) const
{
return ordinal_type(2)*n-ordinal_type(1);
}
Stokhos::SmolyakPseudoSpectralOperator<ordinal_type,value_type,point_compare_type>::
SmolyakPseudoSpectralOperator(
const SmolyakBasis<ordinal_type,value_type,coeff_compare_type>& smolyak_basis,
bool use_smolyak_apply,
bool use_pst,
const point_compare_type& point_compare) :
use_smolyak(use_smolyak_apply),
points(point_compare) {
typedef SmolyakBasis<ordinal_type,value_type,coeff_compare_type> smolyak_basis_type;
typedef typename smolyak_basis_type::tensor_product_basis_type tensor_product_basis_type;
// Generate sparse grid and tensor operators
coeff_sz = smolyak_basis.size();
ordinal_type dim = smolyak_basis.dimension();
ordinal_type num_terms = smolyak_basis.getNumSmolyakTerms();
for (ordinal_type i=0; i<num_terms; ++i) {
// Get tensor product basis for given term
Teuchos::RCP<const tensor_product_basis_type> tp_basis =
smolyak_basis.getTensorProductBasis(i);
// Get coefficient multi-index defining basis orders
multiindex_type coeff_index = tp_basis->getMaxOrders();
// Apply growth rule to cofficient multi-index
multiindex_type point_growth_index(dim);
for (ordinal_type j=0; j<dim; ++j) {
point_growth_index[j] =
smolyak_basis.getCoordinateBases()[j]->pointGrowth(coeff_index[j]);
}
// Build tensor product operator for given index
Teuchos::RCP<operator_type> op =
Teuchos::rcp(new operator_type(*tp_basis, use_pst,
point_growth_index));
if (use_smolyak)
operators.push_back(op);
// Get smolyak cofficient for given index
value_type c = smolyak_basis.getSmolyakCoefficient(i);
if (use_smolyak)
smolyak_coeffs.push_back(c);
// Include points in union over all sets
typename operator_type::set_iterator op_set_iterator = op->set_begin();
typename operator_type::set_iterator op_set_end = op->set_end();
for (; op_set_iterator != op_set_end; ++op_set_iterator) {
const point_type& point = op_set_iterator->first;
value_type w = op_set_iterator->second.first;
set_iterator si = points.find(point);
if (si == points.end())
points[point] = std::make_pair(c*w,ordinal_type(0));
else
si->second.first += c*w;
}
}
// Generate linear ordering of points
ordinal_type idx = 0;
point_map.resize(points.size());
for (set_iterator si = points.begin(); si != points.end(); ++si) {
si->second.second = idx;
point_map[idx] = si->first;
++idx;
}
if (use_smolyak) {
// Build gather/scatter maps into global domain/range for each operator
gather_maps.resize(operators.size());
scatter_maps.resize(operators.size());
for (ordinal_type i=0; i<operators.size(); i++) {
Teuchos::RCP<operator_type> op = operators[i];
gather_maps[i].reserve(op->point_size());
typename operator_type::iterator op_iterator = op->begin();
typename operator_type::iterator op_end = op->end();
for (; op_iterator != op_end; ++op_iterator) {
gather_maps[i].push_back(points[*op_iterator].second);
}
Teuchos::RCP<const tensor_product_basis_type> tp_basis =
smolyak_basis.getTensorProductBasis(i);
ordinal_type op_coeff_sz = tp_basis->size();
scatter_maps[i].reserve(op_coeff_sz);
for (ordinal_type j=0; j<op_coeff_sz; ++j) {
scatter_maps[i].push_back(smolyak_basis.index(tp_basis->term(j)));
}
}
}
//else {
// Generate quadrature operator
ordinal_type nqp = points.size();
ordinal_type npc = coeff_sz;
qp2pce.reshape(npc,nqp);
pce2qp.reshape(nqp,npc);
qp2pce.putScalar(1.0);
pce2qp.putScalar(1.0);
Teuchos::Array<value_type> vals(npc);
for (set_iterator si = points.begin(); si != points.end(); ++si) {
ordinal_type j = si->second.second;
value_type w = si->second.first;
point_type point = si->first;
smolyak_basis.evaluateBases(point, vals);
for (ordinal_type i=0; i<npc; ++i) {
qp2pce(i,j) = w*vals[i] / smolyak_basis.norm_squared(i);
pce2qp(j,i) = vals[i];
}
}
//}
}
ordinal_type
Stokhos::RecurrenceBasis<ordinal_type,value_type>::
quadDegreeOfExactness(ordinal_type n) const
{
return ordinal_type(2)*n-ordinal_type(1);
}
