45 #include "Teuchos_Assert.hpp" 46 #include "EpetraExt_BlockUtility.h" 47 #include "EpetraExt_BlockMultiVector.h" 52 #include "Epetra_LocalMap.h" 53 #include "Epetra_Export.h" 54 #include "Epetra_Import.h" 57 const Teuchos::RCP<EpetraExt::ModelEvaluator>& me_,
58 const Teuchos::RCP<Stokhos::AdaptivityManager> & am,
61 const Teuchos::RCP<const Stokhos::ParallelData>& sg_parallel_data_,
62 bool onlyUseLinear_,
int kExpOrder_,
63 const Teuchos::RCP<Teuchos::ParameterList>& params_)
65 sg_basis(am->getMasterStochasticBasis()),
66 sg_row_dof_basis(am->getRowStochasticBasis()),
70 num_sg_blocks(sg_basis->size()),
71 num_W_blocks(sg_basis->size()),
72 num_p_blocks(sg_basis->size()),
74 x_map(me->get_x_map()),
75 f_map(me->get_f_map()),
76 sg_parallel_data(sg_parallel_data_),
77 sg_comm(sg_parallel_data->getMultiComm()),
78 epetraCijk(sg_parallel_data->getEpetraCijk()),
80 Cijk(epetraCijk->getParallelCijk()),
99 kExpOrder(kExpOrder_),
100 onlyUseLinear(onlyUseLinear_),
101 scaleOP(am->isScaled()),
104 if (
x_map != Teuchos::null)
152 std::string W_expansion_type =
153 params->get(
"Jacobian Expansion Type",
"Full");
154 if (W_expansion_type ==
"Linear")
159 Teuchos::RCP<Epetra_BlockMap> W_overlap_map =
160 Teuchos::rcp(
new Epetra_LocalMap(
176 InArgs me_inargs =
me->createInArgs();
177 OutArgs me_outargs =
me->createOutArgs();
178 num_p = me_inargs.Np();
181 for (
int i=0; i<
num_p; i++) {
182 if (me_inargs.supports(IN_ARG_p_sg, i))
192 std::string p_expansion_type =
193 params->get(
"Parameter Expansion Type",
"Full");
194 if (p_expansion_type ==
"Linear")
201 Teuchos::rcp(
new Epetra_LocalMap(
207 Teuchos::rcp(EpetraExt::BlockUtility::GenerateBlockMap(
210 Teuchos::RCP<const Teuchos::Array<std::string> > p_names =
212 if (p_names != Teuchos::null) {
214 Teuchos::rcp(
new Teuchos::Array<std::string>(
num_sg_blocks*(p_names->size())));
215 for (
int j=0;
j<p_names->size();
j++) {
216 std::stringstream ss;
217 ss << (*p_names)[
j] <<
" -- SG Coefficient " << i;
229 num_g = me_outargs.Ng();
232 for (
int i=0; i<
num_g; i++) {
233 if (me_outargs.supports(OUT_ARG_g_sg, i))
246 Teuchos::rcp(EpetraExt::BlockUtility::GenerateBlockMap(
272 const Teuchos::RCP<EpetraExt::ModelEvaluator>& me_,
277 const Teuchos::RCP<const Stokhos::ParallelData>& sg_parallel_data_,
278 bool onlyUseLinear_,
int kExpOrder_,
279 const Teuchos::RCP<Teuchos::ParameterList>& params_,
283 sg_row_dof_basis(sg_row_dof_basis_),
287 num_sg_blocks(sg_basis->size()),
288 num_W_blocks(sg_basis->size()),
289 num_p_blocks(sg_basis->size()),
291 x_map(me->get_x_map()),
292 f_map(me->get_f_map()),
293 sg_parallel_data(sg_parallel_data_),
294 sg_comm(sg_parallel_data->getMultiComm()),
295 epetraCijk(sg_parallel_data->getEpetraCijk()),
297 Cijk(epetraCijk->getParallelCijk()),
311 dgdx_dot_sg_blocks(),
315 eval_W_with_f(false),
316 kExpOrder(kExpOrder_),
317 onlyUseLinear(onlyUseLinear_),
320 if (
x_map != Teuchos::null)
371 std::string W_expansion_type =
372 params->get(
"Jacobian Expansion Type",
"Full");
373 if (W_expansion_type ==
"Linear")
378 Teuchos::RCP<Epetra_BlockMap> W_overlap_map =
379 Teuchos::rcp(
new Epetra_LocalMap(
395 InArgs me_inargs =
me->createInArgs();
396 OutArgs me_outargs =
me->createOutArgs();
397 num_p = me_inargs.Np();
400 for (
int i=0; i<
num_p; i++) {
401 if (me_inargs.supports(IN_ARG_p_sg, i))
411 std::string p_expansion_type =
412 params->get(
"Parameter Expansion Type",
"Full");
413 if (p_expansion_type ==
"Linear")
420 Teuchos::rcp(
new Epetra_LocalMap(
426 Teuchos::rcp(EpetraExt::BlockUtility::GenerateBlockMap(
429 Teuchos::RCP<const Teuchos::Array<std::string> > p_names =
431 if (p_names != Teuchos::null) {
433 Teuchos::rcp(
new Teuchos::Array<std::string>(
num_sg_blocks*(p_names->size())));
434 for (
int j=0;
j<p_names->size();
j++) {
435 std::stringstream ss;
436 ss << (*p_names)[
j] <<
" -- SG Coefficient " << i;
448 num_g = me_outargs.Ng();
451 for (
int i=0; i<
num_g; i++) {
452 if (me_outargs.supports(OUT_ARG_g_sg, i))
465 Teuchos::rcp(EpetraExt::BlockUtility::GenerateBlockMap(
492 Teuchos::RCP<const Epetra_Map>
495 return adapted_x_map;
498 Teuchos::RCP<const Epetra_Map>
501 return adapted_f_map;
504 Teuchos::RCP<const Epetra_Map>
507 TEUCHOS_TEST_FOR_EXCEPTION(l < 0 || l >= num_p + num_p_sg, std::logic_error,
508 "Error! Invalid p map index " << l);
510 return me->get_p_map(l);
512 return sg_p_map[l-num_p];
514 return Teuchos::null;
517 Teuchos::RCP<const Epetra_Map>
520 TEUCHOS_TEST_FOR_EXCEPTION(l < 0 || l >= num_g_sg, std::logic_error,
521 "Error! Invalid g map index " << l);
525 Teuchos::RCP<const Teuchos::Array<std::string> >
528 TEUCHOS_TEST_FOR_EXCEPTION(l < 0 || l >= num_p + num_p_sg, std::logic_error,
529 "Error! Invalid p map index " << l);
531 return me->get_p_names(l);
533 return sg_p_names[l-num_p];
535 return Teuchos::null;
538 Teuchos::RCP<const Epetra_Vector>
542 Teuchos::RCP<Epetra_Vector> x_init = Teuchos::rcp(
new Epetra_Vector(*get_x_map()));
543 adaptMngr->copyToAdaptiveVector(*get_x_sg_init(),*x_init);
548 Teuchos::RCP<const Epetra_Vector>
551 TEUCHOS_TEST_FOR_EXCEPTION(l < 0 || l >= num_p + num_p_sg, std::logic_error,
552 "Error! Invalid p map index " << l);
554 return me->get_p_init(l);
556 return sg_p_init[l-num_p]->getBlockVector();
558 return Teuchos::null;
561 Teuchos::RCP<Epetra_Operator>
565 Teuchos::RCP<Teuchos::ParameterList> sgOpParams =
566 Teuchos::rcp(&(params->sublist(
"SG Operator")),
false);
568 Teuchos::RCP<Epetra_CrsMatrix> W_crs
569 = Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(me->create_W(),
true);
570 const Epetra_CrsGraph & W_graph = W_crs->Graph();
572 adaptMngr->setupWithGraph(W_graph,onlyUseLinear,kExpOrder);
573 my_W = adaptMngr->buildMatrixFromGraph();
574 adaptMngr->setupOperator(*my_W,*Cijk,*W_sg_blocks);
579 return Teuchos::null;
582 EpetraExt::ModelEvaluator::InArgs
586 InArgs me_inargs = me->createInArgs();
588 inArgs.setModelEvalDescription(this->description());
589 inArgs.set_Np(num_p + num_p_sg);
590 inArgs.setSupports(IN_ARG_x_dot, me_inargs.supports(IN_ARG_x_dot_sg));
591 inArgs.setSupports(IN_ARG_x, me_inargs.supports(IN_ARG_x_sg));
592 inArgs.setSupports(IN_ARG_t, me_inargs.supports(IN_ARG_t));
593 inArgs.setSupports(IN_ARG_alpha, me_inargs.supports(IN_ARG_alpha));
594 inArgs.setSupports(IN_ARG_beta, me_inargs.supports(IN_ARG_beta));
595 inArgs.setSupports(IN_ARG_sg_basis, me_inargs.supports(IN_ARG_sg_basis));
596 inArgs.setSupports(IN_ARG_sg_quadrature,
597 me_inargs.supports(IN_ARG_sg_quadrature));
598 inArgs.setSupports(IN_ARG_sg_expansion,
599 me_inargs.supports(IN_ARG_sg_expansion));
604 EpetraExt::ModelEvaluator::OutArgs
607 OutArgsSetup outArgs;
608 OutArgs me_outargs = me->createOutArgs();
610 outArgs.setModelEvalDescription(this->description());
611 outArgs.set_Np_Ng(num_p+num_p_sg, num_g_sg);
612 outArgs.setSupports(OUT_ARG_f, me_outargs.supports(OUT_ARG_f_sg));
613 outArgs.setSupports(OUT_ARG_W, me_outargs.supports(OUT_ARG_W_sg));
614 outArgs.setSupports(OUT_ARG_WPrec,
false);
615 for (
int j=0;
j<num_p;
j++)
616 outArgs.setSupports(OUT_ARG_DfDp,
j,
617 me_outargs.supports(OUT_ARG_DfDp_sg,
j));
618 for (
int i=0; i<num_g_sg; i++) {
619 int ii = sg_g_index_map[i];
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));
637 const OutArgs& outArgs)
const 640 Teuchos::RCP<const Epetra_Vector>
x;
641 if (inArgs.supports(IN_ARG_x)) {
643 if (
x != Teuchos::null)
646 Teuchos::RCP<const Epetra_Vector> x_dot;
647 if (inArgs.supports(IN_ARG_x_dot))
648 x_dot = inArgs.get_x_dot();
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();
659 InArgs me_inargs = me->createInArgs();
660 if (
x != Teuchos::null) {
662 adaptMngr->copyFromAdaptiveVector(*
x,*x_sg_blocks);
663 me_inargs.set_x_sg(x_sg_blocks);
665 if (x_dot != Teuchos::null) {
667 adaptMngr->copyFromAdaptiveVector(*x_dot,*x_dot_sg_blocks);
668 me_inargs.set_x_dot_sg(x_dot_sg_blocks);
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());
680 me_inargs.set_sg_basis(sg_basis);
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());
686 me_inargs.set_sg_quadrature(sg_quad);
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());
692 me_inargs.set_sg_expansion(sg_exp);
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);
703 if (p == Teuchos::null)
704 p = sg_p_init[i]->getBlockVector();
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);
713 OutArgs me_outargs = me->createOutArgs();
716 if (f_out != Teuchos::null) {
717 me_outargs.set_f_sg(f_sg_blocks);
719 me_outargs.set_W_sg(W_sg_blocks);
723 if (W_out != Teuchos::null && !eval_W_with_f )
724 me_outargs.set_W_sg(W_sg_blocks);
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)
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)
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()));
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!");
755 for (
int i=0; i<num_g_sg; i++) {
756 int ii = sg_g_index_map[i];
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);
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 =
772 dgdx_dot.getLinearOp(),
true);
773 Teuchos::RCP< Stokhos::EpetraOperatorOrthogPoly > sg_blocks =
775 if (me_outargs.supports(OUT_ARG_DgDx, ii).supports(DERIV_LINEAR_OP))
776 me_outargs.set_DgDx_dot_sg(ii, sg_blocks);
778 for (
unsigned int k=0; k<num_sg_blocks; k++) {
779 Teuchos::RCP<Epetra_MultiVector> mv =
781 sg_blocks->getCoeffPtr(k),
true)->getMultiVector();
782 dgdx_dot_sg_blocks[i]->setCoeffPtr(k, mv);
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],
788 me_outargs.set_DgDx_dot_sg(ii, SGDerivative(dgdx_dot_sg_blocks[i],
789 DERIV_TRANS_MV_BY_ROW));
792 TEUCHOS_TEST_FOR_EXCEPTION(dgdx_dot.getLinearOp() == Teuchos::null &&
793 dgdx_dot.isEmpty() ==
false,
795 "Error! Stokhos::SGModelEvaluator_Adaptive::evalModel: " <<
796 "Operator form of dg/dxdot is required!");
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 =
805 dgdx.getLinearOp(),
true);
806 Teuchos::RCP< Stokhos::EpetraOperatorOrthogPoly > sg_blocks =
808 if (me_outargs.supports(OUT_ARG_DgDx, ii).supports(DERIV_LINEAR_OP))
809 me_outargs.set_DgDx_sg(ii, sg_blocks);
811 for (
unsigned int k=0; k<num_sg_blocks; k++) {
812 Teuchos::RCP<Epetra_MultiVector> mv =
814 sg_blocks->getCoeffPtr(k),
true)->getMultiVector();
815 dgdx_sg_blocks[i]->setCoeffPtr(k, mv);
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],
821 me_outargs.set_DgDx_sg(ii, SGDerivative(dgdx_sg_blocks[i],
822 DERIV_TRANS_MV_BY_ROW));
825 TEUCHOS_TEST_FOR_EXCEPTION(dgdx.getLinearOp() == Teuchos::null &&
826 dgdx.isEmpty() ==
false,
828 "Error! Stokhos::SGModelEvaluator_Adaptive::evalModel: " <<
829 "Operator form of dg/dxdot is required!");
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)
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);
850 sg_basis, overlapped_stoch_row_map,
851 me->get_p_map(
j), product_map, sg_comm,
852 View, *(dgdp.getMultiVector())));
854 me_outargs.set_DgDp_sg(ii,
j,
855 SGDerivative(dgdp_sg,
856 dgdp.getMultiVectorOrientation()));
858 TEUCHOS_TEST_FOR_EXCEPTION(dgdp.getLinearOp() != Teuchos::null,
860 "Error! Stokhos::SGModelEvaluator_Adaptive::evalModel " <<
861 "cannot handle operator form of dg/dp!");
868 me->evalModel(me_inargs, me_outargs);
871 if ((W_out != Teuchos::null || (eval_W_with_f && f_out != Teuchos::null)) ) {
873 Teuchos::RCP<Epetra_Operator> W;
874 if (W_out != Teuchos::null)
879 Teuchos::RCP<Epetra_CrsMatrix> W_sg = Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(W,
true);
880 adaptMngr->setupOperator(*W_sg,*Cijk,*W_sg_blocks);
884 if (f_out!=Teuchos::null){
886 for (
int i=0; i<sg_basis->size(); i++)
887 (*f_sg_blocks)[i].Scale(sg_basis->norm_squared(i));
889 adaptMngr->copyToAdaptiveVector(*f_sg_blocks,*f_out);
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) {
899 dfdp.getMultiVector()->Export(
900 *(dfdp_sg.getMultiVector()->getBlockMultiVector()),
901 *adapted_overlapped_f_exporter, Insert);
911 *sg_x_init = x_sg_in;
914 Teuchos::RCP<const Stokhos::EpetraVectorOrthogPoly>
924 *sg_p_init[i] = p_sg_in;
927 Teuchos::RCP<const Stokhos::EpetraVectorOrthogPoly>
936 return sg_p_index_map;
942 return sg_g_index_map;
945 Teuchos::Array< Teuchos::RCP<const Epetra_Map> >
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);
954 Teuchos::RCP<const Epetra_BlockMap>
957 return overlapped_stoch_row_map;
960 Teuchos::RCP<const Epetra_BlockMap>
963 return adapted_overlapped_x_map;
966 Teuchos::RCP<const Epetra_Import>
969 return adapted_overlapped_x_importer;
972 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly>
975 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x;
977 sg_basis, stoch_row_map, x_map, sg_comm));
981 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly>
984 return create_x_sg();
987 Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly>
990 Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly> sg_x;
992 sg_basis, stoch_row_map, x_map, sg_comm, num_vecs));
996 Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly>
1000 return create_x_mv_sg(num_vecs);
1003 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly>
1005 const Epetra_Vector* v)
const 1007 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_p;
1008 Teuchos::Array<int>::const_iterator it = std::find(sg_p_index_map.begin(),
1009 sg_p_index_map.end(),
1011 TEUCHOS_TEST_FOR_EXCEPTION(it == sg_p_index_map.end(), std::logic_error,
1012 "Error! Invalid p map index " << l);
1013 int ll = it - sg_p_index_map.begin();
1016 sg_basis, overlapped_stoch_p_map, me->get_p_map(l),
1017 sg_p_map[ll], sg_comm));
1020 sg_basis, overlapped_stoch_p_map, me->get_p_map(l),
1021 sg_p_map[ll], sg_comm, CV, *v));
1025 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly>
1028 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_f;
1030 sg_basis, stoch_row_map, f_map, sg_comm));
1034 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly>
1037 return create_f_sg();
1040 Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly>
1044 Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly> sg_f;
1046 sg_basis, stoch_row_map, f_map, sg_comm, num_vecs));
1050 Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly>
1054 return create_f_mv_sg_overlap(num_vecs);
1057 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly>
1059 const Epetra_Vector* v)
const 1061 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_g;
1062 Teuchos::Array<int>::const_iterator it = std::find(sg_g_index_map.begin(),
1063 sg_g_index_map.end(),
1065 TEUCHOS_TEST_FOR_EXCEPTION(it == sg_g_index_map.end(), std::logic_error,
1066 "Error! Invalid g map index " << l);
1067 int ll = it - sg_g_index_map.begin();
1070 sg_basis, overlapped_stoch_row_map,
1072 sg_g_map[ll], sg_comm));
1075 sg_basis, overlapped_stoch_row_map,
1077 sg_g_map[ll], sg_comm, CV, *v));
1081 Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly>
1083 Epetra_DataAccess CV,
1084 const Epetra_MultiVector* v)
const 1086 Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly> sg_g;
1087 Teuchos::Array<int>::const_iterator it = std::find(sg_g_index_map.begin(),
1088 sg_g_index_map.end(),
1090 TEUCHOS_TEST_FOR_EXCEPTION(it == sg_g_index_map.end(), std::logic_error,
1091 "Error! Invalid g map index " << l);
1092 int ll = it - sg_g_index_map.begin();
1095 sg_basis, overlapped_stoch_row_map,
1097 sg_g_map[ll], sg_comm, num_vecs));
1100 sg_basis, overlapped_stoch_row_map,
1102 sg_g_map[ll], sg_comm, CV, *v));
void evalModel(const InArgs &inArgs, const OutArgs &outArgs) const
Evaluate model on InArgs.
Teuchos::RCP< const Epetra_Map > get_g_map(int l) const
Return response map.
Teuchos::Array< int > get_p_sg_map_indices() const
Get indices of SG parameters.
bool eval_W_with_f
Whether to always evaluate W with f.
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > x_sg_blocks
x stochastic Galerkin components
A container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor.
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > create_x_sg() const
Create vector orthog poly using x map and owned sg map.
int num_g_sg
Number of stochastic response vectors.
Teuchos::RCP< Epetra_Operator > create_W() const
Create W = alpha*M + beta*J matrix.
Teuchos::Array< int > get_g_sg_map_indices() const
Get indices of SG responses.
Teuchos::RCP< const Epetra_Map > get_x_map() const
Return solution vector map.
Teuchos::RCP< const Epetra_BlockMap > stoch_row_map
Map for stochastic blocks.
Teuchos::RCP< const Stokhos::EpetraSparse3Tensor > serialCijk
Serial Epetra Cijk for dgdx*.
Teuchos::Array< Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > > dgdx_sg_blocks
dg/dx stochastic Galerkin components
Teuchos::RCP< const Epetra_Map > get_f_map() const
Return residual vector map.
Teuchos::RCP< Epetra_Export > adapted_overlapped_f_exporter
Exporter from SG-overlapped to SG maps.
Teuchos::Array< Teuchos::RCP< Teuchos::Array< std::string > > > sg_p_names
SG coefficient parameter names.
Teuchos::Array< Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > > dgdx_dot_sg_blocks
dg/dxdot stochastic Galerkin components
void set_p_sg_init(int i, const Stokhos::EpetraVectorOrthogPoly &p_sg_in)
Set initial parameter polynomial.
Teuchos::RCP< const Epetra_Map > x_map
Underlying unknown map.
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.
Teuchos::RCP< const Stokhos::ParallelData > sg_parallel_data
Parallel SG data.
Teuchos::RCP< const Epetra_BlockMap > get_overlap_stochastic_map() const
Return overlap stochastic map.
Teuchos::RCP< const Epetra_Map > adapted_overlapped_x_map
Block SG overlapped unknown map.
int num_g
Number of response vectors of underlying model evaluator.
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > sg_x_init
SG initial x.
Teuchos::Array< Teuchos::RCP< const Epetra_Map > > sg_g_map
Block SG response map.
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > create_f_sg_overlap() const
Create vector orthog poly using f map and overlap sg map.
OutArgs createOutArgs() const
Create OutArgs.
Teuchos::RCP< const Epetra_Map > get_p_map(int l) const
Return parameter vector map.
Teuchos::RCP< const Stokhos::EpetraSparse3Tensor > epetraCijk
Epetra Cijk.
InArgs createInArgs() const
Create InArgs.
Teuchos::RCP< const Teuchos::Array< std::string > > get_p_names(int l) const
Return array of parameter names.
Abstract base class for orthogonal polynomial-based expansions.
unsigned int num_W_blocks
Number of W stochastic blocks (may be smaller than num_sg_blocks)
std::vector< Teuchos::RCP< const Stokhos::ProductBasis< int, double > > > sg_row_dof_basis
Teuchos::RCP< EpetraExt::ModelEvaluator > me
Underlying model evaluator.
const IndexType const IndexType const IndexType const IndexType const ValueType const ValueType * x
An adaptor that supplies the operator interface to a multi-vector.
An abstract class to represent a generic stochastic Galerkin operator as an Epetra_Operator.
Teuchos::RCP< const Stokhos::EpetraVectorOrthogPoly > get_p_sg_init(int l) const
Return initial SG parameters.
bool supports_x
Whether we support x (and thus f and W)
Abstract base class for quadrature methods.
int num_p
Number of parameter vectors of underlying model evaluator.
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.
A container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor.
virtual Teuchos::RCP< Stokhos::EpetraOperatorOrthogPoly > getSGPolynomial()=0
Get SG polynomial.
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > create_x_sg_overlap() const
Create vector orthog poly using x map and overlap sg map.
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > x_dot_sg_blocks
x_dot stochastic Galerkin components
Teuchos::RCP< const Epetra_Map > adapted_overlapped_f_map
Block SG overlapped residual map.
Teuchos::RCP< const Epetra_BlockMap > overlapped_stoch_row_map
Overlapped map for stochastic blocks (local map)
Teuchos::Array< Teuchos::RCP< const Epetra_Map > > get_g_sg_base_maps() const
Get base maps of SG responses.
Abstract base class for multivariate orthogonal polynomials generated from tensor products of univari...
Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > create_x_mv_sg(int num_vecs) const
Create vector orthog poly using x map and owned sg map.
Teuchos::RCP< const Epetra_Map > adapted_f_map
Block SG residual map.
Teuchos::RCP< const Epetra_Map > adapted_x_map
Block SG unknown map.
Teuchos::RCP< const Stokhos::EpetraVectorOrthogPoly > get_x_sg_init() const
Return initial SG x.
Teuchos::Array< Teuchos::RCP< const Epetra_Map > > sg_p_map
Block SG parameter map.
Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > create_f_mv_sg_overlap(int num_vecs) const
Create multi-vector orthog poly using f map and overlap sg map.
Teuchos::RCP< Stokhos::EpetraOperatorOrthogPoly > W_sg_blocks
W stochastic Galerkin components.
Teuchos::RCP< Epetra_Import > adapted_overlapped_x_importer
Importer from SG to SG-overlapped maps.
Teuchos::RCP< const Epetra_BlockMap > get_x_sg_overlap_map() const
Return x sg overlap map.
Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > create_x_mv_sg_overlap(int num_vecs) const
Create vector orthog poly using x map and overlap sg map.
Teuchos::RCP< const Epetra_Vector > get_p_init(int l) const
Return initial parameters.
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.
Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > create_f_mv_sg(int num_vecs) const
Create multi-vector orthog poly using f map and owned sg map.
Teuchos::Array< int > sg_p_index_map
Index map between block-p and p_sg maps.
Teuchos::RCP< const Epetra_Vector > get_x_init() const
Return initial solution.
int num_p_sg
Number of stochastic parameter vectors.
void set_x_sg_init(const Stokhos::EpetraVectorOrthogPoly &x_sg_in)
Set initial solution polynomial.
unsigned int num_sg_blocks
Number of stochastic blocks.
Teuchos::Array< int > sg_g_index_map
Index map between block-g and g_sg maps.
Teuchos::RCP< const EpetraExt::MultiComm > sg_comm
Parallel SG communicator.
Teuchos::RCP< const Epetra_Import > get_x_sg_importer() const
Return x sg importer.
Teuchos::RCP< Epetra_Vector > my_x
x pointer for evaluating preconditioner
Teuchos::RCP< const Stokhos::OrthogPolyBasis< int, double > > sg_basis
Stochastic Galerkin basis.
Teuchos::RCP< Teuchos::ParameterList > params
Algorithmic parameters.
unsigned int num_p_blocks
Number of p stochastic blocks (may be smaller than num_sg_blocks)
Teuchos::RCP< Stokhos::AdaptivityManager > adaptMngr
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > create_f_sg() const
Create vector orthog poly using f map and owned sg map.
ScalarType g(const Teuchos::Array< ScalarType > &x, const ScalarType &y)
Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > f_sg_blocks
f stochastic Galerkin components
Teuchos::RCP< const Epetra_BlockMap > overlapped_stoch_p_map
Overlapped map for p stochastic blocks (local map)
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 > ¶ms_)
A container class storing an orthogonal polynomial whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor.
Teuchos::Array< Teuchos::RCP< Stokhos::EpetraVectorOrthogPoly > > sg_p_init
SG initial p.
Teuchos::RCP< const Epetra_Map > f_map
Underlying residual map.