// @HEADER // ***************************************************************************** // Stokhos Package // // Copyright 2009 NTESS and the Stokhos contributors. // SPDX-License-Identifier: BSD-3-Clause // ***************************************************************************** // @HEADER #include "Teuchos_TimeMonitor.hpp" template Stokhos::CompletePolynomialBasis:: CompletePolynomialBasis( const Teuchos::Array< Teuchos::RCP > >& bases_, const value_type& sparse_tol_, bool use_old_cijk_alg_, const Teuchos::RCP< Teuchos::Array >& deriv_coeffs_) : p(0), d(bases_.size()), sz(0), bases(bases_), basis_orders(d), sparse_tol(sparse_tol_), use_old_cijk_alg(use_old_cijk_alg_), deriv_coeffs(deriv_coeffs_), norms(), terms() { // Compute total order for (ordinal_type i=0; iorder(); if (basis_orders[i] > p) p = basis_orders[i]; } // Compute basis terms CPBUtils::compute_terms(basis_orders, sz, terms, num_terms); // Compute norms norms.resize(sz); value_type nrm; for (ordinal_type k=0; knorm_squared(terms[k][i]); norms[k] = nrm; } // Create name name = "Complete polynomial basis ("; for (ordinal_type i=0; igetName() + ", "; name += bases[d-1]->getName() + ")"; // Allocate array for basis evaluation basis_eval_tmp.resize(d); for (ordinal_type j=0; j(d)); for (ordinal_type j=0; j Stokhos::CompletePolynomialBasis:: ~CompletePolynomialBasis() { } template ordinal_type Stokhos::CompletePolynomialBasis:: order() const { return p; } template ordinal_type Stokhos::CompletePolynomialBasis:: dimension() const { return d; } template ordinal_type Stokhos::CompletePolynomialBasis:: size() const { return sz; } template const Teuchos::Array& Stokhos::CompletePolynomialBasis:: norm_squared() const { return norms; } template const value_type& Stokhos::CompletePolynomialBasis:: norm_squared(ordinal_type i) const { return norms[i]; } template Teuchos::RCP< Stokhos::Sparse3Tensor > Stokhos::CompletePolynomialBasis:: computeTripleProductTensor() const { #ifdef STOKHOS_TEUCHOS_TIME_MONITOR TEUCHOS_FUNC_TIME_MONITOR("Stokhos: Total Triple-Product Tensor Fill Time"); #endif if (use_old_cijk_alg) return computeTripleProductTensorOld(sz); else return computeTripleProductTensorNew(sz); } template Teuchos::RCP< Stokhos::Sparse3Tensor > Stokhos::CompletePolynomialBasis:: computeLinearTripleProductTensor() const { #ifdef STOKHOS_TEUCHOS_TIME_MONITOR TEUCHOS_FUNC_TIME_MONITOR("Stokhos: Total Triple-Product Tensor Fill Time"); #endif if (use_old_cijk_alg) return computeTripleProductTensorOld(d+1); else return computeTripleProductTensorNew(d+1); } template Teuchos::RCP< Stokhos::Sparse3Tensor > Stokhos::CompletePolynomialBasis:: computeTripleProductTensorOld(ordinal_type order) const { // Compute Cijk = < \Psi_i \Psi_j \Psi_k > Teuchos::RCP< Stokhos::Sparse3Tensor > Cijk = Teuchos::rcp(new Sparse3Tensor); // Create 1-D triple products Teuchos::Array< Teuchos::RCP > > Cijk_1d(d); for (ordinal_type i=0; icomputeTripleProductTensor(); for (ordinal_type j=0; j sparse_tol) Cijk->add_term(i,j,k,c); } } } Cijk->fillComplete(); return Cijk; } template Teuchos::RCP< Stokhos::Sparse3Tensor > Stokhos::CompletePolynomialBasis:: computeTripleProductTensorNew(ordinal_type order) const { // The algorithm for computing Cijk = < \Psi_i \Psi_j \Psi_k > here works // by factoring // < \Psi_i \Psi_j \Psi_k > = // < \psi^1_{i_1}\psi^1_{j_1}\psi^1_{k_1} >_1 x ... x // < \psi^d_{i_d}\psi^d_{j_d}\psi^d_{k_d} >_d // We compute the sparse triple product < \psi^l_i\psi^l_j\psi^l_k >_l // for each dimension l, and then compute all non-zero products of these // terms. The complexity arises from iterating through all possible // combinations, throwing out terms that aren't in the basis and are beyond // the k-order limit provided Teuchos::RCP< Stokhos::Sparse3Tensor > Cijk = Teuchos::rcp(new Sparse3Tensor); // Map the specified order limit to a limit on each dimension // Subtract 1 to get the term for the last order we want to include, // add up the orders for each term to get the total order, then add 1 MultiIndex term = this->term(order-1); ordinal_type k_lim = 0; for (ordinal_type i=0; i > > Cijk_1d(d); for (ordinal_type i=0; icomputeSparseTripleProductTensor(k_lim); else Cijk_1d[i] = bases[i]->computeSparseTripleProductTensor(basis_orders[i]+1); } // Create i, j, k iterators for each dimension // Note: we have to supply an initializer in the arrays of iterators to // avoid checked-stl errors about singular iterators typedef Sparse3Tensor Cijk_type; typedef typename Cijk_type::k_iterator k_iterator; typedef typename Cijk_type::kj_iterator kj_iterator; typedef typename Cijk_type::kji_iterator kji_iterator; Teuchos::Array k_iterators(d, Cijk_1d[0]->k_begin()); Teuchos::Array j_iterators(d, Cijk_1d[0]->j_begin(k_iterators[0])); Teuchos::Array i_iterators(d, Cijk_1d[0]->i_begin(j_iterators[0])); MultiIndex terms_i(d), terms_j(d), terms_k(d); ordinal_type sum_i = 0; ordinal_type sum_j = 0; ordinal_type sum_k = 0; for (ordinal_type dim=0; dimk_begin(); j_iterators[dim] = Cijk_1d[dim]->j_begin(k_iterators[dim]); i_iterators[dim] = Cijk_1d[dim]->i_begin(j_iterators[dim]); terms_i[dim] = Stokhos::index(i_iterators[dim]); terms_j[dim] = Stokhos::index(j_iterators[dim]); terms_k[dim] = Stokhos::index(k_iterators[dim]); sum_i += terms_i[dim]; sum_j += terms_j[dim]; sum_k += terms_k[dim]; } ordinal_type I = 0; ordinal_type J = 0; ordinal_type K = 0; bool inc_i = true; bool inc_j = true; bool inc_k = true; bool stop = false; ordinal_type cnt = 0; while (!stop) { // Add term if it is in the basis if (sum_i <= p && sum_j <= p && sum_k <= p) { if (inc_k) K = CPBUtils::compute_index(terms_k, terms, num_terms, p); if (K < order) { if (inc_i) I = CPBUtils::compute_index(terms_i, terms, num_terms, p); if (inc_j) J = CPBUtils::compute_index(terms_j, terms, num_terms, p); value_type c = value_type(1.0); for (ordinal_type dim=0; dim sparse_tol) Cijk->add_term(I,J,K,c); } } // Increment iterators to the next valid term ordinal_type cdim = 0; bool inc = true; inc_i = false; inc_j = false; inc_k = false; while (inc && cdim < d) { ordinal_type cur_dim = cdim; ++i_iterators[cdim]; inc_i = true; if (i_iterators[cdim] != Cijk_1d[cdim]->i_end(j_iterators[cdim])) { terms_i[cdim] = Stokhos::index(i_iterators[cdim]); sum_i = 0; for (int dim=0; dimi_end(j_iterators[cdim]) || sum_i > p) { ++j_iterators[cdim]; inc_j = true; if (j_iterators[cdim] != Cijk_1d[cdim]->j_end(k_iterators[cdim])) { terms_j[cdim] = Stokhos::index(j_iterators[cdim]); sum_j = 0; for (int dim=0; dimj_end(k_iterators[cdim]) || sum_j > p) { ++k_iterators[cdim]; inc_k = true; if (k_iterators[cdim] != Cijk_1d[cdim]->k_end()) { terms_k[cdim] = Stokhos::index(k_iterators[cdim]); sum_k = 0; for (int dim=0; dimk_end() || sum_k > p) { k_iterators[cdim] = Cijk_1d[cdim]->k_begin(); ++cdim; terms_k[cur_dim] = Stokhos::index(k_iterators[cur_dim]); sum_k = 0; for (int dim=0; dimj_begin(k_iterators[cur_dim]); terms_j[cur_dim] = Stokhos::index(j_iterators[cur_dim]); sum_j = 0; for (int dim=0; dimi_begin(j_iterators[cur_dim]); terms_i[cur_dim] = Stokhos::index(i_iterators[cur_dim]); sum_i = 0; for (int dim=0; dim p || sum_j > p || sum_k > p) inc = true; } if (cdim == d) stop = true; cnt++; } Cijk->fillComplete(); return Cijk; } template Teuchos::RCP< Stokhos::Dense3Tensor > Stokhos::CompletePolynomialBasis:: computeDerivTripleProductTensor( const Teuchos::RCP< const Teuchos::SerialDenseMatrix >& Bij, const Teuchos::RCP< const Stokhos::Sparse3Tensor >& Cijk) const { // Compute Dijk = < \Psi_i \Psi_j \Psi_k' > Teuchos::RCP< Stokhos::Dense3Tensor > Dijk = Teuchos::rcp(new Dense3Tensor(sz)); for (ordinal_type i=0; ik_begin(); m_it!=Cijk->k_end(); ++m_it) { m = Stokhos::index(m_it); for (typename Cijk_type::kj_iterator j_it = Cijk->j_begin(m_it); j_it != Cijk->j_end(m_it); ++j_it) { j = Stokhos::index(j_it); for (typename Cijk_type::kji_iterator i_it = Cijk->i_begin(j_it); i_it != Cijk->i_end(j_it); ++i_it) { i = Stokhos::index(i_it); c = Stokhos::value(i_it); (*Dijk)(i,j,k) += (*Bij)(m,k)*c/norms[m]; } } } } return Dijk; } template Teuchos::RCP< Teuchos::SerialDenseMatrix > Stokhos::CompletePolynomialBasis:: computeDerivDoubleProductTensor() const { // Compute Bij = < \Psi_i \Psi_j' > Teuchos::RCP< Teuchos::SerialDenseMatrix > Bij = Teuchos::rcp(new Teuchos::SerialDenseMatrix(sz, sz)); // Create products Teuchos::Array< Teuchos::RCP > > Bij_1d(d); for (ordinal_type i=0; icomputeDerivDoubleProductTensor(); for (ordinal_type i=0; inorm_squared(terms[k][l]); } if (!is_zero) c += t*(*deriv_coeffs)[j]*(*Bij_1d[j])(terms[k][j],terms[i][j]); } (*Bij)(i,k) = c; } } return Bij; } template value_type Stokhos::CompletePolynomialBasis:: evaluateZero(ordinal_type i) const { // z = psi_{i_1}(0) * ... * psi_{i_d}(0) where i_1,...,i_d are the basis // terms for coefficient i value_type z = value_type(1.0); for (ordinal_type j=0; jevaluate(value_type(0.0), terms[i][j]); return z; } template void Stokhos::CompletePolynomialBasis:: evaluateBases(const Teuchos::ArrayView& point, Teuchos::Array& basis_vals) const { for (ordinal_type j=0; jevaluateBases(point[j], basis_eval_tmp[j]); // Only evaluate basis upto number of terms included in basis_pts for (ordinal_type i=0; i void Stokhos::CompletePolynomialBasis:: print(std::ostream& os) const { os << "Complete basis of order " << p << ", dimension " << d << ", and size " << sz << ". Component bases:\n"; for (ordinal_type i=0; i(norms.size()); i++) os << norms[i] << " "; os << "\n"; } template const Stokhos::MultiIndex& Stokhos::CompletePolynomialBasis:: term(ordinal_type i) const { return terms[i]; } template ordinal_type Stokhos::CompletePolynomialBasis:: index(const Stokhos::MultiIndex& term) const { return CPBUtils::compute_index(term, terms, num_terms, p); } template const std::string& Stokhos::CompletePolynomialBasis:: getName() const { return name; } template Teuchos::Array< Teuchos::RCP > > Stokhos::CompletePolynomialBasis:: getCoordinateBases() const { return bases; } template Stokhos::MultiIndex Stokhos::CompletePolynomialBasis:: getMaxOrders() const { MultiIndex max_orders(d); for (ordinal_type i=0; i