Stokhos Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
basis.cpp
Go to the documentation of this file.
1 // @HEADER
2 // *****************************************************************************
3 // Stokhos Package
4 //
5 // Copyright 2009 NTESS and the Stokhos contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9 
10 #include "Stokhos.hpp"
11 #include "Teuchos_CommandLineProcessor.hpp"
12 
13 // basis
14 //
15 // usage:
16 // basis [options]
17 //
18 // output:
19 // prints the dimensionality and corresponding sparse-grid size for
20 // various multi-variate basis choices.
21 
22 // Basis types
23 enum BasisType { HERMITE, LEGENDRE, CC_LEGENDRE, GP_LEGENDRE, RYS, JACOBI };
24 const int num_basis_types = 6;
25 const BasisType basis_type_values[] = {
26  HERMITE, LEGENDRE, CC_LEGENDRE, GP_LEGENDRE, RYS, JACOBI };
27 const char *basis_type_names[] = {
28  "hermite", "legendre", "clenshaw-curtis", "gauss-patterson", "rys", "jacobi" };
29 
30 // Growth policies
31 const int num_growth_types = 2;
32 const Stokhos::GrowthPolicy growth_type_values[] = {
33  Stokhos::SLOW_GROWTH, Stokhos::MODERATE_GROWTH };
34 const char *growth_type_names[] = { "slow", "moderate" };
35 
36 // Product Basis types
37 enum ProductBasisType { COMPLETE, TENSOR, TOTAL, SMOLYAK };
38 const int num_prod_basis_types = 4;
39 const ProductBasisType prod_basis_type_values[] = {
40  COMPLETE, TENSOR, TOTAL, SMOLYAK };
41 const char *prod_basis_type_names[] = {
42  "complete", "tensor", "total", "smolyak" };
43 
44 // Ordering types
45 enum OrderingType { TOTAL_ORDERING, LEXICOGRAPHIC_ORDERING, MORTON_Z_ORDERING };
46 const int num_ordering_types = 3;
47 const OrderingType ordering_type_values[] = {
48  TOTAL_ORDERING, LEXICOGRAPHIC_ORDERING, MORTON_Z_ORDERING };
49 const char *ordering_type_names[] = {
50  "total", "lexicographic", "morton-z" };
51 
52 int main(int argc, char **argv)
53 {
54  try {
55 
56  // Setup command line options
57  Teuchos::CommandLineProcessor CLP;
58  CLP.setDocString(
59  "This example prints out the dimensionality of various basis choices.\n");
60  int d = 3;
61  CLP.setOption("dimension", &d, "Stochastic dimension");
62  int p = 5;
63  CLP.setOption("order", &p, "Polynomial order");
64  double drop = 1.0e-12;
65  CLP.setOption("drop", &drop, "Drop tolerance");
66  BasisType basis_type = LEGENDRE;
67  CLP.setOption("basis", &basis_type,
68  num_basis_types, basis_type_values, basis_type_names,
69  "Basis type");
70  Stokhos::GrowthPolicy growth_type = Stokhos::SLOW_GROWTH;
71  CLP.setOption("growth", &growth_type,
72  num_growth_types, growth_type_values, growth_type_names,
73  "Growth type");
74  ProductBasisType prod_basis_type = COMPLETE;
75  CLP.setOption("product_basis", &prod_basis_type,
76  num_prod_basis_types, prod_basis_type_values,
77  prod_basis_type_names,
78  "Product basis type");
79  OrderingType ordering_type = TOTAL_ORDERING;
80  CLP.setOption("ordering", &ordering_type,
81  num_ordering_types, ordering_type_values,
82  ordering_type_names,
83  "Product basis ordering");
84  double alpha = 1.0;
85  CLP.setOption("alpha", &alpha, "Jacobi alpha index");
86  double beta = 1.0;
87  CLP.setOption("beta", &beta, "Jacobi beta index");
88 
89  // Parse arguments
90  CLP.parse( argc, argv );
91 
92  // Basis
93  Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(d);
94  for (int i=0; i<d; i++) {
95  if (basis_type == HERMITE)
96  bases[i] = Teuchos::rcp(new Stokhos::HermiteBasis<int,double>(
97  p, true, growth_type));
98  else if (basis_type == LEGENDRE)
99  bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<int,double>(
100  p, true, growth_type));
101  else if (basis_type == CC_LEGENDRE)
102  bases[i] =
103  Teuchos::rcp(new Stokhos::ClenshawCurtisLegendreBasis<int,double>(
104  p, true));
105  else if (basis_type == GP_LEGENDRE)
106  bases[i] =
107  Teuchos::rcp(new Stokhos::GaussPattersonLegendreBasis<int,double>(
108  p, true));
109  else if (basis_type == RYS)
110  bases[i] = Teuchos::rcp(new Stokhos::RysBasis<int,double>(
111  p, 1.0, true, growth_type));
112  else if (basis_type == JACOBI)
113  bases[i] = Teuchos::rcp(new Stokhos::JacobiBasis<int,double>(
114  p, alpha, beta, true, growth_type));
115  }
116  Teuchos::RCP<const Stokhos::ProductBasis<int,double> > basis;
117  typedef Stokhos::TotalOrderLess< Stokhos::MultiIndex<int> > total_less;
118  typedef Stokhos::LexographicLess< Stokhos::MultiIndex<int> > lexo_less;
119  typedef Stokhos::MortonZLess< Stokhos::MultiIndex<int> > z_less;
120  if (prod_basis_type == COMPLETE)
121  basis =
122  Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(
123  bases, drop));
124  else if (prod_basis_type == TENSOR) {
125  if (ordering_type == TOTAL_ORDERING)
126  basis =
127  Teuchos::rcp(new Stokhos::TensorProductBasis<int,double,total_less>(
128  bases, drop));
129  else if (ordering_type == LEXICOGRAPHIC_ORDERING)
130  basis =
131  Teuchos::rcp(new Stokhos::TensorProductBasis<int,double,lexo_less>(
132  bases, drop));
133  else if (ordering_type == MORTON_Z_ORDERING)
134  basis =
135  Teuchos::rcp(new Stokhos::TensorProductBasis<int,double,z_less>(
136  bases, drop));
137  }
138  else if (prod_basis_type == TOTAL) {
139  if (ordering_type == TOTAL_ORDERING)
140  basis =
141  Teuchos::rcp(new Stokhos::TotalOrderBasis<int,double,total_less>(
142  bases, drop));
143  else if (ordering_type == LEXICOGRAPHIC_ORDERING)
144  basis =
145  Teuchos::rcp(new Stokhos::TotalOrderBasis<int,double,lexo_less>(
146  bases, drop));
147  else if (ordering_type == MORTON_Z_ORDERING)
148  basis =
149  Teuchos::rcp(new Stokhos::TotalOrderBasis<int,double,z_less>(
150  bases, drop));
151  }
152  else if (prod_basis_type == SMOLYAK) {
153  Stokhos::TotalOrderIndexSet<int> index_set(d, p);
154  if (ordering_type == TOTAL_ORDERING)
155  basis =
156  Teuchos::rcp(new Stokhos::SmolyakBasis<int,double,total_less>(
157  bases, index_set, drop));
158  else if (ordering_type == LEXICOGRAPHIC_ORDERING)
159  basis =
160  Teuchos::rcp(new Stokhos::SmolyakBasis<int,double,lexo_less>(
161  bases, index_set, drop));
162  else if (ordering_type == MORTON_Z_ORDERING)
163  basis =
164  Teuchos::rcp(new Stokhos::SmolyakBasis<int,double,z_less>(
165  bases, index_set, drop));
166  }
167 
168  Stokhos::TotalOrderIndexSet<int> index_set(d, p);
169  Teuchos::RCP<const Stokhos::Quadrature<int,double> > quad =
170  Teuchos::rcp(new Stokhos::SmolyakSparseGridQuadrature<int,double>(basis, index_set));
171 
172  std::cout << "order = " << p << " dim = " << d
173  << " basis size = " << basis->size()
174  << " sparse grid size = " << quad->size()
175  << std::endl;
176  }
177  catch (std::exception& e) {
178  std::cout << e.what() << std::endl;
179  }
180 
181  return 0;
182 }
prod_basis_type_values
const ProductBasisType prod_basis_type_values[]
Definition: cijk_nonzeros.cpp:50
argv
char * argv[]
Definition: Stokhos_HouseTriDiagUnitTest.cpp:252
Stokhos::HermiteBasis
Hermite polynomial basis.
Definition: Stokhos_HermiteBasis.hpp:33
MORTON_Z_ORDERING
Definition: sparsity_example.cpp:61
RYS
Definition: cijk_nonzeros.cpp:34
Stokhos::TotalOrderBasis
Multivariate orthogonal polynomial basis generated from a total order tensor product of univariate po...
Definition: Stokhos_TotalOrderBasis.hpp:36
basis_type_names
const char * basis_type_names[]
Definition: cijk_nonzeros.cpp:38
CC_LEGENDRE
Definition: cijk_nonzeros.cpp:34
basis_type_values
const BasisType basis_type_values[]
Definition: cijk_nonzeros.cpp:36
SMOLYAK
Definition: cijk_nonzeros.cpp:48
num_prod_basis_types
const int num_prod_basis_types
Definition: cijk_nonzeros.cpp:49
Stokhos::GrowthPolicy
GrowthPolicy
Enumerated type for determining Smolyak growth policies.
Definition: Stokhos_RecurrenceBasis.hpp:18
TOTAL
Definition: cijk_nonzeros.cpp:48
growth_type_names
const char * growth_type_names[]
Definition: cijk_nonzeros.cpp:45
HERMITE
Definition: cijk_nonzeros.cpp:34
COMPLETE
Definition: cijk_nonzeros.cpp:48
ordering_type_values
const OrderingType ordering_type_values[]
Definition: cijk_partition.cpp:61
num_ordering_types
const int num_ordering_types
Definition: cijk_partition.cpp:60
Stokhos::SmolyakSparseGridQuadrature
Defines quadrature for a tensor product basis by Smolyak sparse grids.
Definition: Stokhos_SmolyakSparseGridQuadrature.hpp:31
Stokhos::TotalOrderLess
A comparison functor implementing a strict weak ordering based total-order ordering, recursive on the dimension.
Definition: Stokhos_ProductBasisUtils.hpp:817
GP_LEGENDRE
Definition: cijk_nonzeros.cpp:34
OrderingType
OrderingType
Definition: cijk_partition.cpp:59
JACOBI
Definition: cijk_nonzeros.cpp:34
Stokhos::GaussPattersonLegendreBasis
Legendre polynomial basis using Gauss-Patterson quadrature points.
Definition: Stokhos_GaussPattersonLegendreBasis.hpp:23
ProductBasisType
ProductBasisType
Definition: cijk_nonzeros.cpp:48
LEGENDRE
Definition: cijk_nonzeros.cpp:34
Teuchos::rcp
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Stokhos::RysBasis
Rys polynomial basis.
Definition: Stokhos_RysBasis.hpp:33
Teuchos::CommandLineProcessor::setOption
void setOption(const char option_true[], const char option_false[], bool *option_val, const char documentation[]=NULL)
num_growth_types
const int num_growth_types
Definition: cijk_nonzeros.cpp:42
Stokhos::JacobiBasis
Jacobi polynomial basis.
Definition: Stokhos_JacobiBasis.hpp:60
Teuchos::CommandLineProcessor::parse
EParseCommandLineReturn parse(int argc, char *argv[], std::ostream *errout=&std::cerr) const
BasisType
BasisType
Definition: cijk_nonzeros.cpp:34
LEXICOGRAPHIC_ORDERING
Definition: cijk_partition.cpp:59
growth_type_values
const Stokhos::GrowthPolicy growth_type_values[]
Definition: cijk_nonzeros.cpp:43
Stokhos::SmolyakBasis
Multivariate orthogonal polynomial basis generated from a Smolyak sparse grid.
Definition: Stokhos_SmolyakBasis.hpp:30
Stokhos::TensorProductBasis
Multivariate orthogonal polynomial basis generated from a tensor product of univariate polynomials...
Definition: Stokhos_TensorProductBasis.hpp:37
Stokhos::LegendreBasis
Legendre polynomial basis.
Definition: Stokhos_LegendreBasis.hpp:33
main
int main(int argc, char **argv)
Definition: cijk_ltb_partition.cpp:25
Stokhos::TotalOrderIndexSet
An isotropic total order index set.
Definition: Stokhos_ProductBasisUtils.hpp:183
Stokhos::MortonZLess
A comparison functor implementing a strict weak ordering based Morton Z-ordering. ...
Definition: Stokhos_ProductBasisUtils.hpp:870
Stokhos::ClenshawCurtisLegendreBasis
Legendre polynomial basis using Clenshaw-Curtis quadrature points.
Definition: Stokhos_ClenshawCurtisLegendreBasis.hpp:23
Teuchos_CommandLineProcessor.hpp
Teuchos::CommandLineProcessor::setDocString
void setDocString(const char doc_string[])
TENSOR
Definition: cijk_nonzeros.cpp:48
Stokhos::LexographicLess
A comparison functor implementing a strict weak ordering based lexographic ordering.
Definition: Stokhos_ProductBasisUtils.hpp:767
num_basis_types
const int num_basis_types
Definition: cijk_nonzeros.cpp:35
ordering_type_names
const char * ordering_type_names[]
Definition: cijk_partition.cpp:63
prod_basis_type_names
const char * prod_basis_type_names[]
Definition: cijk_nonzeros.cpp:52
TOTAL_ORDERING
Definition: cijk_partition.cpp:59
CLP
Definition: gram_schmidt_example3.cpp:53
Generated by   doxygen 1.8.5