43 #include "Teuchos_CommandLineProcessor.hpp" 44 #include "Teuchos_ParameterList.hpp" 74 "complete",
"tensor",
"total",
"smolyak" };
82 "total",
"lexicographic" };
86 using Teuchos::ParameterList;
94 template <
typename coord_t>
110 MPI_Init(&argc,&
argv);
114 Teuchos::CommandLineProcessor
CLP;
116 "This example generates the sparsity pattern for the block stochastic Galerkin matrix.\n");
118 CLP.setOption(
"dimension", &d,
"Stochastic dimension");
120 CLP.setOption(
"order", &p,
"Polynomial order");
121 double drop = 1.0e-12;
122 CLP.setOption(
"drop", &drop,
"Drop tolerance");
123 std::string file =
"A.mm";
124 CLP.setOption(
"filename", &file,
"Matrix Market filename");
125 bool symmetric =
true;
126 CLP.setOption(
"symmetric",
"asymmetric", &symmetric,
127 "Use basis polynomials with symmetric PDF");
129 CLP.setOption(
"growth", &growth_type,
133 CLP.setOption(
"product_basis", &prod_basis_type,
136 "Product basis type");
138 CLP.setOption(
"ordering", &ordering_type,
141 "Product basis ordering");
142 int i_tile_size = 128;
143 CLP.setOption(
"tile_size", &i_tile_size,
"Tile size");
144 bool save_3tensor =
false;
145 CLP.setOption(
"save_3tensor",
"no-save_3tensor", &save_3tensor,
146 "Save full 3tensor to file");
147 std::string file_3tensor =
"Cijk.dat";
148 CLP.setOption(
"filename_3tensor", &file_3tensor,
149 "Filename to store full 3-tensor");
155 Array< RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(d);
156 const double alpha = 1.0;
157 const double beta = symmetric ? 1.0 : 2.0 ;
158 for (
int i=0; i<d; i++) {
160 p, alpha, beta,
true, growth_type));
162 RCP<const Stokhos::ProductBasis<int,double> > basis;
169 else if (prod_basis_type ==
TENSOR) {
180 else if (prod_basis_type ==
TOTAL) {
190 else if (prod_basis_type ==
SMOLYAK) {
195 bases, index_set, drop));
199 bases, index_set, drop));
204 RCP<Cijk_type> Cijk = basis->computeTripleProductTensor();
206 int basis_size = basis->size();
207 std::cout <<
"basis size = " << basis_size
208 <<
" num nonzero Cijk entries = " << Cijk->
num_entries()
212 RCP<Cijk_type> Cijk_sym = rcp(
new Cijk_type);
213 Cijk_type::i_iterator i_begin = Cijk->i_begin();
214 Cijk_type::i_iterator i_end = Cijk->i_end();
215 for (Cijk_type::i_iterator i_it=i_begin; i_it!=i_end; ++i_it) {
217 Cijk_type::ik_iterator k_begin = Cijk->k_begin(i_it);
218 Cijk_type::ik_iterator k_end = Cijk->k_end(i_it);
219 for (Cijk_type::ik_iterator k_it = k_begin; k_it != k_end; ++k_it) {
221 Cijk_type::ikj_iterator j_begin = Cijk->j_begin(k_it);
222 Cijk_type::ikj_iterator j_end = Cijk->j_end(k_it);
223 for (Cijk_type::ikj_iterator j_it = j_begin; j_it != j_end; ++j_it) {
226 double c =
value(j_it);
227 Cijk_sym->add_term(i,
j, k, c);
232 Cijk_sym->fillComplete();
235 int j_tile_size = i_tile_size / 2;
236 int num_i_parts = (basis_size + i_tile_size-1) / i_tile_size;
237 int its = basis_size / num_i_parts;
238 Array<ITile> i_tiles(num_i_parts);
239 for (
int i=0; i<num_i_parts; ++i) {
240 i_tiles[i].lower = i*its;
241 i_tiles[i].upper = (i+1)*its;
242 i_tiles[i].parts.resize(1);
243 i_tiles[i].parts[0].lower = basis_size;
244 i_tiles[i].parts[0].upper = 0;
248 for (Cijk_type::i_iterator i_it=Cijk_sym->i_begin();
249 i_it!=Cijk_sym->i_end(); ++i_it) {
254 while (idx < num_i_parts && i >= i_tiles[idx].lower) ++idx;
256 TEUCHOS_ASSERT(idx >= 0 && idx < num_i_parts);
258 Cijk_type::ik_iterator k_begin = Cijk_sym->k_begin(i_it);
259 Cijk_type::ik_iterator k_end = Cijk_sym->k_end(i_it);
260 for (Cijk_type::ik_iterator k_it = k_begin; k_it != k_end; ++k_it) {
263 if (
j < i_tiles[idx].parts[0].lower)
264 i_tiles[idx].parts[0].lower =
j;
265 if (
j > i_tiles[idx].parts[0].upper)
266 i_tiles[idx].parts[0].upper =
j;
269 for (
int idx=0; idx<num_i_parts; ++idx) {
270 int lower = i_tiles[idx].parts[0].lower;
271 int upper = i_tiles[idx].parts[0].upper;
272 int range = upper - lower + 1;
273 int num_j_parts = (range + j_tile_size-1) / j_tile_size;
274 int jts = range / num_j_parts;
275 Array<JTile> j_tiles(num_j_parts);
276 for (
int j=0;
j<num_j_parts; ++
j) {
277 j_tiles[
j].lower = lower +
j*jts;
278 j_tiles[
j].upper = lower + (
j+1)*jts;
279 j_tiles[
j].parts.resize(1);
280 j_tiles[
j].parts[0].lower = basis_size;
281 j_tiles[
j].parts[0].upper = 0;
283 i_tiles[idx].parts.swap(j_tiles);
287 for (Cijk_type::i_iterator i_it=Cijk_sym->i_begin();
288 i_it!=Cijk_sym->i_end(); ++i_it) {
293 while (idx < num_i_parts && i >= i_tiles[idx].lower) ++idx;
295 TEUCHOS_ASSERT(idx >= 0 && idx < num_i_parts);
297 Cijk_type::ik_iterator k_begin = Cijk_sym->k_begin(i_it);
298 Cijk_type::ik_iterator k_end = Cijk_sym->k_end(i_it);
299 for (Cijk_type::ik_iterator k_it = k_begin; k_it != k_end; ++k_it) {
303 int num_j_parts = i_tiles[idx].parts.size();
305 while (jdx < num_j_parts && j >= i_tiles[idx].parts[jdx].lower) ++jdx;
307 TEUCHOS_ASSERT(jdx >= 0 && jdx < num_j_parts);
309 Cijk_type::ikj_iterator j_begin = Cijk_sym->j_begin(k_it);
310 Cijk_type::ikj_iterator j_end = Cijk_sym->j_end(k_it);
311 for (Cijk_type::ikj_iterator j_it = j_begin; j_it != j_end; ++j_it) {
316 coord.
i = i; coord.
j =
j; coord.
k = k;
317 i_tiles[idx].parts[jdx].parts[0].parts.push_back(coord);
318 if (k < i_tiles[idx].parts[jdx].parts[0].lower)
319 i_tiles[idx].parts[jdx].parts[0].lower = k;
320 if (k > i_tiles[idx].parts[jdx].parts[0].upper)
321 i_tiles[idx].parts[jdx].parts[0].upper = k;
330 for (
int idx=0; idx<num_i_parts; ++idx) {
331 int num_j_parts = i_tiles[idx].parts.size();
332 for (
int jdx=0; jdx<num_j_parts; ++jdx) {
333 int lower = i_tiles[idx].parts[jdx].parts[0].lower;
334 int upper = i_tiles[idx].parts[jdx].parts[0].upper;
335 int range = upper - lower + 1;
336 int num_k_parts = (range + j_tile_size-1) / j_tile_size;
337 int kts = range / num_k_parts;
338 Array<KTile> k_tiles(num_k_parts);
339 for (
int k=0; k<num_k_parts; ++k) {
340 k_tiles[k].lower = lower + k*kts;
341 k_tiles[k].upper = lower + (k+1)*kts;
343 int num_k = i_tiles[idx].parts[jdx].parts[0].parts.size();
344 for (
int l=0; l<num_k; ++l) {
345 int i = i_tiles[idx].parts[jdx].parts[0].parts[l].i;
346 int j = i_tiles[idx].parts[jdx].parts[0].parts[l].j;
347 int k = i_tiles[idx].parts[jdx].parts[0].parts[l].k;
351 while (kdx < num_k_parts && k >= k_tiles[kdx].lower) ++kdx;
353 TEUCHOS_ASSERT(kdx >= 0 && kdx < num_k_parts);
356 coord.
i = i; coord.
j =
j; coord.
k = k;
357 k_tiles[kdx].parts.push_back(coord);
359 if (
j != k) ++num_coord;
363 Array<KTile> k_tiles2;
364 for (
int k=0; k<num_k_parts; ++k) {
365 if (k_tiles[k].parts.size() > 0)
366 k_tiles2.push_back(k_tiles[k]);
368 num_parts += k_tiles2.size();
369 i_tiles[idx].parts[jdx].parts.swap(k_tiles2);
372 TEUCHOS_ASSERT(num_coord == Cijk->num_entries());
374 std::cout <<
"num parts requested = " << num_parts << std::endl;
377 Teuchos::Array<int> part_IDs(num_parts);
378 for (
int i=0; i<num_parts; ++i)
380 std::random_shuffle(part_IDs.begin(), part_IDs.end());
384 for (
int idx=0; idx<num_i_parts; ++idx) {
385 int num_j_parts = i_tiles[idx].parts.size();
386 for (
int jdx=0; jdx<num_j_parts; ++jdx) {
387 int num_k_parts = i_tiles[idx].parts[jdx].parts.size();
388 for (
int kdx=0; kdx<num_k_parts; ++kdx) {
389 int num_k = i_tiles[idx].parts[jdx].parts[kdx].parts.size();
390 for (
int l=0; l<num_k; ++l) {
391 i_tiles[idx].parts[jdx].parts[kdx].parts[l].gid = part_IDs[pp];
399 for (
int idx=0; idx<num_i_parts; ++idx) {
400 int num_j_parts = i_tiles[idx].parts.size();
401 for (
int jdx=0; jdx<num_j_parts; ++jdx) {
402 int num_k_parts = i_tiles[idx].parts[jdx].parts.size();
403 for (
int kdx=0; kdx<num_k_parts; ++kdx) {
404 std::cout << part++ <<
" : [" 405 << i_tiles[idx].lower <<
"," 406 << i_tiles[idx].upper <<
") x [" 407 << i_tiles[idx].parts[jdx].lower <<
"," 408 << i_tiles[idx].parts[jdx].upper <<
") x [" 409 << i_tiles[idx].parts[jdx].parts[kdx].lower <<
"," 410 << i_tiles[idx].parts[jdx].parts[kdx].upper <<
") : " 411 << i_tiles[idx].parts[jdx].parts[kdx].parts.size()
418 std::ofstream cijk_file;
420 cijk_file.open(file_3tensor.c_str());
421 cijk_file.precision(14);
422 cijk_file.setf(std::ios::scientific);
423 cijk_file <<
"i, j, k, part" << std::endl;
424 for (
int idx=0; idx<num_i_parts; ++idx) {
425 int num_j_parts = i_tiles[idx].parts.size();
426 for (
int jdx=0; jdx<num_j_parts; ++jdx) {
427 int num_k_parts = i_tiles[idx].parts[jdx].parts.size();
428 for (
int kdx=0; kdx<num_k_parts; ++kdx) {
429 int num_k = i_tiles[idx].parts[jdx].parts[kdx].parts.size();
430 for (
int l=0; l<num_k; ++l) {
431 Coord c = i_tiles[idx].parts[jdx].parts[kdx].parts[l];
432 cijk_file << c.
i <<
", " << c.
j <<
", " << c.
k <<
", " << c.
gid 435 cijk_file << c.
i <<
", " << c.
k <<
", " << c.
j <<
", " << c.
gid 446 catch (std::exception& e) {
447 std::cout << e.what() << std::endl;
SparseArrayIterator< index_iterator, value_iterator >::value_type index(const SparseArrayIterator< index_iterator, value_iterator > &it)
Multivariate orthogonal polynomial basis generated from a total order tensor product of univariate po...
GrowthPolicy
Enumerated type for determining Smolyak growth policies.
const ProductBasisType prod_basis_type_values[]
A comparison functor implementing a strict weak ordering based total-order ordering, recursive on the dimension.
int main(int argc, char **argv)
const char * ordering_type_names[]
const int num_growth_types
const char * growth_type_names[]
ordinal_type num_entries() const
Return number of non-zero entries.
Multivariate orthogonal polynomial basis generated from a total-order complete-polynomial tensor prod...
Multivariate orthogonal polynomial basis generated from a Smolyak sparse grid.
Multivariate orthogonal polynomial basis generated from a tensor product of univariate polynomials...
Stokhos::Sparse3Tensor< int, double > Cijk_type
An isotropic total order index set.
SparseArrayIterator< index_iterator, value_iterator >::value_reference value(const SparseArrayIterator< index_iterator, value_iterator > &it)
const Stokhos::GrowthPolicy growth_type_values[]
A comparison functor implementing a strict weak ordering based lexographic ordering.
const int num_prod_basis_types
const char * prod_basis_type_names[]
const int num_ordering_types
const OrderingType ordering_type_values[]