669 const OutArgs& outArgs)
const
672 Teuchos::RCP<const Epetra_Vector> x;
673 if (inArgs.supports(IN_ARG_x)) {
675 if (x != Teuchos::null)
678 Teuchos::RCP<const Epetra_Vector> x_dot;
679 if (inArgs.supports(IN_ARG_x_dot))
680 x_dot = inArgs.get_x_dot();
683 EpetraExt::ModelEvaluator::Evaluation<Epetra_Vector> f_out;
684 if (outArgs.supports(OUT_ARG_f))
685 f_out = outArgs.get_f();
686 Teuchos::RCP<Epetra_Operator> W_out;
687 if (outArgs.supports(OUT_ARG_W))
688 W_out = outArgs.get_W();
691 InArgs me_inargs = me->createInArgs();
692 if (x != Teuchos::null) {
694 adaptMngr->copyFromAdaptiveVector(*x,*x_sg_blocks);
695 me_inargs.set_x_sg(x_sg_blocks);
697 if (x_dot != Teuchos::null) {
699 adaptMngr->copyFromAdaptiveVector(*x_dot,*x_dot_sg_blocks);
700 me_inargs.set_x_dot_sg(x_dot_sg_blocks);
702 if (me_inargs.supports(IN_ARG_alpha))
703 me_inargs.set_alpha(inArgs.get_alpha());
704 if (me_inargs.supports(IN_ARG_beta))
705 me_inargs.set_beta(inArgs.get_beta());
706 if (me_inargs.supports(IN_ARG_t))
707 me_inargs.set_t(inArgs.get_t());
708 if (me_inargs.supports(IN_ARG_sg_basis)) {
709 if (inArgs.get_sg_basis() != Teuchos::null)
710 me_inargs.set_sg_basis(inArgs.get_sg_basis());
712 me_inargs.set_sg_basis(sg_basis);
714 if (me_inargs.supports(IN_ARG_sg_quadrature)) {
715 if (inArgs.get_sg_quadrature() != Teuchos::null)
716 me_inargs.set_sg_quadrature(inArgs.get_sg_quadrature());
718 me_inargs.set_sg_quadrature(sg_quad);
720 if (me_inargs.supports(IN_ARG_sg_expansion)) {
721 if (inArgs.get_sg_expansion() != Teuchos::null)
722 me_inargs.set_sg_expansion(inArgs.get_sg_expansion());
724 me_inargs.set_sg_expansion(sg_exp);
728 for (
int i=0; i<num_p; i++)
729 me_inargs.set_p(i, inArgs.get_p(i));
730 for (
int i=0; i<num_p_sg; i++) {
731 Teuchos::RCP<const Epetra_Vector> p = inArgs.get_p(i+num_p);
735 if (p == Teuchos::null)
736 p = sg_p_init[i]->getBlockVector();
739 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> p_sg =
740 create_p_sg(sg_p_index_map[i],
View, p.get());
741 me_inargs.set_p_sg(sg_p_index_map[i], p_sg);
745 OutArgs me_outargs = me->createOutArgs();
748 if (f_out != Teuchos::null) {
749 me_outargs.set_f_sg(f_sg_blocks);
751 me_outargs.set_W_sg(W_sg_blocks);
755 if (W_out != Teuchos::null && !eval_W_with_f )
756 me_outargs.set_W_sg(W_sg_blocks);
759 for (
int i=0; i<num_p; i++) {
760 if (!outArgs.supports(OUT_ARG_DfDp, i).none()) {
761 Derivative dfdp = outArgs.get_DfDp(i);
762 if (dfdp.getMultiVector() != Teuchos::null) {
763 Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly> dfdp_sg;
764 if (dfdp.getMultiVectorOrientation() == DERIV_MV_BY_COL)
767 sg_basis, overlapped_stoch_row_map,
768 me->get_f_map(), sg_comm,
769 me->get_p_map(i)->NumMyElements()));
770 else if (dfdp.getMultiVectorOrientation() == DERIV_TRANS_MV_BY_ROW)
773 sg_basis, overlapped_stoch_row_map,
774 me->get_p_map(i), sg_comm,
775 me->get_f_map()->NumMyElements()));
776 me_outargs.set_DfDp_sg(i,
777 SGDerivative(dfdp_sg,
778 dfdp.getMultiVectorOrientation()));
780 TEUCHOS_TEST_FOR_EXCEPTION(dfdp.getLinearOp() != Teuchos::null, std::logic_error,
781 "Error! Stokhos::SGModelEvaluator_Adaptive::evalModel " <<
782 "cannot handle operator form of df/dp!");
787 for (
int i=0; i<num_g_sg; i++) {
788 int ii = sg_g_index_map[i];
791 Teuchos::RCP<Epetra_Vector>
g = outArgs.get_g(i);
792 if (
g != Teuchos::null) {
793 Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> g_sg =
794 create_g_sg(sg_g_index_map[i],
View,
g.get());
795 me_outargs.set_g_sg(ii, g_sg);
799 if (outArgs.supports(OUT_ARG_DgDx_dot, i).supports(DERIV_LINEAR_OP)) {
800 Derivative dgdx_dot = outArgs.get_DgDx_dot(i);
801 if (dgdx_dot.getLinearOp() != Teuchos::null) {
802 Teuchos::RCP<Stokhos::SGOperator> op =
803 Teuchos::rcp_dynamic_cast<Stokhos::SGOperator>(
804 dgdx_dot.getLinearOp(),
true);
805 Teuchos::RCP< Stokhos::EpetraOperatorOrthogPoly > sg_blocks =
806 op->getSGPolynomial();
807 if (me_outargs.supports(OUT_ARG_DgDx, ii).supports(DERIV_LINEAR_OP))
808 me_outargs.set_DgDx_dot_sg(ii, sg_blocks);
810 for (
unsigned int k=0; k<num_sg_blocks; k++) {
811 Teuchos::RCP<Epetra_MultiVector> mv =
812 Teuchos::rcp_dynamic_cast<Stokhos::EpetraMultiVectorOperator>(
813 sg_blocks->getCoeffPtr(k),
true)->getMultiVector();
814 dgdx_dot_sg_blocks[i]->setCoeffPtr(k, mv);
816 if (me_outargs.supports(OUT_ARG_DgDx_dot_sg, ii).supports(DERIV_MV_BY_COL))
817 me_outargs.set_DgDx_dot_sg(ii, SGDerivative(dgdx_dot_sg_blocks[i],
820 me_outargs.set_DgDx_dot_sg(ii, SGDerivative(dgdx_dot_sg_blocks[i],
821 DERIV_TRANS_MV_BY_ROW));
824 TEUCHOS_TEST_FOR_EXCEPTION(dgdx_dot.getLinearOp() == Teuchos::null &&
825 dgdx_dot.isEmpty() ==
false,
827 "Error! Stokhos::SGModelEvaluator_Adaptive::evalModel: " <<
828 "Operator form of dg/dxdot is required!");
832 if (outArgs.supports(OUT_ARG_DgDx, i).supports(DERIV_LINEAR_OP)) {
833 Derivative dgdx = outArgs.get_DgDx(i);
834 if (dgdx.getLinearOp() != Teuchos::null) {
835 Teuchos::RCP<Stokhos::SGOperator> op =
836 Teuchos::rcp_dynamic_cast<Stokhos::SGOperator>(
837 dgdx.getLinearOp(),
true);
838 Teuchos::RCP< Stokhos::EpetraOperatorOrthogPoly > sg_blocks =
839 op->getSGPolynomial();
840 if (me_outargs.supports(OUT_ARG_DgDx, ii).supports(DERIV_LINEAR_OP))
841 me_outargs.set_DgDx_sg(ii, sg_blocks);
843 for (
unsigned int k=0; k<num_sg_blocks; k++) {
844 Teuchos::RCP<Epetra_MultiVector> mv =
845 Teuchos::rcp_dynamic_cast<Stokhos::EpetraMultiVectorOperator>(
846 sg_blocks->getCoeffPtr(k),
true)->getMultiVector();
847 dgdx_sg_blocks[i]->setCoeffPtr(k, mv);
849 if (me_outargs.supports(OUT_ARG_DgDx_sg, ii).supports(DERIV_MV_BY_COL))
850 me_outargs.set_DgDx_sg(ii, SGDerivative(dgdx_sg_blocks[i],
853 me_outargs.set_DgDx_sg(ii, SGDerivative(dgdx_sg_blocks[i],
854 DERIV_TRANS_MV_BY_ROW));
857 TEUCHOS_TEST_FOR_EXCEPTION(dgdx.getLinearOp() == Teuchos::null &&
858 dgdx.isEmpty() ==
false,
860 "Error! Stokhos::SGModelEvaluator_Adaptive::evalModel: " <<
861 "Operator form of dg/dxdot is required!");
866 for (
int j=0;
j<num_p;
j++) {
867 if (!outArgs.supports(OUT_ARG_DgDp, i,
j).none()) {
868 Derivative dgdp = outArgs.get_DgDp(i,
j);
869 if (dgdp.getMultiVector() != Teuchos::null) {
870 Teuchos::RCP<Stokhos::EpetraMultiVectorOrthogPoly> dgdp_sg;
871 if (dgdp.getMultiVectorOrientation() == DERIV_MV_BY_COL)
874 sg_basis, overlapped_stoch_row_map,
875 me->get_g_map(ii), sg_g_map[i], sg_comm,
876 View, *(dgdp.getMultiVector())));
877 else if (dgdp.getMultiVectorOrientation() == DERIV_TRANS_MV_BY_ROW) {
878 Teuchos::RCP<const Epetra_BlockMap> product_map =
879 Teuchos::rcp(&(dgdp.getMultiVector()->Map()),
false);
882 sg_basis, overlapped_stoch_row_map,
883 me->get_p_map(
j), product_map, sg_comm,
884 View, *(dgdp.getMultiVector())));
886 me_outargs.set_DgDp_sg(ii,
j,
887 SGDerivative(dgdp_sg,
888 dgdp.getMultiVectorOrientation()));
890 TEUCHOS_TEST_FOR_EXCEPTION(dgdp.getLinearOp() != Teuchos::null,
892 "Error! Stokhos::SGModelEvaluator_Adaptive::evalModel " <<
893 "cannot handle operator form of dg/dp!");
900 me->evalModel(me_inargs, me_outargs);
903 if ((W_out != Teuchos::null || (eval_W_with_f && f_out != Teuchos::null)) ) {
905 Teuchos::RCP<Epetra_Operator> W;
906 if (W_out != Teuchos::null)
911 Teuchos::RCP<Epetra_CrsMatrix> W_sg = Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(W,
true);
912 adaptMngr->setupOperator(*W_sg,*Cijk,*W_sg_blocks);
916 if (f_out!=Teuchos::null){
918 for (
int i=0; i<sg_basis->size(); i++)
919 (*f_sg_blocks)[i].Scale(sg_basis->norm_squared(i));
921 adaptMngr->copyToAdaptiveVector(*f_sg_blocks,*f_out);
925 for (
int i=0; i<num_p; i++) {
926 if (!outArgs.supports(OUT_ARG_DfDp, i).none()) {
927 Derivative dfdp = outArgs.get_DfDp(i);
928 SGDerivative dfdp_sg = me_outargs.get_DfDp_sg(i);
929 if (dfdp.getMultiVector() != Teuchos::null) {
931 dfdp.getMultiVector()->Export(
932 *(dfdp_sg.getMultiVector()->getBlockMultiVector()),
933 *adapted_overlapped_f_exporter,
Insert);