Stokhos Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Stokhos_SGModelEvaluator_Adaptive.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_SGModelEvaluator_Adaptive.hpp"
11 
12 #include <algorithm>
13 #include "Teuchos_Assert.hpp"
14 #include "EpetraExt_BlockUtility.h"
15 #include "EpetraExt_BlockMultiVector.h"
16 #include "Stokhos_SGPreconditionerFactory.hpp"
17 #include "Stokhos_MatrixFreeOperator.hpp"
18 #include "Stokhos_EpetraMultiVectorOperator.hpp"
19 #include "Stokhos_AdaptivityUtils.hpp"
20 #include "Epetra_LocalMap.h"
21 #include "Epetra_Export.h"
22 #include "Epetra_Import.h"
23 
24 Stokhos::SGModelEvaluator_Adaptive::SGModelEvaluator_Adaptive(
25  const Teuchos::RCP<EpetraExt::ModelEvaluator>& me_,
26  const Teuchos::RCP<Stokhos::AdaptivityManager> & am,
27  const Teuchos::RCP<const Stokhos::Quadrature<int,double> >& sg_quad_,
28  const Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double> >& sg_exp_,
29  const Teuchos::RCP<const Stokhos::ParallelData>& sg_parallel_data_,
30  bool onlyUseLinear_,int kExpOrder_,
31  const Teuchos::RCP<Teuchos::ParameterList>& params_)
32  : me(me_),
33  sg_basis(am->getMasterStochasticBasis()),
34  sg_row_dof_basis(am->getRowStochasticBasis()),
35  sg_quad(sg_quad_),
36  sg_exp(sg_exp_),
37  params(params_),
38  num_sg_blocks(sg_basis->size()),
39  num_W_blocks(sg_basis->size()),
40  num_p_blocks(sg_basis->size()),
41  supports_x(false),
42  x_map(me->get_x_map()),
43  f_map(me->get_f_map()),
44  sg_parallel_data(sg_parallel_data_),
45  sg_comm(sg_parallel_data->getMultiComm()),
46  epetraCijk(sg_parallel_data->getEpetraCijk()),
47  serialCijk(),
48  Cijk(epetraCijk->getParallelCijk()),
49  num_p(0),
50  num_p_sg(0),
51  sg_p_index_map(),
52  sg_p_map(),
53  sg_p_names(),
54  num_g(0),
55  num_g_sg(0),
56  sg_g_index_map(),
57  sg_g_map(),
58  x_dot_sg_blocks(),
59  x_sg_blocks(),
60  f_sg_blocks(),
61  W_sg_blocks(),
62  dgdx_dot_sg_blocks(),
63  dgdx_sg_blocks(),
64  sg_x_init(),
65  sg_p_init(),
66  eval_W_with_f(false),
67  kExpOrder(kExpOrder_),
68  onlyUseLinear(onlyUseLinear_),
69  scaleOP(am->isScaled()),
70  adaptMngr(am)
71 {
72  if (x_map != Teuchos::null)
73  supports_x = true;
74 
75  overlapped_stoch_row_map =
76  Teuchos::rcp(new Epetra_LocalMap(static_cast<int>(num_sg_blocks), 0, *(sg_parallel_data->getStochasticComm())));
77  stoch_row_map = overlapped_stoch_row_map;
78 
79  if (epetraCijk != Teuchos::null)
80  stoch_row_map = epetraCijk->getStochasticRowMap();
81 
82  if (supports_x) {
83 
84  // Create block SG x and f maps
85  sg_x_map =
86  Teuchos::rcp(EpetraExt::BlockUtility::GenerateBlockMap(
87  *x_map, *stoch_row_map, *sg_comm));
88  sg_overlapped_x_map =
89  Teuchos::rcp(EpetraExt::BlockUtility::GenerateBlockMap(
90  *x_map, *overlapped_stoch_row_map, *sg_comm));
91 
92  sg_f_map =
93  Teuchos::rcp(EpetraExt::BlockUtility::GenerateBlockMap(
94  *f_map, *stoch_row_map, *sg_comm));
95  sg_overlapped_f_map =
96  Teuchos::rcp(EpetraExt::BlockUtility::GenerateBlockMap(
97  *f_map, *overlapped_stoch_row_map, *sg_comm));
98 
99  // Create interlace SG x and f maps
100  adapted_x_map = adaptMngr->getAdaptedMap();
101  adapted_overlapped_x_map = adapted_x_map;
102 
103  adapted_f_map = adapted_x_map; // these are the same! No overlap possible in refinement!
104  adapted_overlapped_f_map = adapted_x_map;
105 
106  // Create importer/exporter from/to overlapped distribution
107  adapted_overlapped_x_importer =
108  Teuchos::rcp(new Epetra_Import(*adapted_overlapped_x_map, *get_x_map()));
109  adapted_overlapped_f_exporter =
110  Teuchos::rcp(new Epetra_Export(*adapted_overlapped_f_map, *adapted_f_map));
111 
112  // now we create the underlying Epetra block vectors
113  // that will be used by the model evaluator to construct
114  // the solution of the deterministic problem.
116 
117  // Create vector blocks
118  x_dot_sg_blocks = create_x_sg_overlap();
119  x_sg_blocks = create_x_sg_overlap();
120  f_sg_blocks = create_f_sg_overlap();
121 
122  // Create default sg_x_init
123  sg_x_init = create_x_sg();
124  if (sg_x_init->myGID(0))
125  (*sg_x_init)[0] = *(me->get_x_init());
126 
127  // Preconditioner needs an x: This is adapted
128  my_x = Teuchos::rcp(new Epetra_Vector(*get_x_map()));
129 
130  // setup storage for W, these are blocked in Stokhos
131  // format
133 
134  // Determine W expansion type
135  std::string W_expansion_type =
136  params->get("Jacobian Expansion Type", "Full");
137  if (W_expansion_type == "Linear")
138  num_W_blocks = sg_basis->dimension() + 1;
139  else
140  num_W_blocks = num_sg_blocks;
141 
142  Teuchos::RCP<Epetra_BlockMap> W_overlap_map =
143  Teuchos::rcp(new Epetra_LocalMap(
144  static_cast<int>(num_W_blocks), 0,
145  *(sg_parallel_data->getStochasticComm())));
146  W_sg_blocks =
147  Teuchos::rcp(new Stokhos::EpetraOperatorOrthogPoly(
148  sg_basis, W_overlap_map, x_map, f_map, adapted_f_map,
149  sg_comm));
150  for (unsigned int i=0; i<num_W_blocks; i++)
151  W_sg_blocks->setCoeffPtr(i, me->create_W()); // allocate a bunch of matrices
152 
153  eval_W_with_f = params->get("Evaluate W with F", false);
154  }
155 
156  // Parameters -- The idea here is to add new parameter vectors
157  // for the stochastic Galerkin components of the parameters
158 
159  InArgs me_inargs = me->createInArgs();
160  OutArgs me_outargs = me->createOutArgs();
161  num_p = me_inargs.Np();
162 
163  // Get the p_sg's supported and build index map
164  for (int i=0; i<num_p; i++) {
165  if (me_inargs.supports(IN_ARG_p_sg, i))
166  sg_p_index_map.push_back(i);
167  }
168  num_p_sg = sg_p_index_map.size();
169 
170  sg_p_map.resize(num_p_sg);
171  sg_p_names.resize(num_p_sg);
172  sg_p_init.resize(num_p_sg);
173 
174  // Determine parameter expansion type
175  std::string p_expansion_type =
176  params->get("Parameter Expansion Type", "Full");
177  if (p_expansion_type == "Linear")
178  num_p_blocks = sg_basis->dimension() + 1;
179  else
180  num_p_blocks = num_sg_blocks;
181 
182  // Create parameter maps, names, and initial values
183  overlapped_stoch_p_map =
184  Teuchos::rcp(new Epetra_LocalMap(
185  static_cast<int>(num_p_blocks), 0,
186  *(sg_parallel_data->getStochasticComm())));
187  for (int i=0; i<num_p_sg; i++) {
188  Teuchos::RCP<const Epetra_Map> p_map = me->get_p_map(sg_p_index_map[i]);
189  sg_p_map[i] =
190  Teuchos::rcp(EpetraExt::BlockUtility::GenerateBlockMap(
191  *p_map, *overlapped_stoch_p_map, *sg_comm));
192 
193  Teuchos::RCP<const Teuchos::Array<std::string> > p_names =
194  me->get_p_names(sg_p_index_map[i]);
195  if (p_names != Teuchos::null) {
196  sg_p_names[i] =
197  Teuchos::rcp(new Teuchos::Array<std::string>(num_sg_blocks*(p_names->size())));
198  for (int j=0; j<p_names->size(); j++) {
199  std::stringstream ss;
200  ss << (*p_names)[j] << " -- SG Coefficient " << i;
201  (*sg_p_names[i])[j] = ss.str();
202  }
203  }
204 
205  // Create default sg_p_init
206  sg_p_init[i] = create_p_sg(sg_p_index_map[i]);
207  sg_p_init[i]->init(0.0);
208  }
209 
210  // Responses -- The idea here is to add new parameter vectors
211  // for the stochastic Galerkin components of the respones
212  num_g = me_outargs.Ng();
213 
214  // Get the g_sg's supported and build index map
215  for (int i=0; i<num_g; i++) {
216  if (me_outargs.supports(OUT_ARG_g_sg, i))
217  sg_g_index_map.push_back(i);
218  }
219  num_g_sg = sg_g_index_map.size();
220 
221  sg_g_map.resize(num_g_sg);
222  dgdx_dot_sg_blocks.resize(num_g_sg);
223  dgdx_sg_blocks.resize(num_g_sg);
224 
225  // Create response maps
226  for (int i=0; i<num_g_sg; i++) {
227  Teuchos::RCP<const Epetra_Map> g_map = me->get_g_map(sg_g_index_map[i]);
228  sg_g_map[i] =
229  Teuchos::rcp(EpetraExt::BlockUtility::GenerateBlockMap(
230  *g_map, *overlapped_stoch_row_map, *sg_comm));
231 
232  // Create dg/dxdot, dg/dx SG blocks
233  if (supports_x) {
234  dgdx_dot_sg_blocks[i] =
235  Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
236  sg_basis, overlapped_stoch_row_map));
237  dgdx_sg_blocks[i] =
238  Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
239  sg_basis, overlapped_stoch_row_map));
240  }
241  }
242 
243  // We don't support parallel for dgdx yet, so build a new EpetraCijk
244  if (supports_x) {
245  serialCijk =
246  Teuchos::rcp(new Stokhos::EpetraSparse3Tensor(sg_basis,
247  epetraCijk->getCijk(),
248  sg_comm,
249  overlapped_stoch_row_map));
250  }
251 
252 }
253 
254 Stokhos::SGModelEvaluator_Adaptive::SGModelEvaluator_Adaptive(
255  const Teuchos::RCP<EpetraExt::ModelEvaluator>& me_,
256  const Teuchos::RCP<const Stokhos::OrthogPolyBasis<int,double> >& sg_basis_,
257  const std::vector<Teuchos::RCP<const Stokhos::ProductBasis<int,double> > > & sg_row_dof_basis_,
258  const Teuchos::RCP<const Stokhos::Quadrature<int,double> >& sg_quad_,
259  const Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double> >& sg_exp_,
260  const Teuchos::RCP<const Stokhos::ParallelData>& sg_parallel_data_,
261  bool onlyUseLinear_,int kExpOrder_,
262  const Teuchos::RCP<Teuchos::ParameterList>& params_,
263  bool scaleOP_)
264  : me(me_),
265  sg_basis(sg_basis_),
266  sg_row_dof_basis(sg_row_dof_basis_),
267  sg_quad(sg_quad_),
268  sg_exp(sg_exp_),
269  params(params_),
270  num_sg_blocks(sg_basis->size()),
271  num_W_blocks(sg_basis->size()),
272  num_p_blocks(sg_basis->size()),
273  supports_x(false),
274  x_map(me->get_x_map()),
275  f_map(me->get_f_map()),
276  sg_parallel_data(sg_parallel_data_),
277  sg_comm(sg_parallel_data->getMultiComm()),
278  epetraCijk(sg_parallel_data->getEpetraCijk()),
279  serialCijk(),
280  Cijk(epetraCijk->getParallelCijk()),
281  num_p(0),
282  num_p_sg(0),
283  sg_p_index_map(),
284  sg_p_map(),
285  sg_p_names(),
286  num_g(0),
287  num_g_sg(0),
288  sg_g_index_map(),
289  sg_g_map(),
290  x_dot_sg_blocks(),
291  x_sg_blocks(),
292  f_sg_blocks(),
293  W_sg_blocks(),
294  dgdx_dot_sg_blocks(),
295  dgdx_sg_blocks(),
296  sg_x_init(),
297  sg_p_init(),
298  eval_W_with_f(false),
299  kExpOrder(kExpOrder_),
300  onlyUseLinear(onlyUseLinear_),
301  scaleOP(scaleOP_)
302 {
303  if (x_map != Teuchos::null)
304  supports_x = true;
305 
306  adaptMngr = Teuchos::rcp(new Stokhos::AdaptivityManager(Teuchos::rcp_dynamic_cast<const Stokhos::ProductBasis<int,double> >(sg_basis),
307  sg_row_dof_basis,*sg_parallel_data->getStochasticComm(),scaleOP));
308 
309  overlapped_stoch_row_map =
310  Teuchos::rcp(new Epetra_LocalMap(static_cast<int>(num_sg_blocks), 0, *(sg_parallel_data->getStochasticComm())));
311  stoch_row_map = overlapped_stoch_row_map;
312 
313  if (epetraCijk != Teuchos::null)
314  stoch_row_map = epetraCijk->getStochasticRowMap();
315 
316  if (supports_x) {
317 
318  // Create block SG x and f maps
319  sg_x_map =
320  Teuchos::rcp(EpetraExt::BlockUtility::GenerateBlockMap(
321  *x_map, *stoch_row_map, *sg_comm));
322  sg_overlapped_x_map =
323  Teuchos::rcp(EpetraExt::BlockUtility::GenerateBlockMap(
324  *x_map, *overlapped_stoch_row_map, *sg_comm));
325 
326  sg_f_map =
327  Teuchos::rcp(EpetraExt::BlockUtility::GenerateBlockMap(
328  *f_map, *stoch_row_map, *sg_comm));
329  sg_overlapped_f_map =
330  Teuchos::rcp(EpetraExt::BlockUtility::GenerateBlockMap(
331  *f_map, *overlapped_stoch_row_map, *sg_comm));
332 
333  // Create interlace SG x and f maps
334  adapted_x_map = adaptMngr->getAdaptedMap();
335  adapted_overlapped_x_map = adapted_x_map;
336 
337  adapted_f_map = adapted_x_map; // these are the same! No overlap possible in refinement!
338  adapted_overlapped_f_map = adapted_x_map;
339 
340  // Create importer/exporter from/to overlapped distribution
341  adapted_overlapped_x_importer =
342  Teuchos::rcp(new Epetra_Import(*adapted_overlapped_x_map, *get_x_map()));
343  adapted_overlapped_f_exporter =
344  Teuchos::rcp(new Epetra_Export(*adapted_overlapped_f_map, *adapted_f_map));
345 
346  // now we create the underlying Epetra block vectors
347  // that will be used by the model evaluator to construct
348  // the solution of the deterministic problem.
350 
351  // Create vector blocks
352  x_dot_sg_blocks = create_x_sg_overlap();
353  x_sg_blocks = create_x_sg_overlap();
354  f_sg_blocks = create_f_sg_overlap();
355 
356  // Create default sg_x_init
357  sg_x_init = create_x_sg();
358  if (sg_x_init->myGID(0))
359  (*sg_x_init)[0] = *(me->get_x_init());
360 
361  // Preconditioner needs an x: This is adapted
362  my_x = Teuchos::rcp(new Epetra_Vector(*get_x_map()));
363 
364  // setup storage for W, these are blocked in Stokhos
365  // format
367 
368  // Determine W expansion type
369  std::string W_expansion_type =
370  params->get("Jacobian Expansion Type", "Full");
371  if (W_expansion_type == "Linear")
372  num_W_blocks = sg_basis->dimension() + 1;
373  else
374  num_W_blocks = num_sg_blocks;
375 
376  Teuchos::RCP<Epetra_BlockMap> W_overlap_map =
377  Teuchos::rcp(new Epetra_LocalMap(
378  static_cast<int>(num_W_blocks), 0,
379  *(sg_parallel_data->getStochasticComm())));
380  W_sg_blocks =
381  Teuchos::rcp(new Stokhos::EpetraOperatorOrthogPoly(
382  sg_basis, W_overlap_map, x_map, f_map, adapted_f_map,
383  sg_comm));
384  for (unsigned int i=0; i<num_W_blocks; i++)
385  W_sg_blocks->setCoeffPtr(i, me->create_W()); // allocate a bunch of matrices
386 
387  eval_W_with_f = params->get("Evaluate W with F", false);
388  }
389 
390  // Parameters -- The idea here is to add new parameter vectors
391  // for the stochastic Galerkin components of the parameters
392 
393  InArgs me_inargs = me->createInArgs();
394  OutArgs me_outargs = me->createOutArgs();
395  num_p = me_inargs.Np();
396 
397  // Get the p_sg's supported and build index map
398  for (int i=0; i<num_p; i++) {
399  if (me_inargs.supports(IN_ARG_p_sg, i))
400  sg_p_index_map.push_back(i);
401  }
402  num_p_sg = sg_p_index_map.size();
403 
404  sg_p_map.resize(num_p_sg);
405  sg_p_names.resize(num_p_sg);
406  sg_p_init.resize(num_p_sg);
407 
408  // Determine parameter expansion type
409  std::string p_expansion_type =
410  params->get("Parameter Expansion Type", "Full");
411  if (p_expansion_type == "Linear")
412  num_p_blocks = sg_basis->dimension() + 1;
413  else
414  num_p_blocks = num_sg_blocks;
415 
416  // Create parameter maps, names, and initial values
417  overlapped_stoch_p_map =
418  Teuchos::rcp(new Epetra_LocalMap(
419  static_cast<int>(num_p_blocks), 0,
420  *(sg_parallel_data->getStochasticComm())));
421  for (int i=0; i<num_p_sg; i++) {
422  Teuchos::RCP<const Epetra_Map> p_map = me->get_p_map(sg_p_index_map[i]);
423  sg_p_map[i] =
424  Teuchos::rcp(EpetraExt::BlockUtility::GenerateBlockMap(
425  *p_map, *overlapped_stoch_p_map, *sg_comm));
426 
427  Teuchos::RCP<const Teuchos::Array<std::string> > p_names =
428  me->get_p_names(sg_p_index_map[i]);
429  if (p_names != Teuchos::null) {
430  sg_p_names[i] =
431  Teuchos::rcp(new Teuchos::Array<std::string>(num_sg_blocks*(p_names->size())));
432  for (int j=0; j<p_names->size(); j++) {
433  std::stringstream ss;
434  ss << (*p_names)[j] << " -- SG Coefficient " << i;
435  (*sg_p_names[i])[j] = ss.str();
436  }
437  }
438 
439  // Create default sg_p_init
440  sg_p_init[i] = create_p_sg(sg_p_index_map[i]);
441  sg_p_init[i]->init(0.0);
442  }
443 
444  // Responses -- The idea here is to add new parameter vectors
445  // for the stochastic Galerkin components of the respones
446  num_g = me_outargs.Ng();
447 
448  // Get the g_sg's supported and build index map
449  for (int i=0; i<num_g; i++) {
450  if (me_outargs.supports(OUT_ARG_g_sg, i))
451  sg_g_index_map.push_back(i);
452  }
453  num_g_sg = sg_g_index_map.size();
454 
455  sg_g_map.resize(num_g_sg);
456  dgdx_dot_sg_blocks.resize(num_g_sg);
457  dgdx_sg_blocks.resize(num_g_sg);
458 
459  // Create response maps
460  for (int i=0; i<num_g_sg; i++) {
461  Teuchos::RCP<const Epetra_Map> g_map = me->get_g_map(sg_g_index_map[i]);
462  sg_g_map[i] =
463  Teuchos::rcp(EpetraExt::BlockUtility::GenerateBlockMap(
464  *g_map, *overlapped_stoch_row_map, *sg_comm));
465 
466  // Create dg/dxdot, dg/dx SG blocks
467  if (supports_x) {
468  dgdx_dot_sg_blocks[i] =
469  Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
470  sg_basis, overlapped_stoch_row_map));
471  dgdx_sg_blocks[i] =
472  Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
473  sg_basis, overlapped_stoch_row_map));
474  }
475  }
476 
477  // We don't support parallel for dgdx yet, so build a new EpetraCijk
478  if (supports_x) {
479  serialCijk =
480  Teuchos::rcp(new Stokhos::EpetraSparse3Tensor(sg_basis,
481  epetraCijk->getCijk(),
482  sg_comm,
483  overlapped_stoch_row_map));
484  }
485 
486 }
487 
488 // Overridden from EpetraExt::ModelEvaluator
489 
490 Teuchos::RCP<const Epetra_Map>
491 Stokhos::SGModelEvaluator_Adaptive::get_x_map() const
492 {
493  return adapted_x_map;
494 }
495 
496 Teuchos::RCP<const Epetra_Map>
497 Stokhos::SGModelEvaluator_Adaptive::get_f_map() const
498 {
499  return adapted_f_map;
500 }
501 
502 Teuchos::RCP<const Epetra_Map>
503 Stokhos::SGModelEvaluator_Adaptive::get_p_map(int l) const
504 {
505  TEUCHOS_TEST_FOR_EXCEPTION(l < 0 || l >= num_p + num_p_sg, std::logic_error,
506  "Error! Invalid p map index " << l);
507  if (l < num_p)
508  return me->get_p_map(l);
509  else
510  return sg_p_map[l-num_p];
511 
512  return Teuchos::null;
513 }
514 
515 Teuchos::RCP<const Epetra_Map>
516 Stokhos::SGModelEvaluator_Adaptive::get_g_map(int l) const
517 {
518  TEUCHOS_TEST_FOR_EXCEPTION(l < 0 || l >= num_g_sg, std::logic_error,
519  "Error! Invalid g map index " << l);
520  return sg_g_map[l];
521 }
522 
523 Teuchos::RCP<const Teuchos::Array<std::string> >
524 Stokhos::SGModelEvaluator_Adaptive::get_p_names(int l) const
525 {
526  TEUCHOS_TEST_FOR_EXCEPTION(l < 0 || l >= num_p + num_p_sg, std::logic_error,
527  "Error! Invalid p map index " << l);
528  if (l < num_p)
529  return me->get_p_names(l);
530  else
531  return sg_p_names[l-num_p];
532 
533  return Teuchos::null;
534 }
535 
536 Teuchos::RCP<const Epetra_Vector>
537 Stokhos::SGModelEvaluator_Adaptive::get_x_init() const
538 {
539  // get stochastic galerking initial condition and write it out to x initial condition
540  Teuchos::RCP<Epetra_Vector> x_init = Teuchos::rcp(new Epetra_Vector(*get_x_map()));
541  adaptMngr->copyToAdaptiveVector(*get_x_sg_init(),*x_init);
542 
543  return x_init;
544 }
545 
546 Teuchos::RCP<const Epetra_Vector>
547 Stokhos::SGModelEvaluator_Adaptive::get_p_init(int l) const
548 {
549  TEUCHOS_TEST_FOR_EXCEPTION(l < 0 || l >= num_p + num_p_sg, std::logic_error,
550  "Error! Invalid p map index " << l);
551  if (l < num_p)
552  return me->get_p_init(l);
553  else
554  return sg_p_init[l-num_p]->getBlockVector();
555 
556  return Teuchos::null;
557 }
558 
559 Teuchos::RCP<Epetra_Operator>
560 Stokhos::SGModelEvaluator_Adaptive::create_W() const
561 {
562  if (supports_x) {
563  Teuchos::RCP<Teuchos::ParameterList> sgOpParams =
564  Teuchos::rcp(&(params->sublist("SG Operator")), false);
565 
566  Teuchos::RCP<Epetra_CrsMatrix> W_crs
567  = Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(me->create_W(), true);
568  const Epetra_CrsGraph & W_graph = W_crs->Graph();
569 
570  adaptMngr->setupWithGraph(W_graph,onlyUseLinear,kExpOrder);
571  my_W = adaptMngr->buildMatrixFromGraph();
572  adaptMngr->setupOperator(*my_W,*Cijk,*W_sg_blocks);
573 
574  return my_W;
575  }
576 
577  return Teuchos::null;
578 }
579 
580 EpetraExt::ModelEvaluator::InArgs
581 Stokhos::SGModelEvaluator_Adaptive::createInArgs() const
582 {
583  InArgsSetup inArgs;
584  InArgs me_inargs = me->createInArgs();
585 
586  inArgs.setModelEvalDescription(this->description());
587  inArgs.set_Np(num_p + num_p_sg);
588  inArgs.setSupports(IN_ARG_x_dot, me_inargs.supports(IN_ARG_x_dot_sg));
589  inArgs.setSupports(IN_ARG_x, me_inargs.supports(IN_ARG_x_sg));
590  inArgs.setSupports(IN_ARG_t, me_inargs.supports(IN_ARG_t));
591  inArgs.setSupports(IN_ARG_alpha, me_inargs.supports(IN_ARG_alpha));
592  inArgs.setSupports(IN_ARG_beta, me_inargs.supports(IN_ARG_beta));
593  inArgs.setSupports(IN_ARG_sg_basis, me_inargs.supports(IN_ARG_sg_basis));
594  inArgs.setSupports(IN_ARG_sg_quadrature,
595  me_inargs.supports(IN_ARG_sg_quadrature));
596  inArgs.setSupports(IN_ARG_sg_expansion,
597  me_inargs.supports(IN_ARG_sg_expansion));
598 
599  return inArgs;
600 }
601 
602 EpetraExt::ModelEvaluator::OutArgs
603 Stokhos::SGModelEvaluator_Adaptive::createOutArgs() const
604 {
605  OutArgsSetup outArgs;
606  OutArgs me_outargs = me->createOutArgs();
607 
608  outArgs.setModelEvalDescription(this->description());
609  outArgs.set_Np_Ng(num_p+num_p_sg, num_g_sg);
610 
611  outArgs.setSupports(OUT_ARG_f, me_outargs.supports(OUT_ARG_f_sg));
612  outArgs.setSupports(OUT_ARG_W, me_outargs.supports(OUT_ARG_W_sg));
613  outArgs.setSupports(OUT_ARG_WPrec, false);
614  for (int j=0; j<num_p; j++)
615  outArgs.setSupports(OUT_ARG_DfDp, j,
616  me_outargs.supports(OUT_ARG_DfDp_sg, j));
617 
618  for (int i=0; i<num_g_sg; i++) {
619  int ii = sg_g_index_map[i];
620 // if (!me_outargs.supports(OUT_ARG_DgDx_dot_sg, ii).none())
621 // outArgs.setSupports(OUT_ARG_DgDx_dot, i, DERIV_LINEAR_OP);
622 // if (!me_outargs.supports(OUT_ARG_DgDx_sg, ii).none())
623 // outArgs.setSupports(OUT_ARG_DgDx, i, DERIV_LINEAR_OP);
624  for (int j=0; j<num_p; j++)
625  outArgs.setSupports(OUT_ARG_DgDp, i, j,
626  me_outargs.supports(OUT_ARG_DgDp_sg, ii, j));
627  }
628 
629  // We do not support derivatives w.r.t. the new SG parameters, so their
630  // support defaults to none.
631 
632  return outArgs;
633 }
634 
635 void
636 Stokhos::SGModelEvaluator_Adaptive::evalModel(const InArgs& inArgs,
637  const OutArgs& outArgs) const
638 {
639  // Get the input arguments
640  Teuchos::RCP<const Epetra_Vector> x;
641  if (inArgs.supports(IN_ARG_x)) {
642  x = inArgs.get_x();
643  if (x != Teuchos::null)
644  *my_x = *x;
645  }
646  Teuchos::RCP<const Epetra_Vector> x_dot;
647  if (inArgs.supports(IN_ARG_x_dot))
648  x_dot = inArgs.get_x_dot();
649 
650  // Get the output arguments
651  EpetraExt::ModelEvaluator::Evaluation<Epetra_Vector> f_out;
652  if (outArgs.supports(OUT_ARG_f))
653  f_out = outArgs.get_f();
654  Teuchos::RCP<Epetra_Operator> W_out;
655  if (outArgs.supports(OUT_ARG_W))
656  W_out = outArgs.get_W();
657 
658  // Create underlying inargs
659  InArgs me_inargs = me->createInArgs();
660  if (x != Teuchos::null) {
661  // copy to a poly orthog vector
662  adaptMngr->copyFromAdaptiveVector(*x,*x_sg_blocks);
663  me_inargs.set_x_sg(x_sg_blocks);
664  }
665  if (x_dot != Teuchos::null) {
666  // copy to a poly orthog vector
667  adaptMngr->copyFromAdaptiveVector(*x_dot,*x_dot_sg_blocks);
668  me_inargs.set_x_dot_sg(x_dot_sg_blocks);
669  }
670  if (me_inargs.supports(IN_ARG_alpha))
671  me_inargs.set_alpha(inArgs.get_alpha());
672  if (me_inargs.supports(IN_ARG_beta))
673  me_inargs.set_beta(inArgs.get_beta());
674  if (me_inargs.supports(IN_ARG_t))
675  me_inargs.set_t(inArgs.get_t());
676  if (me_inargs.supports(IN_ARG_sg_basis)) {
677  if (inArgs.get_sg_basis() != Teuchos::null)
678  me_inargs.set_sg_basis(inArgs.get_sg_basis());
679  else
680  me_inargs.set_sg_basis(sg_basis);
681  }
682  if (me_inargs.supports(IN_ARG_sg_quadrature)) {
683  if (inArgs.get_sg_quadrature() != Teuchos::null)
684  me_inargs.set_sg_quadrature(inArgs.get_sg_quadrature());
685  else
686  me_inargs.set_sg_quadrature(sg_quad);
687  }
688  if (me_inargs.supports(IN_ARG_sg_expansion)) {
689  if (inArgs.get_sg_expansion() != Teuchos::null)
690  me_inargs.set_sg_expansion(inArgs.get_sg_expansion());
691  else
692  me_inargs.set_sg_expansion(sg_exp);
693  }
694 
695  // Pass parameters
696  for (int i=0; i<num_p; i++)
697  me_inargs.set_p(i, inArgs.get_p(i));
698  for (int i=0; i<num_p_sg; i++) {
699  Teuchos::RCP<const Epetra_Vector> p = inArgs.get_p(i+num_p);
700 
701  // We always need to pass in the SG parameters, so just use
702  // the initial parameters if it is NULL
703  if (p == Teuchos::null)
704  p = sg_p_init[i]->getBlockVector();
705 
706  // Convert block p to SG polynomial
707  Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> p_sg =
708  create_p_sg(sg_p_index_map[i], View, p.get());
709  me_inargs.set_p_sg(sg_p_index_map[i], p_sg);
710  }
711 
712  // Create underlying outargs
713  OutArgs me_outargs = me->createOutArgs();
714 
715  // f
716  if (f_out != Teuchos::null) {
717  me_outargs.set_f_sg(f_sg_blocks);
718  if (eval_W_with_f)
719  me_outargs.set_W_sg(W_sg_blocks);
720  }
721 
722  // W
723  if (W_out != Teuchos::null && !eval_W_with_f )
724  me_outargs.set_W_sg(W_sg_blocks);
725 
726  // df/dp
727  for (int i=0; i<num_p; i++) {
728  if (!outArgs.supports(OUT_ARG_DfDp, i).none()) {
729  Derivative dfdp = outArgs.get_DfDp(i);
730  if (dfdp.getMultiVector() != Teuchos::null) {
731  Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly> dfdp_sg;
732  if (dfdp.getMultiVectorOrientation() == DERIV_MV_BY_COL)
733  dfdp_sg =
734  Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
735  sg_basis, overlapped_stoch_row_map,
736  me->get_f_map(), sg_comm,
737  me->get_p_map(i)->NumMyElements()));
738  else if (dfdp.getMultiVectorOrientation() == DERIV_TRANS_MV_BY_ROW)
739  dfdp_sg =
740  Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
741  sg_basis, overlapped_stoch_row_map,
742  me->get_p_map(i), sg_comm,
743  me->get_f_map()->NumMyElements()));
744  me_outargs.set_DfDp_sg(i,
745  SGDerivative(dfdp_sg,
746  dfdp.getMultiVectorOrientation()));
747  }
748  TEUCHOS_TEST_FOR_EXCEPTION(dfdp.getLinearOp() != Teuchos::null, std::logic_error,
749  "Error! Stokhos::SGModelEvaluator_Adaptive::evalModel " <<
750  "cannot handle operator form of df/dp!");
751  }
752  }
753 
754  // Responses (g, dg/dx, dg/dp, ...)
755  for (int i=0; i<num_g_sg; i++) {
756  int ii = sg_g_index_map[i];
757 
758  // g
759  Teuchos::RCP<Epetra_Vector> g = outArgs.get_g(i);
760  if (g != Teuchos::null) {
761  Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> g_sg =
762  create_g_sg(sg_g_index_map[i], View, g.get());
763  me_outargs.set_g_sg(ii, g_sg);
764  }
765 
766  // dg/dxdot
767  if (outArgs.supports(OUT_ARG_DgDx_dot, i).supports(DERIV_LINEAR_OP)) {
768  Derivative dgdx_dot = outArgs.get_DgDx_dot(i);
769  if (dgdx_dot.getLinearOp() != Teuchos::null) {
770  Teuchos::RCP<Stokhos::SGOperator> op =
771  Teuchos::rcp_dynamic_cast<Stokhos::SGOperator>(
772  dgdx_dot.getLinearOp(), true);
773  Teuchos::RCP< Stokhos::EpetraOperatorOrthogPoly > sg_blocks =
774  op->getSGPolynomial();
775  if (me_outargs.supports(OUT_ARG_DgDx, ii).supports(DERIV_LINEAR_OP))
776  me_outargs.set_DgDx_dot_sg(ii, sg_blocks);
777  else {
778  for (unsigned int k=0; k<num_sg_blocks; k++) {
779  Teuchos::RCP<Epetra_MultiVector> mv =
780  Teuchos::rcp_dynamic_cast<Stokhos::EpetraMultiVectorOperator>(
781  sg_blocks->getCoeffPtr(k), true)->getMultiVector();
782  dgdx_dot_sg_blocks[i]->setCoeffPtr(k, mv);
783  }
784  if (me_outargs.supports(OUT_ARG_DgDx_dot_sg, ii).supports(DERIV_MV_BY_COL))
785  me_outargs.set_DgDx_dot_sg(ii, SGDerivative(dgdx_dot_sg_blocks[i],
786  DERIV_MV_BY_COL));
787  else
788  me_outargs.set_DgDx_dot_sg(ii, SGDerivative(dgdx_dot_sg_blocks[i],
789  DERIV_TRANS_MV_BY_ROW));
790  }
791  }
792  TEUCHOS_TEST_FOR_EXCEPTION(dgdx_dot.getLinearOp() == Teuchos::null &&
793  dgdx_dot.isEmpty() == false,
794  std::logic_error,
795  "Error! Stokhos::SGModelEvaluator_Adaptive::evalModel: " <<
796  "Operator form of dg/dxdot is required!");
797  }
798 
799  // dg/dx
800  if (outArgs.supports(OUT_ARG_DgDx, i).supports(DERIV_LINEAR_OP)) {
801  Derivative dgdx = outArgs.get_DgDx(i);
802  if (dgdx.getLinearOp() != Teuchos::null) {
803  Teuchos::RCP<Stokhos::SGOperator> op =
804  Teuchos::rcp_dynamic_cast<Stokhos::SGOperator>(
805  dgdx.getLinearOp(), true);
806  Teuchos::RCP< Stokhos::EpetraOperatorOrthogPoly > sg_blocks =
807  op->getSGPolynomial();
808  if (me_outargs.supports(OUT_ARG_DgDx, ii).supports(DERIV_LINEAR_OP))
809  me_outargs.set_DgDx_sg(ii, sg_blocks);
810  else {
811  for (unsigned int k=0; k<num_sg_blocks; k++) {
812  Teuchos::RCP<Epetra_MultiVector> mv =
813  Teuchos::rcp_dynamic_cast<Stokhos::EpetraMultiVectorOperator>(
814  sg_blocks->getCoeffPtr(k), true)->getMultiVector();
815  dgdx_sg_blocks[i]->setCoeffPtr(k, mv);
816  }
817  if (me_outargs.supports(OUT_ARG_DgDx_sg, ii).supports(DERIV_MV_BY_COL))
818  me_outargs.set_DgDx_sg(ii, SGDerivative(dgdx_sg_blocks[i],
819  DERIV_MV_BY_COL));
820  else
821  me_outargs.set_DgDx_sg(ii, SGDerivative(dgdx_sg_blocks[i],
822  DERIV_TRANS_MV_BY_ROW));
823  }
824  }
825  TEUCHOS_TEST_FOR_EXCEPTION(dgdx.getLinearOp() == Teuchos::null &&
826  dgdx.isEmpty() == false,
827  std::logic_error,
828  "Error! Stokhos::SGModelEvaluator_Adaptive::evalModel: " <<
829  "Operator form of dg/dxdot is required!");
830  }
831 
832  // dg/dp
833  // Rembember, no derivatives w.r.t. sg parameters
834  for (int j=0; j<num_p; j++) {
835  if (!outArgs.supports(OUT_ARG_DgDp, i, j).none()) {
836  Derivative dgdp = outArgs.get_DgDp(i,j);
837  if (dgdp.getMultiVector() != Teuchos::null) {
838  Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly> dgdp_sg;
839  if (dgdp.getMultiVectorOrientation() == DERIV_MV_BY_COL)
840  dgdp_sg =
841  Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
842  sg_basis, overlapped_stoch_row_map,
843  me->get_g_map(ii), sg_g_map[i], sg_comm,
844  View, *(dgdp.getMultiVector())));
845  else if (dgdp.getMultiVectorOrientation() == DERIV_TRANS_MV_BY_ROW) {
846  Teuchos::RCP<const Epetra_BlockMap> product_map =
847  Teuchos::rcp(&(dgdp.getMultiVector()->Map()),false);
848  dgdp_sg =
849  Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
850  sg_basis, overlapped_stoch_row_map,
851  me->get_p_map(j), product_map, sg_comm,
852  View, *(dgdp.getMultiVector())));
853  }
854  me_outargs.set_DgDp_sg(ii, j,
855  SGDerivative(dgdp_sg,
856  dgdp.getMultiVectorOrientation()));
857  }
858  TEUCHOS_TEST_FOR_EXCEPTION(dgdp.getLinearOp() != Teuchos::null,
859  std::logic_error,
860  "Error! Stokhos::SGModelEvaluator_Adaptive::evalModel " <<
861  "cannot handle operator form of dg/dp!");
862  }
863  }
864 
865  }
866 
867  // Compute the functions
868  me->evalModel(me_inargs, me_outargs);
869 
870  // Copy block SG components for W
871  if ((W_out != Teuchos::null || (eval_W_with_f && f_out != Teuchos::null)) ) {
872 
873  Teuchos::RCP<Epetra_Operator> W;
874  if (W_out != Teuchos::null)
875  W = W_out;
876  else
877  W = my_W;
878 
879  Teuchos::RCP<Epetra_CrsMatrix> W_sg = Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(W, true);
880  adaptMngr->setupOperator(*W_sg,*Cijk,*W_sg_blocks);
881  }
882 
883  // f
884  if (f_out!=Teuchos::null){
885  if (!scaleOP)
886  for (int i=0; i<sg_basis->size(); i++)
887  (*f_sg_blocks)[i].Scale(sg_basis->norm_squared(i));
888 
889  adaptMngr->copyToAdaptiveVector(*f_sg_blocks,*f_out);
890  }
891 
892  // df/dp
893  for (int i=0; i<num_p; i++) {
894  if (!outArgs.supports(OUT_ARG_DfDp, i).none()) {
895  Derivative dfdp = outArgs.get_DfDp(i);
896  SGDerivative dfdp_sg = me_outargs.get_DfDp_sg(i);
897  if (dfdp.getMultiVector() != Teuchos::null) {
898 
899  dfdp.getMultiVector()->Export(
900  *(dfdp_sg.getMultiVector()->getBlockMultiVector()),
901  *adapted_overlapped_f_exporter, Insert);
902  }
903  }
904  }
905 }
906 
907 void
908 Stokhos::SGModelEvaluator_Adaptive::set_x_sg_init(
909  const Stokhos::EpetraVectorOrthogPoly& x_sg_in)
910 {
911  *sg_x_init = x_sg_in;
912 }
913 
914 Teuchos::RCP<const Stokhos::EpetraVectorOrthogPoly>
915 Stokhos::SGModelEvaluator_Adaptive::get_x_sg_init() const
916 {
917  return sg_x_init;
918 }
919 
920 void
921 Stokhos::SGModelEvaluator_Adaptive::set_p_sg_init(
922  int i, const Stokhos::EpetraVectorOrthogPoly& p_sg_in)
923 {
924  *sg_p_init[i] = p_sg_in;
925 }
926 
927 Teuchos::RCP<const Stokhos::EpetraVectorOrthogPoly>
928 Stokhos::SGModelEvaluator_Adaptive::get_p_sg_init(int l) const
929 {
930  return sg_p_init[l];
931 }
932 
933 Teuchos::Array<int>
934 Stokhos::SGModelEvaluator_Adaptive::get_p_sg_map_indices() const
935 {
936  return sg_p_index_map;
937 }
938 
939 Teuchos::Array<int>
940 Stokhos::SGModelEvaluator_Adaptive::get_g_sg_map_indices() const
941 {
942  return sg_g_index_map;
943 }
944 
945 Teuchos::Array< Teuchos::RCP<const Epetra_Map> >
946 Stokhos::SGModelEvaluator_Adaptive::get_g_sg_base_maps() const
947 {
948  Teuchos::Array< Teuchos::RCP<const Epetra_Map> > base_maps(num_g);
949  for (int i=0; i<num_g; i++)
950  base_maps[i] = me->get_g_map(i);
951  return base_maps;
952  }
953 
954 Teuchos::RCP<const Epetra_BlockMap>
955 Stokhos::SGModelEvaluator_Adaptive::get_overlap_stochastic_map() const
956 {
957  return overlapped_stoch_row_map;
958 }
959 
960 Teuchos::RCP<const Epetra_BlockMap>
961 Stokhos::SGModelEvaluator_Adaptive::get_x_sg_overlap_map() const
962 {
963  return adapted_overlapped_x_map;
964 }
965 
966 Teuchos::RCP<const Epetra_Import>
967 Stokhos::SGModelEvaluator_Adaptive::get_x_sg_importer() const
968 {
969  return adapted_overlapped_x_importer;
970 }
971 
972 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly>
973 Stokhos::SGModelEvaluator_Adaptive::create_x_sg(Epetra_DataAccess CV,
974  const Epetra_Vector* v) const
975 {
976  Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x;
977  if (v == NULL)
978  sg_x = Teuchos::rcp(new Stokhos::EpetraVectorOrthogPoly(
979  sg_basis, stoch_row_map, x_map, sg_x_map, sg_comm));
980  else
981  sg_x = Teuchos::rcp(new Stokhos::EpetraVectorOrthogPoly(
982  sg_basis, stoch_row_map, x_map, sg_x_map, sg_comm,
983  CV, *v));
984  return sg_x;
985 }
986 
987 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly>
988 Stokhos::SGModelEvaluator_Adaptive::create_x_sg_overlap(Epetra_DataAccess CV,
989  const Epetra_Vector* v) const
990 {
991  Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x;
992  if (v == NULL)
993  sg_x = Teuchos::rcp(new Stokhos::EpetraVectorOrthogPoly(
994  sg_basis, overlapped_stoch_row_map, x_map,
995  sg_overlapped_x_map, sg_comm));
996  else
997  sg_x = Teuchos::rcp(new Stokhos::EpetraVectorOrthogPoly(
998  sg_basis, overlapped_stoch_row_map, x_map,
999  sg_overlapped_x_map, sg_comm, CV, *v));
1000  return sg_x;
1001 }
1002 
1003 Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly>
1004 Stokhos::SGModelEvaluator_Adaptive::create_x_mv_sg(int num_vecs, Epetra_DataAccess CV,
1005  const Epetra_MultiVector* v) const
1006 {
1007  Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly> sg_x;
1008  if (v == NULL)
1009  sg_x = Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
1010  sg_basis, stoch_row_map, x_map, sg_x_map, sg_comm,
1011  num_vecs));
1012  else
1013  sg_x = Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
1014  sg_basis, stoch_row_map, x_map, sg_x_map, sg_comm,
1015  CV, *v));
1016  return sg_x;
1017 }
1018 
1019 Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly>
1020 Stokhos::SGModelEvaluator_Adaptive::create_x_mv_sg_overlap(
1021  int num_vecs,
1022  Epetra_DataAccess CV,
1023  const Epetra_MultiVector* v) const
1024 {
1025  Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly> sg_x;
1026  if (v == NULL)
1027  sg_x = Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
1028  sg_basis, overlapped_stoch_row_map, x_map,
1029  sg_overlapped_x_map, sg_comm, num_vecs));
1030  else
1031  sg_x = Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
1032  sg_basis, overlapped_stoch_row_map, x_map,
1033  sg_overlapped_x_map, sg_comm, CV, *v));
1034  return sg_x;
1035 }
1036 
1037 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly>
1038 Stokhos::SGModelEvaluator_Adaptive::create_p_sg(int l, Epetra_DataAccess CV,
1039  const Epetra_Vector* v) const
1040 {
1041  Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_p;
1042  Teuchos::Array<int>::const_iterator it = std::find(sg_p_index_map.begin(),
1043  sg_p_index_map.end(),
1044  l);
1045  TEUCHOS_TEST_FOR_EXCEPTION(it == sg_p_index_map.end(), std::logic_error,
1046  "Error! Invalid p map index " << l);
1047  int ll = it - sg_p_index_map.begin();
1048  if (v == NULL)
1049  sg_p = Teuchos::rcp(new Stokhos::EpetraVectorOrthogPoly(
1050  sg_basis, overlapped_stoch_p_map, me->get_p_map(l),
1051  sg_p_map[ll], sg_comm));
1052  else
1053  sg_p = Teuchos::rcp(new Stokhos::EpetraVectorOrthogPoly(
1054  sg_basis, overlapped_stoch_p_map, me->get_p_map(l),
1055  sg_p_map[ll], sg_comm, CV, *v));
1056  return sg_p;
1057 }
1058 
1059 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly>
1060 Stokhos::SGModelEvaluator_Adaptive::create_f_sg(Epetra_DataAccess CV,
1061  const Epetra_Vector* v) const
1062 {
1063  Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_f;
1064  if (v == NULL)
1065  sg_f = Teuchos::rcp(new Stokhos::EpetraVectorOrthogPoly(
1066  sg_basis, stoch_row_map, f_map, sg_f_map, sg_comm));
1067  else
1068  sg_f = Teuchos::rcp(new Stokhos::EpetraVectorOrthogPoly(
1069  sg_basis, stoch_row_map, f_map, sg_f_map, sg_comm,
1070  CV, *v));
1071  return sg_f;
1072 }
1073 
1074 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly>
1075 Stokhos::SGModelEvaluator_Adaptive::create_f_sg_overlap(Epetra_DataAccess CV,
1076  const Epetra_Vector* v) const
1077 {
1078  Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_f;
1079  if (v == NULL)
1080  sg_f = Teuchos::rcp(new Stokhos::EpetraVectorOrthogPoly(
1081  sg_basis, overlapped_stoch_row_map, f_map,
1082  sg_overlapped_f_map, sg_comm));
1083  else
1084  sg_f = Teuchos::rcp(new Stokhos::EpetraVectorOrthogPoly(
1085  sg_basis, overlapped_stoch_row_map, f_map,
1086  sg_overlapped_f_map, sg_comm, CV, *v));
1087  return sg_f;
1088 }
1089 
1090 Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly>
1091 Stokhos::SGModelEvaluator_Adaptive::create_f_mv_sg(
1092  int num_vecs,
1093  Epetra_DataAccess CV,
1094  const Epetra_MultiVector* v) const
1095 {
1096  Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly> sg_f;
1097  if (v == NULL)
1098  sg_f = Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
1099  sg_basis, stoch_row_map, f_map, sg_f_map, sg_comm,
1100  num_vecs));
1101  else
1102  sg_f = Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
1103  sg_basis, stoch_row_map, f_map, sg_f_map, sg_comm,
1104  CV, *v));
1105  return sg_f;
1106 }
1107 
1108 Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly>
1109 Stokhos::SGModelEvaluator_Adaptive::create_f_mv_sg_overlap(
1110  int num_vecs,
1111  Epetra_DataAccess CV,
1112  const Epetra_MultiVector* v) const
1113 {
1114  Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly> sg_f;
1115  if (v == NULL)
1116  sg_f = Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
1117  sg_basis, overlapped_stoch_row_map, f_map,
1118  sg_overlapped_f_map, sg_comm, num_vecs));
1119  else
1120  sg_f = Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
1121  sg_basis, overlapped_stoch_row_map, f_map,
1122  sg_overlapped_f_map, sg_comm, CV, *v));
1123  return sg_f;
1124 }
1125 
1126 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly>
1127 Stokhos::SGModelEvaluator_Adaptive::create_g_sg(int l, Epetra_DataAccess CV,
1128  const Epetra_Vector* v) const
1129 {
1130  Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_g;
1131  Teuchos::Array<int>::const_iterator it = std::find(sg_g_index_map.begin(),
1132  sg_g_index_map.end(),
1133  l);
1134  TEUCHOS_TEST_FOR_EXCEPTION(it == sg_g_index_map.end(), std::logic_error,
1135  "Error! Invalid g map index " << l);
1136  int ll = it - sg_g_index_map.begin();
1137  if (v == NULL)
1138  sg_g = Teuchos::rcp(new Stokhos::EpetraVectorOrthogPoly(
1139  sg_basis, overlapped_stoch_row_map,
1140  me->get_g_map(l),
1141  sg_g_map[ll], sg_comm));
1142  else
1143  sg_g = Teuchos::rcp(new Stokhos::EpetraVectorOrthogPoly(
1144  sg_basis, overlapped_stoch_row_map,
1145  me->get_g_map(l),
1146  sg_g_map[ll], sg_comm, CV, *v));
1147  return sg_g;
1148 }
1149 
1150 Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly>
1151 Stokhos::SGModelEvaluator_Adaptive::create_g_mv_sg(int l, int num_vecs,
1152  Epetra_DataAccess CV,
1153  const Epetra_MultiVector* v) const
1154 {
1155  Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly> sg_g;
1156  Teuchos::Array<int>::const_iterator it = std::find(sg_g_index_map.begin(),
1157  sg_g_index_map.end(),
1158  l);
1159  TEUCHOS_TEST_FOR_EXCEPTION(it == sg_g_index_map.end(), std::logic_error,
1160  "Error! Invalid g map index " << l);
1161  int ll = it - sg_g_index_map.begin();
1162  if (v == NULL)
1163  sg_g = Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
1164  sg_basis, overlapped_stoch_row_map,
1165  me->get_g_map(l),
1166  sg_g_map[ll], sg_comm, num_vecs));
1167  else
1168  sg_g = Teuchos::rcp(new Stokhos::EpetraMultiVectorOrthogPoly(
1169  sg_basis, overlapped_stoch_row_map,
1170  me->get_g_map(l),
1171  sg_g_map[ll], sg_comm, CV, *v));
1172  return sg_g;
1173 }
Stokhos::SGModelEvaluator_Adaptive::get_x_sg_importer
Teuchos::RCP< const Epetra_Import > get_x_sg_importer() const
Return x sg importer.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:967
Stokhos::SGModelEvaluator_Adaptive::get_g_sg_map_indices
Teuchos::Array< int > get_g_sg_map_indices() const
Get indices of SG responses.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:940
Stokhos::SGModelEvaluator_Adaptive::get_p_map
Teuchos::RCP< const Epetra_Map > get_p_map(int l) const
Return parameter vector map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:503
Epetra_MultiVector
Stokhos::SGModelEvaluator_Adaptive::eval_W_with_f
bool eval_W_with_f
Whether to always evaluate W with f.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:368
Stokhos::SGModelEvaluator_Adaptive::x_sg_blocks
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > x_sg_blocks
x stochastic Galerkin components
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:345
Stokhos::EpetraOperatorOrthogPoly
A container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor.
Definition: Stokhos_EpetraOperatorOrthogPoly.hpp:23
Stokhos::SGModelEvaluator_Adaptive::num_g_sg
int num_g_sg
Number of stochastic response vectors.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:333
Stokhos::SGModelEvaluator_Adaptive::create_f_mv_sg_overlap
Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > create_f_mv_sg_overlap(int num_vecs, Epetra_DataAccess CV=Copy, const Epetra_MultiVector *v=NULL) const
Create multi-vector orthog poly using f map and overlap sg map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:1109
Stokhos::ProductContainer::myGID
bool myGID(int i) const
Return whether global index i resides on this processor.
Definition: Stokhos_ProductContainerImp.hpp:179
Stokhos::SGModelEvaluator_Adaptive::sg_f_map
Teuchos::RCP< const Epetra_Map > sg_f_map
Block SG residual map.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:291
Stokhos::SGModelEvaluator_Adaptive::get_p_names
Teuchos::RCP< const Teuchos::Array< std::string > > get_p_names(int l) const
Return array of parameter names.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:524
Stokhos::SGModelEvaluator_Adaptive::stoch_row_map
Teuchos::RCP< const Epetra_BlockMap > stoch_row_map
Map for stochastic blocks.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:276
Stokhos::SGModelEvaluator_Adaptive::get_p_sg_init
Teuchos::RCP< const Stokhos::EpetraVectorOrthogPoly > get_p_sg_init(int l) const
Return initial SG parameters.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:928
Stokhos::SGModelEvaluator_Adaptive::serialCijk
Teuchos::RCP< const Stokhos::EpetraSparse3Tensor > serialCijk
Serial Epetra Cijk for dgdx*.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:271
Teuchos::ParameterList::get
T & get(ParameterList &l, const std::string &name)
Epetra_Export.h
Stokhos::SGModelEvaluator_Adaptive::create_f_mv_sg
Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > create_f_mv_sg(int num_vecs, Epetra_DataAccess CV=Copy, const Epetra_MultiVector *v=NULL) const
Create multi-vector orthog poly using f map and owned sg map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:1091
Stokhos_SGPreconditionerFactory.hpp
Stokhos::SGModelEvaluator_Adaptive::dgdx_sg_blocks
Teuchos::Array< Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > > dgdx_sg_blocks
dg/dx stochastic Galerkin components
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:359
Stokhos::SGModelEvaluator_Adaptive::scaleOP
bool scaleOP
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:379
TEUCHOS_TEST_FOR_EXCEPTION
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Stokhos_EpetraMultiVectorOperator.hpp
Stokhos::SGModelEvaluator_Adaptive::create_x_sg_overlap
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > create_x_sg_overlap(Epetra_DataAccess CV=Copy, const Epetra_Vector *v=NULL) const
Create vector orthog poly using x map and overlap sg map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:988
Stokhos::SGModelEvaluator_Adaptive::create_x_mv_sg
Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > create_x_mv_sg(int num_vecs, Epetra_DataAccess CV=Copy, const Epetra_MultiVector *v=NULL) const
Create vector orthog poly using x map and owned sg map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:1004
Stokhos::SGModelEvaluator_Adaptive::adapted_overlapped_f_exporter
Teuchos::RCP< Epetra_Export > adapted_overlapped_f_exporter
Exporter from SG-overlapped to SG maps.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:312
Stokhos::SGModelEvaluator_Adaptive::sg_p_names
Teuchos::Array< Teuchos::RCP< Teuchos::Array< std::string > > > sg_p_names
SG coefficient parameter names.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:327
Stokhos::SGModelEvaluator_Adaptive::create_x_sg
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > create_x_sg(Epetra_DataAccess CV=Copy, const Epetra_Vector *v=NULL) const
Create vector orthog poly using x map and owned sg map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:973
Stokhos::SGModelEvaluator_Adaptive::sg_x_map
Teuchos::RCP< const Epetra_Map > sg_x_map
Block SG unknown map.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:285
Epetra_Import.h
Stokhos::SGModelEvaluator_Adaptive::dgdx_dot_sg_blocks
Teuchos::Array< Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > > dgdx_dot_sg_blocks
dg/dxdot stochastic Galerkin components
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:356
Stokhos::SGModelEvaluator_Adaptive::set_p_sg_init
void set_p_sg_init(int i, const Stokhos::EpetraVectorOrthogPoly &p_sg_in)
Set initial parameter polynomial.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:921
Insert
Epetra_Export
Teuchos::RCP::get
T * get() const
Stokhos::SGModelEvaluator_Adaptive::x_map
Teuchos::RCP< const Epetra_Map > x_map
Underlying unknown map.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:256
Epetra_Vector
Stokhos::SGModelEvaluator_Adaptive::get_f_map
Teuchos::RCP< const Epetra_Map > get_f_map() const
Return residual vector map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:497
Stokhos::SGModelEvaluator_Adaptive::sg_parallel_data
Teuchos::RCP< const Stokhos::ParallelData > sg_parallel_data
Parallel SG data.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:262
Stokhos::SGModelEvaluator_Adaptive::adapted_overlapped_x_map
Teuchos::RCP< const Epetra_Map > adapted_overlapped_x_map
Adapated block SG overlapped unknown map.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:300
Stokhos::SGModelEvaluator_Adaptive::get_x_sg_overlap_map
Teuchos::RCP< const Epetra_BlockMap > get_x_sg_overlap_map() const
Return x sg overlap map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:961
Stokhos_MatrixFreeOperator.hpp
Epetra_Import
Stokhos::OrthogPolyBasis::dimension
virtual ordinal_type dimension() const =0
Return dimension of basis.
Stokhos::SGModelEvaluator_Adaptive::num_g
int num_g
Number of response vectors of underlying model evaluator.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:330
Stokhos::SGModelEvaluator_Adaptive::sg_x_init
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > sg_x_init
SG initial x.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:362
Stokhos_SGModelEvaluator_Adaptive.hpp
Stokhos::SGModelEvaluator_Adaptive::create_W
Teuchos::RCP< Epetra_Operator > create_W() const
Create W = alpha*M + beta*J matrix.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:560
Stokhos::SGModelEvaluator_Adaptive::sg_g_map
Teuchos::Array< Teuchos::RCP< const Epetra_Map > > sg_g_map
Block SG response map.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:339
Stokhos::SGModelEvaluator_Adaptive::get_g_map
Teuchos::RCP< const Epetra_Map > get_g_map(int l) const
Return response map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:516
j
j
Definition: Sacado_Fad_Exp_MP_Vector.hpp:495
Stokhos::SGModelEvaluator_Adaptive::epetraCijk
Teuchos::RCP< const Stokhos::EpetraSparse3Tensor > epetraCijk
Epetra Cijk.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:268
Stokhos::OrthogPolyExpansion
Abstract base class for orthogonal polynomial-based expansions.
Definition: Stokhos_OrthogPolyExpansion.hpp:25
Stokhos::SGModelEvaluator_Adaptive::num_W_blocks
unsigned int num_W_blocks
Number of W stochastic blocks (may be smaller than num_sg_blocks)
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:247
Stokhos::SGModelEvaluator_Adaptive::get_p_sg_map_indices
Teuchos::Array< int > get_p_sg_map_indices() const
Get indices of SG parameters.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:934
Stokhos::SGModelEvaluator_Adaptive::sg_row_dof_basis
std::vector< Teuchos::RCP< const Stokhos::ProductBasis< int, double > > > sg_row_dof_basis
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:232
Stokhos::SGModelEvaluator_Adaptive::me
Teuchos::RCP< EpetraExt::ModelEvaluator > me
Underlying model evaluator.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:227
Stokhos::EpetraMultiVectorOperator
An adaptor that supplies the operator interface to a multi-vector.
Definition: Stokhos_EpetraMultiVectorOperator.hpp:34
Teuchos::rcp
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Stokhos::SGOperator
An abstract class to represent a generic stochastic Galerkin operator as an Epetra_Operator.
Definition: Stokhos_SGOperator.hpp:23
Stokhos::SGModelEvaluator_Adaptive::create_x_mv_sg_overlap
Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > create_x_mv_sg_overlap(int num_vecs, Epetra_DataAccess CV=Copy, const Epetra_MultiVector *v=NULL) const
Create vector orthog poly using x map and overlap sg map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:1020
Stokhos::SGModelEvaluator_Adaptive::supports_x
bool supports_x
Whether we support x (and thus f and W)
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:253
Stokhos::SGModelEvaluator_Adaptive::num_p
int num_p
Number of parameter vectors of underlying model evaluator.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:315
Stokhos::EpetraVectorOrthogPoly
A container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor.
Definition: Stokhos_EpetraVectorOrthogPoly.hpp:23
Stokhos::SGModelEvaluator_Adaptive::create_p_sg
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > create_p_sg(int l, Epetra_DataAccess CV=Copy, const Epetra_Vector *v=0) const
Create vector orthog poly using p map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:1038
Stokhos::SGModelEvaluator_Adaptive::sg_overlapped_x_map
Teuchos::RCP< const Epetra_Map > sg_overlapped_x_map
Block SG overlapped unknown map.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:288
Stokhos::SGOperator::getSGPolynomial
virtual Teuchos::RCP< Stokhos::EpetraOperatorOrthogPoly > getSGPolynomial()=0
Get SG polynomial.
Stokhos::SGModelEvaluator_Adaptive::evalModel
void evalModel(const InArgs &inArgs, const OutArgs &outArgs) const
Evaluate model on InArgs.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:636
Stokhos::SGModelEvaluator_Adaptive::x_dot_sg_blocks
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > x_dot_sg_blocks
x_dot stochastic Galerkin components
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:342
Stokhos::SGModelEvaluator_Adaptive::adapted_overlapped_f_map
Teuchos::RCP< const Epetra_Map > adapted_overlapped_f_map
Adapted block SG overlapped residual map.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:306
Stokhos::SGModelEvaluator_Adaptive::overlapped_stoch_row_map
Teuchos::RCP< const Epetra_BlockMap > overlapped_stoch_row_map
Overlapped map for stochastic blocks (local map)
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:279
Stokhos::SGModelEvaluator_Adaptive::get_x_sg_init
Teuchos::RCP< const Stokhos::EpetraVectorOrthogPoly > get_x_sg_init() const
Return initial SG x.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:915
Stokhos::SGModelEvaluator_Adaptive::adapted_f_map
Teuchos::RCP< const Epetra_Map > adapted_f_map
Adapted block SG residual map.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:303
Teuchos::Array::end
iterator end()
Teuchos::Array::const_iterator
std::vector< T >::const_iterator const_iterator
Stokhos::SGModelEvaluator_Adaptive::adapted_x_map
Teuchos::RCP< const Epetra_Map > adapted_x_map
Adapted lock SG unknown map.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:297
Stokhos::SGModelEvaluator_Adaptive::sg_p_map
Teuchos::Array< Teuchos::RCP< const Epetra_Map > > sg_p_map
Block SG parameter map.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:324
Stokhos::SGModelEvaluator_Adaptive::get_g_sg_base_maps
Teuchos::Array< Teuchos::RCP< const Epetra_Map > > get_g_sg_base_maps() const
Get base maps of SG responses.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:946
Stokhos::SGModelEvaluator_Adaptive::createOutArgs
OutArgs createOutArgs() const
Create OutArgs.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:603
Teuchos::Array::push_back
void push_back(const value_type &x)
Stokhos::SGModelEvaluator_Adaptive::W_sg_blocks
Teuchos::RCP< Stokhos::EpetraOperatorOrthogPoly > W_sg_blocks
W stochastic Galerkin components.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:351
Stokhos::SGModelEvaluator_Adaptive::adapted_overlapped_x_importer
Teuchos::RCP< Epetra_Import > adapted_overlapped_x_importer
Importer from SG to SG-overlapped maps.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:309
Stokhos::SGModelEvaluator_Adaptive::get_overlap_stochastic_map
Teuchos::RCP< const Epetra_BlockMap > get_overlap_stochastic_map() const
Return overlap stochastic map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:955
Stokhos::SGModelEvaluator_Adaptive::get_x_map
Teuchos::RCP< const Epetra_Map > get_x_map() const
Return solution vector map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:491
Epetra_LocalMap.h
Epetra_CrsMatrix
Stokhos::SGModelEvaluator_Adaptive::sg_p_index_map
Teuchos::Array< int > sg_p_index_map
Index map between block-p and p_sg maps.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:321
Teuchos::Array::size
size_type size() const
Stokhos::SGModelEvaluator_Adaptive::num_p_sg
int num_p_sg
Number of stochastic parameter vectors.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:318
Stokhos::SGModelEvaluator_Adaptive::set_x_sg_init
void set_x_sg_init(const Stokhos::EpetraVectorOrthogPoly &x_sg_in)
Set initial solution polynomial.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:908
Stokhos::SGModelEvaluator_Adaptive::num_sg_blocks
unsigned int num_sg_blocks
Number of stochastic blocks.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:244
Stokhos::SGModelEvaluator_Adaptive::create_f_sg
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > create_f_sg(Epetra_DataAccess CV=Copy, const Epetra_Vector *v=NULL) const
Create vector orthog poly using f map and owned sg map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:1060
Stokhos::SGModelEvaluator_Adaptive::create_g_mv_sg
Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > create_g_mv_sg(int l, int num_vecs, Epetra_DataAccess CV=Copy, const Epetra_MultiVector *v=NULL) const
Create multi-vector orthog poly using g map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:1151
Stokhos::SGModelEvaluator_Adaptive::get_p_init
Teuchos::RCP< const Epetra_Vector > get_p_init(int l) const
Return initial parameters.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:547
Epetra_CrsMatrix::Graph
const Epetra_CrsGraph & Graph() const
Stokhos::SGModelEvaluator_Adaptive::sg_g_index_map
Teuchos::Array< int > sg_g_index_map
Index map between block-g and g_sg maps.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:336
Epetra_CrsMatrix::Scale
int Scale(double ScalarConstant)
Stokhos::SGModelEvaluator_Adaptive::create_f_sg_overlap
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > create_f_sg_overlap(Epetra_DataAccess CV=Copy, const Epetra_Vector *v=NULL) const
Create vector orthog poly using f map and overlap sg map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:1075
Epetra_DataAccess
Epetra_DataAccess
Stokhos::SGModelEvaluator_Adaptive::sg_comm
Teuchos::RCP< const EpetraExt::MultiComm > sg_comm
Parallel SG communicator.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:265
Stokhos::SGModelEvaluator_Adaptive::my_x
Teuchos::RCP< Epetra_Vector > my_x
x pointer for evaluating preconditioner
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:377
Stokhos::SGModelEvaluator_Adaptive::sg_basis
Teuchos::RCP< const Stokhos::OrthogPolyBasis< int, double > > sg_basis
Stochastic Galerkin basis.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:230
Stokhos::SGModelEvaluator_Adaptive::params
Teuchos::RCP< Teuchos::ParameterList > params
Algorithmic parameters.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:241
Teuchos_Assert.hpp
Stokhos::SGModelEvaluator_Adaptive::num_p_blocks
unsigned int num_p_blocks
Number of p stochastic blocks (may be smaller than num_sg_blocks)
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:250
Stokhos::SGModelEvaluator_Adaptive::adaptMngr
Teuchos::RCP< Stokhos::AdaptivityManager > adaptMngr
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:381
Teuchos::Array::begin
iterator begin()
Stokhos::SGModelEvaluator_Adaptive::sg_overlapped_f_map
Teuchos::RCP< const Epetra_Map > sg_overlapped_f_map
Block SG overlapped residual map.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:294
Stokhos_AdaptivityUtils.hpp
g
ScalarType g(const Teuchos::Array< ScalarType > &x, const ScalarType &y)
Definition: gram_schmidt_example3.cpp:75
Stokhos::SGModelEvaluator_Adaptive::f_sg_blocks
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > f_sg_blocks
f stochastic Galerkin components
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:348
Epetra_CrsGraph
Epetra_LocalMap
Stokhos::SGModelEvaluator_Adaptive::get_x_init
Teuchos::RCP< const Epetra_Vector > get_x_init() const
Return initial solution.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:537
Stokhos::SGModelEvaluator_Adaptive::overlapped_stoch_p_map
Teuchos::RCP< const Epetra_BlockMap > overlapped_stoch_p_map
Overlapped map for p stochastic blocks (local map)
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:282
Stokhos::SGModelEvaluator_Adaptive::createInArgs
InArgs createInArgs() const
Create InArgs.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:581
Stokhos::SGModelEvaluator_Adaptive::create_g_sg
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > create_g_sg(int l, Epetra_DataAccess CV=Copy, const Epetra_Vector *v=NULL) const
Create vector orthog poly using g map.
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:1127
Stokhos::SGModelEvaluator_Adaptive::SGModelEvaluator_Adaptive
SGModelEvaluator_Adaptive(const Teuchos::RCP< EpetraExt::ModelEvaluator > &me_, const Teuchos::RCP< Stokhos::AdaptivityManager > &am, const Teuchos::RCP< const Stokhos::Quadrature< int, double > > &sg_quad_, const Teuchos::RCP< Stokhos::OrthogPolyExpansion< int, double > > &sg_exp_, const Teuchos::RCP< const Stokhos::ParallelData > &sg_parallel_data_, bool onlyUseLinear_, int kExpOrder_, const Teuchos::RCP< Teuchos::ParameterList > &params_)
Definition: Stokhos_SGModelEvaluator_Adaptive.cpp:24
Stokhos::EpetraMultiVectorOrthogPoly
A container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor.
Definition: Stokhos_EpetraMultiVectorOrthogPoly.hpp:23
Stokhos::SGModelEvaluator_Adaptive::sg_p_init
Teuchos::Array< Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > > sg_p_init
SG initial p.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:365
Stokhos::SGModelEvaluator_Adaptive::f_map
Teuchos::RCP< const Epetra_Map > f_map
Underlying residual map.
Definition: Stokhos_SGModelEvaluator_Adaptive.hpp:259
Generated on Fri Nov 22 2024 09:18:14 for Stokhos Package Browser (Single Doxygen Collection) by   doxygen 1.8.5