43 #include "Thyra_LinearOpWithSolveFactoryHelpers.hpp" 46 #include "Thyra_DetachedMultiVectorView.hpp" 47 #include "Thyra_ModelEvaluatorDelegatorBase.hpp" 48 #include "EpetraExt_ModelEvaluatorScalingTools.h" 49 #include "Epetra_RowMatrix.h" 50 #include "Teuchos_Time.hpp" 51 #include "Teuchos_implicit_cast.hpp" 52 #include "Teuchos_Assert.hpp" 53 #include "Teuchos_StandardParameterEntryValidators.hpp" 54 #include "Teuchos_VerboseObjectParameterListHelpers.hpp" 60 const std::string StateFunctionScaling_name =
"State Function Scaling";
62 Teuchos::StringToIntegralParameterEntryValidator<
66 stateFunctionScalingValidator;
67 const std::string StateFunctionScaling_default =
"None";
71 Teuchos::RCP<Epetra_RowMatrix>
73 const EpetraExt::ModelEvaluator::OutArgs &epetraOutArgs
77 const RCP<Epetra_Operator>
78 eW = epetraOutArgs.get_W();
79 const RCP<Epetra_RowMatrix>
80 ermW = Teuchos::rcp_dynamic_cast<Epetra_RowMatrix>(eW,
false);
81 TEUCHOS_TEST_FOR_EXCEPTION(
82 is_null(ermW), std::logic_error,
83 "Thyra::EpetraModelEvaluator::evalModel(...): Error, if\n" 84 "scaling is turned on, the underlying Epetra_Operator created\n" 85 "an initialized by the underlying epetra model evaluator\n" 86 "\"" << epetraOutArgs.modelEvalDescription() <<
"\"\n" 87 "must support the Epetra_RowMatrix interface through a dynamic cast.\n" 88 "The concrete type " << Teuchos::typeName(*eW) <<
" does not support\n" 95 Teuchos::RCP<Epetra_Operator>
97 const EpetraExt::ModelEvaluator &epetraModel
102 eW = epetraModel.create_W();
103 TEUCHOS_TEST_FOR_EXCEPTION(
104 is_null(eW), std::logic_error,
105 "Error, the call to create_W() returned null on the " 106 "EpetraExt::ModelEvaluator object " 107 "\"" << epetraModel.description() <<
"\". This may mean that " 108 "the underlying model does not support more than one copy of " 124 :nominalValuesAndBoundsAreUpdated_(false), stateFunctionScaling_(STATE_FUNC_SCALING_NONE),
125 currentInArgsOutArgs_(false), finalPointWasSolved_(false)
130 const RCP<const EpetraExt::ModelEvaluator> &epetraModel,
131 const RCP<LinearOpWithSolveFactoryBase<double> > &W_factory
133 :nominalValuesAndBoundsAreUpdated_(false), stateFunctionScaling_(STATE_FUNC_SCALING_NONE),
134 currentInArgsOutArgs_(false), finalPointWasSolved_(false)
141 const RCP<const EpetraExt::ModelEvaluator> &epetraModel,
142 const RCP<LinearOpWithSolveFactoryBase<double> > &W_factory
145 using Teuchos::implicit_cast;
159 EpetraExt::ModelEvaluator::InArgs inArgs =
epetraModel_->createInArgs();
162 for(
int l = 0; l < implicit_cast<int>(
p_space_.size()); ++l ) {
163 RCP<const Epetra_Map>
166 TEUCHOS_TEST_FOR_EXCEPTION(
167 is_null(p_map_l), std::logic_error,
168 "Error, the the map p["<<l<<
"] for the model \"" 169 <<epetraModel->description()<<
"\" can not be null!");
176 EpetraExt::ModelEvaluator::OutArgs outArgs =
epetraModel_->createOutArgs();
179 for(
int j = 0; j < implicit_cast<int>(
g_space_.size()); ++j ) {
180 RCP<const Epetra_Map>
196 RCP<const EpetraExt::ModelEvaluator>
204 const ModelEvaluatorBase::InArgs<double>& nominalValues
213 const RCP<const Epetra_Vector> &stateVariableScalingVec
217 typedef ModelEvaluatorBase MEB;
218 TEUCHOS_TEST_FOR_EXCEPT( !this->
createInArgs().supports(MEB::IN_ARG_x) );
226 RCP<const Epetra_Vector>
233 RCP<const Epetra_Vector>
242 const RCP<const Epetra_Vector> &stateFunctionScalingVec
249 RCP<const Epetra_Vector>
257 RCP<const EpetraExt::ModelEvaluator> *epetraModel,
258 RCP<LinearOpWithSolveFactoryBase<double> > *W_factory
272 const ModelEvaluatorBase::InArgs<double>&
290 std::ostringstream oss;
291 oss <<
"Thyra::EpetraModelEvaluator{";
292 oss <<
"epetraModel=";
297 oss <<
",W_factory=";
311 RCP<Teuchos::ParameterList>
const& paramList
314 TEUCHOS_TEST_FOR_EXCEPT(is_null(paramList));
319 *
paramList_, StateFunctionScaling_name, StateFunctionScaling_default
323 Teuchos::readVerboseObjectSublist(&*
paramList_,
this);
326 #endif // TEUCHOS_DEBUG 330 RCP<Teuchos::ParameterList>
337 RCP<Teuchos::ParameterList>
340 RCP<Teuchos::ParameterList> _paramList =
paramList_;
346 RCP<const Teuchos::ParameterList>
353 RCP<const Teuchos::ParameterList>
357 using Teuchos::StringToIntegralParameterEntryValidator;
358 using Teuchos::tuple;
359 using Teuchos::rcp_implicit_cast;
360 typedef Teuchos::ParameterEntryValidator PEV;
361 static RCP<const Teuchos::ParameterList> validPL;
362 if(is_null(validPL)) {
363 RCP<Teuchos::ParameterList>
364 pl = Teuchos::rcp(
new Teuchos::ParameterList());
365 stateFunctionScalingValidator = rcp(
366 new StringToIntegralParameterEntryValidator<EStateFunctionScaling>(
372 "Do not scale the state function f(...) in this class.",
374 "Scale the state function f(...) and all its derivatives\n" 375 "using the row sum scaling from the initial Jacobian\n" 376 "W=d(f)/d(x). Note, this only works with Epetra_CrsMatrix\n" 379 tuple<EStateFunctionScaling>(
383 StateFunctionScaling_name
386 pl->set(StateFunctionScaling_name,StateFunctionScaling_default,
387 "Determines if and how the state function f(...) and all of its\n" 388 "derivatives are scaled. The scaling is done explicitly so there should\n" 389 "be no impact on the meaning of inner products or tolerances for\n" 391 rcp_implicit_cast<const PEV>(stateFunctionScalingValidator)
393 Teuchos::setupVerboseObjectSublist(&*pl);
415 RCP<const VectorSpaceBase<double> >
422 RCP<const VectorSpaceBase<double> >
429 RCP<const VectorSpaceBase<double> >
433 TEUCHOS_ASSERT_IN_RANGE_UPPER_EXCLUSIVE( l, 0, this->
Np() );
439 RCP<const Teuchos::Array<std::string> >
443 TEUCHOS_ASSERT_IN_RANGE_UPPER_EXCLUSIVE( l, 0, this->
Np() );
449 RCP<const VectorSpaceBase<double> >
452 TEUCHOS_TEST_FOR_EXCEPT( ! ( 0 <= j && j < this->
Ng() ) );
457 Teuchos::ArrayView<const std::string>
461 TEUCHOS_ASSERT_IN_RANGE_UPPER_EXCLUSIVE( j, 0, this->
Ng() );
467 ModelEvaluatorBase::InArgs<double>
475 ModelEvaluatorBase::InArgs<double>
483 ModelEvaluatorBase::InArgs<double>
491 RCP<LinearOpBase<double> >
498 RCP<PreconditionerBase<double> >
501 return Teuchos::null;
505 RCP<const LinearOpWithSolveFactoryBase<double> >
521 const ModelEvaluatorBase::InArgs<double> &finalPoint,
534 RCP<LinearOpBase<double> >
537 TEUCHOS_TEST_FOR_EXCEPT(
true);
538 return Teuchos::null;
542 RCP<LinearOpBase<double> >
545 TEUCHOS_TEST_FOR_EXCEPT(
true);
546 return Teuchos::null;
550 RCP<LinearOpBase<double> >
553 TEUCHOS_TEST_FOR_EXCEPT(
true);
554 return Teuchos::null;
558 RCP<LinearOpBase<double> >
561 TEUCHOS_TEST_FOR_EXCEPT(
true);
562 return Teuchos::null;
566 ModelEvaluatorBase::OutArgs<double>
576 const ModelEvaluatorBase::InArgs<double>& inArgs_in,
577 const ModelEvaluatorBase::OutArgs<double>& outArgs
582 using Teuchos::rcp_const_cast;
583 using Teuchos::rcp_dynamic_cast;
584 using Teuchos::OSTab;
585 using Teuchos::includesVerbLevel;
586 typedef EpetraExt::ModelEvaluator EME;
604 inArgs.setArgs(inArgs_in);
610 if (inArgs.supports(Thyra::ModelEvaluatorBase::IN_ARG_x_dot)) {
611 if (is_null(inArgs_in.get_x_dot()))
612 inArgs.set_x_dot(Teuchos::null);
616 typedef double Scalar;
617 THYRA_MODEL_EVALUATOR_DECORATOR_EVAL_MODEL_GEN_BEGIN(
618 "Thyra::EpetraModelEvaluator",inArgs,outArgs,Teuchos::null
622 const bool firstTimeStateFuncScaling
628 typedef Teuchos::VerboseObjectTempState<LinearOpWithSolveFactoryBase<double> > VOTSLOWSF;
629 VOTSLOWSF W_factory_outputTempState(
W_factory_,out,verbLevel);
631 Teuchos::Time timer(
"");
642 if (out.get() && includesVerbLevel(verbLevel,Teuchos::VERB_LOW))
643 *out <<
"\nSetting-up/creating input arguments ...\n";
647 EME::InArgs epetraScaledInArgs =
epetraModel_->createInArgs();
652 EME::InArgs epetraInArgs =
epetraModel_->createInArgs();
653 EpetraExt::unscaleModelVars(
659 if (out.get() && includesVerbLevel(verbLevel,Teuchos::VERB_LOW))
660 OSTab(out).o() <<
"\nTime to setup InArgs = "<<timer.totalElapsedTime()<<
" sec\n";
666 if (out.get() && includesVerbLevel(verbLevel,Teuchos::VERB_LOW))
667 *out <<
"\nSetting-up/creating output arguments ...\n";
672 EME::OutArgs epetraUnscaledOutArgs =
epetraModel_->createOutArgs();
676 RCP<LinearOpBase<double> > W_op;
677 RCP<EpetraLinearOp> efwdW;
678 RCP<Epetra_Operator> eW;
684 &epetraUnscaledOutArgs,
692 if (firstTimeStateFuncScaling) {
697 if (out.get() && includesVerbLevel(verbLevel,Teuchos::VERB_LOW))
699 <<
"\nTime to setup OutArgs = " 700 << timer.totalElapsedTime() <<
" sec\n";
706 if (out.get() && includesVerbLevel(verbLevel,Teuchos::VERB_LOW))
707 *out <<
"\nEvaluating the Epetra output functions ...\n";
710 epetraModel_->evalModel(epetraInArgs,epetraUnscaledOutArgs);
713 if (out.get() && includesVerbLevel(verbLevel,Teuchos::VERB_LOW))
715 <<
"\nTime to evaluate Epetra output functions = " 716 << timer.totalElapsedTime() <<
" sec\n";
726 if (out.get() && includesVerbLevel(verbLevel,Teuchos::VERB_LOW))
727 *out <<
"\nCompute scale factors if needed ...\n";
730 if (firstTimeStateFuncScaling) {
735 if (out.get() && includesVerbLevel(verbLevel,Teuchos::VERB_LOW))
737 <<
"\nTime to compute scale factors = " 738 << timer.totalElapsedTime() <<
" sec\n";
744 if (out.get() && includesVerbLevel(verbLevel,Teuchos::VERB_LOW))
745 *out <<
"\nScale the output objects ...\n";
748 EME::OutArgs epetraOutArgs =
epetraModel_->createOutArgs();
749 bool allFuncsWhereScaled =
false;
750 EpetraExt::scaleModelFuncs(
752 &epetraOutArgs, &allFuncsWhereScaled,
757 TEUCHOS_TEST_FOR_EXCEPTION(
758 !allFuncsWhereScaled, std::logic_error,
759 "Error, we can not currently handle epetra output objects that could not be" 760 " scaled. Special code will have to be added to handle this (i.e. using" 761 " implicit diagonal and multiplied linear operators to implicitly do" 766 if (out.get() && includesVerbLevel(verbLevel,Teuchos::VERB_LOW))
768 <<
"\nTime to scale the output objects = " 769 << timer.totalElapsedTime() <<
" sec\n";
776 if (out.get() && includesVerbLevel(verbLevel,Teuchos::VERB_LOW))
777 *out <<
"\nFinish processing and wrapping the output objects ...\n";
781 epetraOutArgs, W_op, efwdW, eW,
786 if (out.get() && includesVerbLevel(verbLevel,Teuchos::VERB_LOW))
788 <<
"\nTime to finish processing and wrapping the output objects = " 789 << timer.totalElapsedTime() <<
" sec\n";
795 THYRA_MODEL_EVALUATOR_DECORATOR_EVAL_MODEL_END();
804 const EpetraExt::ModelEvaluator::InArgs &epetraInArgs,
805 ModelEvaluatorBase::InArgs<double> *inArgs
809 using Teuchos::implicit_cast;
810 typedef ModelEvaluatorBase MEB;
812 TEUCHOS_TEST_FOR_EXCEPT(!inArgs);
814 if(inArgs->supports(MEB::IN_ARG_x)) {
818 if(inArgs->supports(MEB::IN_ARG_x_dot)) {
822 if(inArgs->supports(MEB::IN_ARG_x_mp)) {
823 inArgs->set_x_mp( epetraInArgs.get_x_mp() );
826 if(inArgs->supports(MEB::IN_ARG_x_dot_mp)) {
827 inArgs->set_x_dot_mp( epetraInArgs.get_x_dot_mp() );
830 const int l_Np = inArgs->Np();
831 for(
int l = 0; l < l_Np; ++l ) {
834 for(
int l = 0; l < l_Np; ++l ) {
835 if(inArgs->supports(MEB::IN_ARG_p_mp, l))
836 inArgs->set_p_mp( l, epetraInArgs.get_p_mp(l) );
839 if(inArgs->supports(MEB::IN_ARG_t)) {
840 inArgs->set_t(epetraInArgs.get_t());
847 const ModelEvaluatorBase::InArgs<double> &inArgs,
848 EpetraExt::ModelEvaluator::InArgs *epetraInArgs
853 using Teuchos::rcp_const_cast;
854 #ifdef HAVE_THYRA_ME_POLYNOMIAL 855 using Teuchos::Polynomial;
856 #endif // HAVE_THYRA_ME_POLYNOMIAL 859 TEUCHOS_TEST_FOR_EXCEPT(0==epetraInArgs);
861 RCP<const VectorBase<double> > x_dot;
862 if( inArgs.supports(IN_ARG_x_dot) && (x_dot = inArgs.get_x_dot()).
get() ) {
864 epetraInArgs->set_x_dot(e_x_dot);
866 RCP<const Stokhos::ProductEpetraVector > x_dot_mp;
867 if( inArgs.supports(IN_ARG_x_dot_mp) && (x_dot_mp = inArgs.get_x_dot_mp()).
get() ) {
868 epetraInArgs->set_x_dot_mp(x_dot_mp);
871 RCP<const VectorBase<double> > x;
872 if( inArgs.supports(IN_ARG_x) && (x = inArgs.get_x()).
get() ) {
874 epetraInArgs->set_x(e_x);
876 RCP<const Stokhos::ProductEpetraVector > x_mp;
877 if( inArgs.supports(IN_ARG_x_mp) && (x_mp = inArgs.get_x_mp()).
get() ) {
878 epetraInArgs->set_x_mp(x_mp);
881 RCP<const VectorBase<double> > p_l;
882 for(
int l = 0; l < inArgs.Np(); ++l ) {
883 p_l = inArgs.get_p(l);
886 RCP<const Stokhos::ProductEpetraVector > p_mp_l;
887 for(
int l = 0; l < inArgs.Np(); ++l ) {
888 if (inArgs.supports(IN_ARG_p_mp,l)) {
889 p_mp_l = inArgs.get_p_mp(l);
890 if(p_mp_l.get()) epetraInArgs->set_p_mp(l,p_mp_l);
894 #ifdef HAVE_THYRA_ME_POLYNOMIAL 896 RCP<const Polynomial< VectorBase<double> > > x_dot_poly;
897 RCP<Epetra_Vector> epetra_ptr;
899 inArgs.supports(IN_ARG_x_dot_poly)
900 && (x_dot_poly = inArgs.get_x_dot_poly()).
get()
903 RCP<Polynomial<Epetra_Vector> > epetra_x_dot_poly =
904 rcp(
new Polynomial<Epetra_Vector>(x_dot_poly->degree()));
905 for (
unsigned int i=0; i<=x_dot_poly->degree(); i++) {
906 epetra_ptr = rcp_const_cast<Epetra_Vector>(
908 epetra_x_dot_poly->setCoefficientPtr(i,epetra_ptr);
910 epetraInArgs->set_x_dot_poly(epetra_x_dot_poly);
913 RCP<const Polynomial< VectorBase<double> > > x_poly;
915 inArgs.supports(IN_ARG_x_poly)
916 && (x_poly = inArgs.get_x_poly()).
get()
919 RCP<Polynomial<Epetra_Vector> > epetra_x_poly =
920 rcp(
new Polynomial<Epetra_Vector>(x_poly->degree()));
921 for (
unsigned int i=0; i<=x_poly->degree(); i++) {
922 epetra_ptr = rcp_const_cast<Epetra_Vector>(
924 epetra_x_poly->setCoefficientPtr(i,epetra_ptr);
926 epetraInArgs->set_x_poly(epetra_x_poly);
929 #endif // HAVE_THYRA_ME_POLYNOMIAL 931 if( inArgs.supports(IN_ARG_t) )
932 epetraInArgs->set_t(inArgs.get_t());
934 if( inArgs.supports(IN_ARG_alpha) )
935 epetraInArgs->set_alpha(inArgs.get_alpha());
937 if( inArgs.supports(IN_ARG_beta) )
938 epetraInArgs->set_beta(inArgs.get_beta());
940 if( inArgs.supports(IN_ARG_step_size) )
941 epetraInArgs->set_step_size(inArgs.get_step_size());
943 if( inArgs.supports(IN_ARG_stage_number) )
944 epetraInArgs->set_stage_number(inArgs.get_stage_number());
949 const ModelEvaluatorBase::OutArgs<double> &outArgs,
950 EpetraExt::ModelEvaluator::OutArgs *epetraUnscaledOutArgs_inout,
951 RCP<LinearOpBase<double> > *W_op_out,
952 RCP<EpetraLinearOp> *efwdW_out,
953 RCP<Epetra_Operator> *eW_out
958 using Teuchos::rcp_const_cast;
959 using Teuchos::rcp_dynamic_cast;
960 using Teuchos::OSTab;
961 using Teuchos::implicit_cast;
967 TEUCHOS_ASSERT(epetraUnscaledOutArgs_inout);
968 TEUCHOS_ASSERT(W_op_out);
969 TEUCHOS_ASSERT(efwdW_out);
970 TEUCHOS_ASSERT(eW_out);
974 EpetraExt::ModelEvaluator::OutArgs &epetraUnscaledOutArgs = *epetraUnscaledOutArgs_inout;
975 RCP<LinearOpBase<double> > &W_op = *W_op_out;
976 RCP<EpetraLinearOp> &efwdW = *efwdW_out;
977 RCP<Epetra_Operator> &eW = *eW_out;
981 RCP<VectorBase<double> > f;
982 if( outArgs.supports(OUT_ARG_f) && (f = outArgs.get_f()).
get() )
984 RCP<Stokhos::ProductEpetraVector > f_mp;
985 if( outArgs.supports(OUT_ARG_f_mp) && (f_mp = outArgs.get_f_mp()).
get() )
986 epetraUnscaledOutArgs.set_f_mp(f_mp);
991 RCP<VectorBase<double> > g_j;
992 for(
int j = 0; j < outArgs.Ng(); ++j ) {
993 g_j = outArgs.get_g(j);
996 RCP<Stokhos::ProductEpetraVector > g_mp_j;
997 for(
int j = 0; j < outArgs.Ng(); ++j ) {
998 if (outArgs.supports(OUT_ARG_g_mp,j)) {
999 g_mp_j = outArgs.get_g_mp(j);
1000 if(g_mp_j.get()) epetraUnscaledOutArgs.set_g_mp(j,g_mp_j);
1007 RCP<Stokhos::ProductEpetraOperator > W_mp;
1008 if( outArgs.supports(OUT_ARG_W_mp) && (W_mp = outArgs.get_W_mp()).
get() )
1009 epetraUnscaledOutArgs.set_W_mp(W_mp);
1015 if (outArgs.supports(OUT_ARG_W_op) && nonnull(W_op = outArgs.get_W_op())) {
1016 if (nonnull(W_op) && is_null(efwdW)) {
1022 if (nonnull(efwdW)) {
1027 eW = efwdW->epetra_op();
1028 epetraUnscaledOutArgs.set_W(eW);
1037 Derivative<double> DfDp_l;
1038 for(
int l = 0; l < outArgs.Np(); ++l ) {
1039 if( !outArgs.supports(OUT_ARG_DfDp,l).none()
1040 && !(DfDp_l = outArgs.get_DfDp(l)).isEmpty() )
1045 MPDerivative DfDp_mp_l;
1046 for(
int l = 0; l < outArgs.Np(); ++l ) {
1047 if( !outArgs.supports(OUT_ARG_DfDp_mp,l).none()
1048 && !(DfDp_mp_l = outArgs.get_DfDp_mp(l)).isEmpty() )
1057 Derivative<double> DgDx_dot_j;
1058 for(
int j = 0; j < outArgs.Ng(); ++j ) {
1059 if( !outArgs.supports(OUT_ARG_DgDx_dot,j).none()
1060 && !(DgDx_dot_j = outArgs.get_DgDx_dot(j)).isEmpty() )
1065 MPDerivative DgDx_dot_mp_j;
1066 for(
int j = 0; j < outArgs.Ng(); ++j ) {
1067 if( !outArgs.supports(OUT_ARG_DgDx_dot_mp,j).none()
1068 && !(DgDx_dot_mp_j = outArgs.get_DgDx_dot_mp(j)).isEmpty() )
1077 Derivative<double> DgDx_j;
1078 for(
int j = 0; j < outArgs.Ng(); ++j ) {
1079 if( !outArgs.supports(OUT_ARG_DgDx,j).none()
1080 && !(DgDx_j = outArgs.get_DgDx(j)).isEmpty() )
1085 MPDerivative DgDx_mp_j;
1086 for(
int j = 0; j < outArgs.Ng(); ++j ) {
1087 if( !outArgs.supports(OUT_ARG_DgDx_mp,j).none()
1088 && !(DgDx_mp_j = outArgs.get_DgDx_mp(j)).isEmpty() )
1097 DerivativeSupport DgDp_j_l_support;
1098 Derivative<double> DgDp_j_l;
1099 for (
int j = 0; j < outArgs.Ng(); ++j ) {
1100 for (
int l = 0; l < outArgs.Np(); ++l ) {
1101 if (!(DgDp_j_l_support = outArgs.supports(OUT_ARG_DgDp,j,l)).none()
1102 && !(DgDp_j_l = outArgs.get_DgDp(j,l)).isEmpty() )
1108 DerivativeSupport DgDp_mp_j_l_support;
1109 MPDerivative DgDp_mp_j_l;
1110 for (
int j = 0; j < outArgs.Ng(); ++j ) {
1111 for (
int l = 0; l < outArgs.Np(); ++l ) {
1112 if (!(DgDp_mp_j_l_support = outArgs.supports(OUT_ARG_DgDp_mp,j,l)).none()
1113 && !(DgDp_mp_j_l = outArgs.get_DgDp_mp(j,l)).isEmpty() )
1121 #ifdef HAVE_THYRA_ME_POLYNOMIAL 1124 RCP<const Teuchos::Polynomial< VectorBase<double> > > f_poly;
1125 if( outArgs.supports(OUT_ARG_f_poly) && (f_poly = outArgs.get_f_poly()).
get() )
1127 RCP<Teuchos::Polynomial<Epetra_Vector> > epetra_f_poly =
1128 Teuchos::rcp(
new Teuchos::Polynomial<Epetra_Vector>(f_poly->degree()));
1129 for (
unsigned int i=0; i<=f_poly->degree(); i++) {
1130 RCP<Epetra_Vector> epetra_ptr
1132 f_poly->getCoefficient(i)));
1133 epetra_f_poly->setCoefficientPtr(i,epetra_ptr);
1135 epetraUnscaledOutArgs.set_f_poly(epetra_f_poly);
1138 #endif // HAVE_THYRA_ME_POLYNOMIAL 1144 EpetraExt::ModelEvaluator::InArgs *epetraInArgs_inout,
1145 EpetraExt::ModelEvaluator::OutArgs *epetraUnscaledOutArgs_inout,
1146 const RCP<Teuchos::FancyOStream> &out,
1147 const Teuchos::EVerbosityLevel verbLevel
1151 typedef EpetraExt::ModelEvaluator EME;
1153 #ifdef TEUCHOS_DEBUG 1154 TEUCHOS_ASSERT(epetraInArgs_inout);
1155 TEUCHOS_ASSERT(epetraUnscaledOutArgs_inout);
1158 EpetraExt::ModelEvaluator::InArgs
1159 &epetraInArgs = *epetraInArgs_inout;
1160 EpetraExt::ModelEvaluator::OutArgs
1161 &epetraUnscaledOutArgs = *epetraUnscaledOutArgs_inout;
1167 epetraUnscaledOutArgs.supports(EME::OUT_ARG_f)
1169 epetraUnscaledOutArgs.funcOrDerivesAreSet(EME::OUT_ARG_f)
1173 epetraUnscaledOutArgs.supports(EME::OUT_ARG_W)
1175 is_null(epetraUnscaledOutArgs.get_W())
1188 if(out.get() && verbLevel >= Teuchos::VERB_LOW)
1190 <<
"\nCreating a temporary Epetra W to compute scale factors" 1191 <<
" for f(...) ...\n";
1192 epetraUnscaledOutArgs.set_W(create_and_assert_W(*
epetraModel_));
1193 if( epetraInArgs.supports(EME::IN_ARG_beta) )
1194 epetraInArgs.set_beta(1.0);
1195 if( epetraInArgs.supports(EME::IN_ARG_alpha) )
1196 epetraInArgs.set_alpha(0.0);
1197 if( epetraInArgs.supports(EME::IN_ARG_step_size) )
1198 epetraInArgs.set_step_size(0.0);
1199 if( epetraInArgs.supports(EME::IN_ARG_stage_number) )
1200 epetraInArgs.set_stage_number(1.0);
1207 const EpetraExt::ModelEvaluator::OutArgs &epetraUnscaledOutArgs,
1208 const RCP<Teuchos::FancyOStream> &out,
1209 const Teuchos::EVerbosityLevel verbLevel
1213 using Teuchos::OSTab;
1215 using Teuchos::rcp_const_cast;
1216 using Teuchos::includesVerbLevel;
1225 const RCP<Epetra_RowMatrix>
1226 ermW = get_Epetra_RowMatrix(epetraUnscaledOutArgs);
1233 invRowSums = rcp(
new Epetra_Vector(ermW->OperatorRangeMap()));
1237 ermW->InvRowSums(*invRowSums);
1239 if (out.get() && includesVerbLevel(verbLevel,Teuchos::VERB_LOW)) {
1241 <<
"\nComputed inverse row sum scaling from W that" 1242 " will be used to scale f(...) and its derivatives:\n";
1243 double minVal = 0, maxVal = 0, avgVal = 0;
1244 invRowSums->MinValue(&minVal);
1245 invRowSums->MaxValue(&maxVal);
1246 invRowSums->MeanValue(&avgVal);
1249 <<
"min(invRowSums) = " << minVal <<
"\n" 1250 <<
"max(invRowSums) = " << maxVal <<
"\n" 1251 <<
"avg(invRowSums) = " << avgVal <<
"\n";
1261 TEUCHOS_TEST_FOR_EXCEPT(
"Should never get here!");
1274 const EpetraExt::ModelEvaluator::OutArgs &epetraOutArgs,
1275 RCP<LinearOpBase<double> > &W_op,
1276 RCP<EpetraLinearOp> &efwdW,
1277 RCP<Epetra_Operator> &eW,
1278 const ModelEvaluatorBase::OutArgs<double> &outArgs
1282 using Teuchos::rcp_dynamic_cast;
1285 if (nonnull(efwdW)) {
1286 efwdW->setFullyInitialized(
true);
1290 if (nonnull(W_op)) {
1291 if (W_op.shares_resource(efwdW)) {
1295 rcp_dynamic_cast<
EpetraLinearOp>(W_op,
true)->setFullyInitialized(
true);
1306 using Teuchos::implicit_cast;
1308 typedef EpetraExt::ModelEvaluator EME;
1314 EME::InArgs epetraOrigNominalValues;
1315 EpetraExt::gatherModelNominalValues(
1318 EME::InArgs epetraOrigLowerBounds;
1319 EME::InArgs epetraOrigUpperBounds;
1320 EpetraExt::gatherModelBounds(
1321 *
epetraModel_, &epetraOrigLowerBounds, &epetraOrigUpperBounds );
1330 if( epetraOrigNominalValues.supports(EME::IN_ARG_x_dot) ) {
1333 if( epetraOrigNominalValues.supports(EME::IN_ARG_x) ) {
1340 EME::InArgs epetraScaledNominalValues =
epetraModel_->createInArgs();
1341 EpetraExt::scaleModelVars(
1345 EME::InArgs epetraScaledLowerBounds =
epetraModel_->createInArgs();
1346 EME::InArgs epetraScaledUpperBounds =
epetraModel_->createInArgs();
1347 EpetraExt::scaleModelBounds(
1348 epetraOrigLowerBounds, epetraOrigUpperBounds,
epetraModel_->getInfBound(),
1350 &epetraScaledLowerBounds, &epetraScaledUpperBounds
1378 typedef EpetraExt::ModelEvaluator EME;
1380 const EpetraExt::ModelEvaluator &epetraModel = *
epetraModel_;
1381 EME::InArgs epetraInArgs = epetraModel.createInArgs();
1382 EME::OutArgs epetraOutArgs = epetraModel.createOutArgs();
1383 const int l_Np = epetraOutArgs.Np();
1384 const int l_Ng = epetraOutArgs.Ng();
1390 InArgsSetup<double> inArgs;
1391 inArgs.setModelEvalDescription(this->
description());
1392 inArgs.set_Np(epetraInArgs.Np());
1393 inArgs.setSupports(IN_ARG_x_dot, epetraInArgs.supports(EME::IN_ARG_x_dot));
1394 inArgs.setSupports(IN_ARG_x, epetraInArgs.supports(EME::IN_ARG_x));
1395 inArgs.setSupports(IN_ARG_x_dot_mp, epetraInArgs.supports(EME::IN_ARG_x_dot_mp));
1396 inArgs.setSupports(IN_ARG_x_mp, epetraInArgs.supports(EME::IN_ARG_x_mp));
1397 #ifdef HAVE_THYRA_ME_POLYNOMIAL 1398 inArgs.setSupports(IN_ARG_x_dot_poly,
1399 epetraInArgs.supports(EME::IN_ARG_x_dot_poly));
1400 inArgs.setSupports(IN_ARG_x_poly, epetraInArgs.supports(EME::IN_ARG_x_poly));
1401 #endif // HAVE_THYRA_ME_POLYNOMIAL 1402 inArgs.setSupports(IN_ARG_t, epetraInArgs.supports(EME::IN_ARG_t));
1403 inArgs.setSupports(IN_ARG_alpha, epetraInArgs.supports(EME::IN_ARG_alpha));
1404 inArgs.setSupports(IN_ARG_beta, epetraInArgs.supports(EME::IN_ARG_beta));
1405 inArgs.setSupports(IN_ARG_step_size, epetraInArgs.supports(EME::IN_ARG_step_size));
1406 inArgs.setSupports(IN_ARG_stage_number, epetraInArgs.supports(EME::IN_ARG_stage_number));
1407 for(
int l=0; l<l_Np; ++l) {
1408 inArgs.setSupports(IN_ARG_p_mp, l, epetraInArgs.supports(EME::IN_ARG_p_mp, l));
1416 OutArgsSetup<double> outArgs;
1417 outArgs.setModelEvalDescription(this->
description());
1418 outArgs.set_Np_Ng(l_Np, l_Ng);
1420 outArgs.setSupports(OUT_ARG_f, epetraOutArgs.supports(EME::OUT_ARG_f));
1421 outArgs.setSupports(OUT_ARG_f_mp, epetraOutArgs.supports(EME::OUT_ARG_f_mp));
1422 if (outArgs.supports(OUT_ARG_f)) {
1424 outArgs.setSupports(OUT_ARG_W_op, epetraOutArgs.supports(EME::OUT_ARG_W));
1425 outArgs.set_W_properties(
convert(epetraOutArgs.get_W_properties()));
1427 for(
int l=0; l<l_Np; ++l) {
1428 outArgs.setSupports(OUT_ARG_DfDp, l,
1429 convert(epetraOutArgs.supports(EME::OUT_ARG_DfDp, l)));
1430 if(!outArgs.supports(OUT_ARG_DfDp, l).none())
1431 outArgs.set_DfDp_properties(l,
1432 convert(epetraOutArgs.get_DfDp_properties(l)));
1433 if (outArgs.supports(OUT_ARG_f_mp))
1435 outArgs.setSupports(OUT_ARG_DfDp_mp, l,
1436 convert(epetraOutArgs.supports(EME::OUT_ARG_DfDp_mp, l)));
1437 if(!outArgs.supports(OUT_ARG_DfDp_mp, l).none())
1438 outArgs.set_DfDp_mp_properties(l,
1439 convert(epetraOutArgs.get_DfDp_mp_properties(l)));
1444 for(
int j=0; j<l_Ng; ++j) {
1445 if (inArgs.supports(IN_ARG_x_dot))
1446 outArgs.setSupports(OUT_ARG_DgDx_dot, j,
1447 convert(epetraOutArgs.supports(EME::OUT_ARG_DgDx_dot, j)));
1448 if(!outArgs.supports(OUT_ARG_DgDx_dot, j).none())
1449 outArgs.set_DgDx_dot_properties(j,
1450 convert(epetraOutArgs.get_DgDx_dot_properties(j)));
1451 if (inArgs.supports(IN_ARG_x))
1452 outArgs.setSupports(OUT_ARG_DgDx, j,
1453 convert(epetraOutArgs.supports(EME::OUT_ARG_DgDx, j)));
1454 if(!outArgs.supports(OUT_ARG_DgDx, j).none())
1455 outArgs.set_DgDx_properties(j,
1456 convert(epetraOutArgs.get_DgDx_properties(j)));
1457 if (inArgs.supports(IN_ARG_x_dot_mp))
1458 outArgs.setSupports(OUT_ARG_DgDx_dot_mp, j,
1459 convert(epetraOutArgs.supports(EME::OUT_ARG_DgDx_dot_mp, j)));
1460 if(!outArgs.supports(OUT_ARG_DgDx_dot_mp, j).none())
1461 outArgs.set_DgDx_dot_mp_properties(j,
1462 convert(epetraOutArgs.get_DgDx_dot_mp_properties(j)));
1463 if (inArgs.supports(IN_ARG_x_mp))
1464 outArgs.setSupports(OUT_ARG_DgDx_mp, j,
1465 convert(epetraOutArgs.supports(EME::OUT_ARG_DgDx_mp, j)));
1466 if(!outArgs.supports(OUT_ARG_DgDx_mp, j).none())
1467 outArgs.set_DgDx_mp_properties(j,
1468 convert(epetraOutArgs.get_DgDx_mp_properties(j)));
1471 for(
int j=0; j < l_Ng; ++j)
for(
int l=0; l < l_Np; ++l) {
1472 const EME::DerivativeSupport epetra_DgDp_j_l_support =
1473 epetraOutArgs.supports(EME::OUT_ARG_DgDp, j, l);
1474 outArgs.setSupports(OUT_ARG_DgDp, j, l,
1475 convert(epetra_DgDp_j_l_support));
1476 if(!outArgs.supports(OUT_ARG_DgDp, j, l).none())
1477 outArgs.set_DgDp_properties(j, l,
1478 convert(epetraOutArgs.get_DgDp_properties(j, l)));
1479 const EME::DerivativeSupport epetra_DgDp_mp_j_l_support =
1480 epetraOutArgs.supports(EME::OUT_ARG_DgDp_mp, j, l);
1481 outArgs.setSupports(OUT_ARG_DgDp_mp, j, l,
1482 convert(epetra_DgDp_mp_j_l_support));
1483 if(!outArgs.supports(OUT_ARG_DgDp_mp, j, l).none())
1484 outArgs.set_DgDp_mp_properties(j, l,
1485 convert(epetraOutArgs.get_DgDp_mp_properties(j, l)));
1487 for(
int j=0; j<l_Ng; ++j) {
1488 outArgs.setSupports(OUT_ARG_g_mp, j, epetraOutArgs.supports(EME::OUT_ARG_g_mp, j));
1490 #ifdef HAVE_THYRA_ME_POLYNOMIAL 1491 outArgs.setSupports(OUT_ARG_f_poly,
1492 epetraOutArgs.supports(EME::OUT_ARG_f_poly));
1493 #endif // HAVE_THYRA_ME_POLYNOMIAL 1505 return Thyra::partialNonconstEpetraLinearOp(
1520 Teuchos::RCP<Thyra::EpetraModelEvaluator>
1521 Thyra::epetraModelEvaluator(
1522 const RCP<const EpetraExt::ModelEvaluator> &epetraModel,
1523 const RCP<LinearOpWithSolveFactoryBase<double> > &W_factory
1526 return Teuchos::rcp(
new EpetraModelEvaluator(epetraModel,W_factory));
1530 Thyra::ModelEvaluatorBase::EDerivativeMultiVectorOrientation
1532 const EpetraExt::ModelEvaluator::EDerivativeMultiVectorOrientation &mvOrientation
1535 switch(mvOrientation) {
1536 case EpetraExt::ModelEvaluator::DERIV_MV_BY_COL :
1537 return ModelEvaluatorBase::DERIV_MV_BY_COL;
1538 case EpetraExt::ModelEvaluator::DERIV_TRANS_MV_BY_ROW :
1539 return ModelEvaluatorBase::DERIV_TRANS_MV_BY_ROW;
1541 TEUCHOS_TEST_FOR_EXCEPT(
true);
1543 return ModelEvaluatorBase::DERIV_MV_BY_COL;
1547 EpetraExt::ModelEvaluator::EDerivativeMultiVectorOrientation
1549 const ModelEvaluatorBase::EDerivativeMultiVectorOrientation &mvOrientation
1552 switch(mvOrientation) {
1553 case ModelEvaluatorBase::DERIV_MV_BY_COL :
1554 return EpetraExt::ModelEvaluator::DERIV_MV_BY_COL;
1555 case ModelEvaluatorBase::DERIV_TRANS_MV_BY_ROW :
1556 return EpetraExt::ModelEvaluator::DERIV_TRANS_MV_BY_ROW;
1558 TEUCHOS_TEST_FOR_EXCEPT(
true);
1560 return EpetraExt::ModelEvaluator::DERIV_MV_BY_COL;
1564 Thyra::ModelEvaluatorBase::DerivativeProperties
1566 const EpetraExt::ModelEvaluator::DerivativeProperties &derivativeProperties
1569 ModelEvaluatorBase::EDerivativeLinearity linearity;
1570 switch(derivativeProperties.linearity) {
1571 case EpetraExt::ModelEvaluator::DERIV_LINEARITY_UNKNOWN:
1572 linearity = ModelEvaluatorBase::DERIV_LINEARITY_UNKNOWN;
1574 case EpetraExt::ModelEvaluator::DERIV_LINEARITY_CONST:
1575 linearity = ModelEvaluatorBase::DERIV_LINEARITY_CONST;
1577 case EpetraExt::ModelEvaluator::DERIV_LINEARITY_NONCONST:
1578 linearity = ModelEvaluatorBase::DERIV_LINEARITY_NONCONST;
1581 TEUCHOS_TEST_FOR_EXCEPT(
true);
1583 ModelEvaluatorBase::ERankStatus rank;
1584 switch(derivativeProperties.rank) {
1585 case EpetraExt::ModelEvaluator::DERIV_RANK_UNKNOWN:
1586 rank = ModelEvaluatorBase::DERIV_RANK_UNKNOWN;
1588 case EpetraExt::ModelEvaluator::DERIV_RANK_FULL:
1589 rank = ModelEvaluatorBase::DERIV_RANK_FULL;
1591 case EpetraExt::ModelEvaluator::DERIV_RANK_DEFICIENT:
1592 rank = ModelEvaluatorBase::DERIV_RANK_DEFICIENT;
1595 TEUCHOS_TEST_FOR_EXCEPT(
true);
1597 return ModelEvaluatorBase::DerivativeProperties(
1598 linearity,rank,derivativeProperties.supportsAdjoint);
1602 Thyra::ModelEvaluatorBase::DerivativeSupport
1604 const EpetraExt::ModelEvaluator::DerivativeSupport &derivativeSupport
1607 ModelEvaluatorBase::DerivativeSupport ds;
1608 if(derivativeSupport.supports(EpetraExt::ModelEvaluator::DERIV_LINEAR_OP))
1609 ds.plus(ModelEvaluatorBase::DERIV_LINEAR_OP);
1610 if(derivativeSupport.supports(EpetraExt::ModelEvaluator::DERIV_MV_BY_COL))
1611 ds.plus(ModelEvaluatorBase::DERIV_MV_BY_COL);
1612 if(derivativeSupport.supports(EpetraExt::ModelEvaluator::DERIV_TRANS_MV_BY_ROW))
1613 ds.plus(ModelEvaluatorBase::DERIV_TRANS_MV_BY_ROW);
1618 EpetraExt::ModelEvaluator::Derivative
1620 const ModelEvaluatorBase::Derivative<double> &derivative,
1621 const RCP<const Epetra_Map> &fnc_map,
1622 const RCP<const Epetra_Map> &var_map
1625 typedef ModelEvaluatorBase MEB;
1626 if(derivative.getLinearOp().get()) {
1627 return EpetraExt::ModelEvaluator::Derivative(
1628 Teuchos::rcp_const_cast<Epetra_Operator>(
1629 Teuchos::dyn_cast<const EpetraLinearOp>(*derivative.getLinearOp()).epetra_op()
1633 else if(derivative.getDerivativeMultiVector().getMultiVector().get()) {
1634 return EpetraExt::ModelEvaluator::Derivative(
1635 EpetraExt::ModelEvaluator::DerivativeMultiVector(
1637 ( derivative.getDerivativeMultiVector().getOrientation() == MEB::DERIV_MV_BY_COL
1641 ,derivative.getDerivativeMultiVector().getMultiVector()
1643 ,
convert(derivative.getDerivativeMultiVector().getOrientation())
1647 return EpetraExt::ModelEvaluator::Derivative();
1649 EpetraExt::ModelEvaluator::MPDerivative
1651 const ModelEvaluatorBase::MPDerivative &derivative,
1652 const RCP<const Epetra_Map> &fnc_map,
1653 const RCP<const Epetra_Map> &var_map
1657 if(derivative.getLinearOp().get()) {
1658 return EpetraExt::ModelEvaluator::MPDerivative(
1659 derivative.getLinearOp()
1662 else if(derivative.getDerivativeMultiVector().getMultiVector().get()) {
1663 return EpetraExt::ModelEvaluator::MPDerivative(
1664 EpetraExt::ModelEvaluator::MPDerivativeMultiVector(
1665 derivative.getDerivativeMultiVector().getMultiVector()
1666 ,
convert(derivative.getDerivativeMultiVector().getOrientation())
1670 return EpetraExt::ModelEvaluator::MPDerivative();
RCP< Epetra_MultiVector > get_Epetra_MultiVector(const Epetra_Map &map, const RCP< MultiVectorBase< double > > &mv)
Get a non-const Epetra_MultiVector view from a non-const MultiVectorBase object if possible...
void preEvalScalingSetup(EpetraExt::ModelEvaluator::InArgs *epetraInArgs, EpetraExt::ModelEvaluator::OutArgs *epetraUnscaledOutArgs, const RCP< Teuchos::FancyOStream > &out, const Teuchos::EVerbosityLevel verbLevel) const
void setNominalValues(const ModelEvaluatorBase::InArgs< double > &nominalValues)
Set the nominal values.
RCP< const EpetraExt::ModelEvaluator > getEpetraModel() const
bool finalPointWasSolved() const
Concrete LinearOpBase adapter subclass for Epetra_Operator object.
RCP< const VectorSpaceBase< double > > get_g_space(int j) const
RCP< const Epetra_Map > x_map_
void reportFinalPoint(const ModelEvaluatorBase::InArgs< double > &finalPoint, const bool wasSolved)
RCP< EpetraLinearOp > create_epetra_W_op() const
RCP< LinearOpBase< double > > create_W_op() const
void evalModelImpl(const ModelEvaluatorBase::InArgs< double > &inArgs, const ModelEvaluatorBase::OutArgs< double > &outArgs) const
void updateInArgsOutArgs() const
RCP< const VectorSpaceBase< double > > get_x_space() const
RCP< Teuchos::ParameterList > getNonconstParameterList()
p_map_is_local_t g_map_is_local_
RCP< LinearOpWithSolveFactoryBase< double > > W_factory_
RCP< const VectorSpaceBase< double > > create_VectorSpace(const RCP< const Epetra_Map > &epetra_map)
Create an VectorSpaceBase object given an Epetra_Map object.
EStateFunctionScaling stateFunctionScaling_
std::string description() const
void setStateVariableScalingVec(const RCP< const Epetra_Vector > &stateVariableScalingVec)
Set the state variable scaling vector s_x (see above).
void convertInArgsFromThyraToEpetra(const ModelEvaluatorBase::InArgs< double > &inArgs, EpetraExt::ModelEvaluator::InArgs *epetraInArgs) const
RCP< const Teuchos::Array< std::string > > get_p_names(int l) const
RCP< const Teuchos::ParameterList > getParameterList() const
ModelEvaluatorBase::OutArgs< double > createOutArgsImpl() const
const ModelEvaluatorBase::InArgs< double > & getFinalPoint() const
void convertOutArgsFromThyraToEpetra(const ModelEvaluatorBase::OutArgs< double > &outArgs, EpetraExt::ModelEvaluator::OutArgs *epetraUnscaledOutArgs, RCP< LinearOpBase< double > > *W_op, RCP< EpetraLinearOp > *efwdW, RCP< Epetra_Operator > *eW) const
RCP< VectorBase< double > > create_Vector(const RCP< Epetra_Vector > &epetra_v, const RCP< const VectorSpaceBase< double > > &space)
Create a non-const VectorBase object from a non-const Epetra_Vector object.
EpetraExt::ModelEvaluator::OutArgs epetraOutArgsScaling_
RCP< const VectorSpaceBase< double > > x_space_
ModelEvaluatorBase::OutArgs< double > prototypeOutArgs_
RCP< const Epetra_Vector > getStateVariableInvScalingVec() const
Get the state variable scaling vector s_x (see above).
ModelEvaluatorBase::InArgs< double > getNominalValues() const
RCP< LinearOpBase< double > > create_DgDx_dot_op_impl(int j) const
EpetraExt::ModelEvaluator::MPDerivative convert(const ModelEvaluatorBase::MPDerivative &derivative, const RCP< const Epetra_Map > &fnc_map, const RCP< const Epetra_Map > &var_map)
void finishConvertingOutArgsFromEpetraToThyra(const EpetraExt::ModelEvaluator::OutArgs &epetraOutArgs, RCP< LinearOpBase< double > > &W_op, RCP< EpetraLinearOp > &efwdW, RCP< Epetra_Operator > &eW, const ModelEvaluatorBase::OutArgs< double > &outArgs) const
RCP< const VectorSpaceBase< double > > f_space_
ModelEvaluatorBase::InArgs< double > finalPoint_
void setStateFunctionScalingVec(const RCP< const Epetra_Vector > &stateFunctionScalingVec)
Set the state function scaling vector s_f (see above).
void postEvalScalingSetup(const EpetraExt::ModelEvaluator::OutArgs &epetraUnscaledOutArgs, const RCP< Teuchos::FancyOStream > &out, const Teuchos::EVerbosityLevel verbLevel) const
ModelEvaluatorBase::InArgs< double > lowerBounds_
RCP< Epetra_Vector > get_Epetra_Vector(const Epetra_Map &map, const RCP< VectorBase< double > > &v)
Get a non-const Epetra_Vector view from a non-const VectorBase object if possible.
void initialize(const RCP< const EpetraExt::ModelEvaluator > &epetraModel, const RCP< LinearOpWithSolveFactoryBase< double > > &W_factory)
ModelEvaluatorBase::InArgs< double > getLowerBounds() const
EpetraExt::ModelEvaluator::InArgs epetraInArgsScaling_
bool currentInArgsOutArgs_
bool finalPointWasSolved_
void setParameterList(RCP< Teuchos::ParameterList > const ¶mList)
void updateNominalValuesAndBounds() const
RCP< const Epetra_Vector > stateFunctionScalingVec_
ModelEvaluatorBase::EDerivativeMultiVectorOrientation convert(const EpetraExt::ModelEvaluator::EDerivativeMultiVectorOrientation &mvOrientation)
void uninitialize(RCP< const EpetraExt::ModelEvaluator > *epetraModel=NULL, RCP< LinearOpWithSolveFactoryBase< double > > *W_factory=NULL)
bool nominalValuesAndBoundsAreUpdated_
RCP< LinearOpBase< double > > create_DfDp_op_impl(int l) const
void convertInArgsFromEpetraToThyra(const EpetraExt::ModelEvaluator::InArgs &epetraInArgs, ModelEvaluatorBase::InArgs< double > *inArgs) const
ModelEvaluatorBase::InArgs< double > prototypeInArgs_
ModelEvaluatorBase::InArgs< double > getUpperBounds() const
RCP< const Epetra_Map > f_map_
RCP< LinearOpBase< double > > create_DgDp_op_impl(int j, int l) const
RCP< const Epetra_Vector > stateVariableScalingVec_
RCP< const EpetraExt::ModelEvaluator > epetraModel_
RCP< Teuchos::ParameterList > paramList_
ModelEvaluatorBase::InArgs< double > nominalValues_
RCP< PreconditionerBase< double > > create_W_prec() const
Returns null currently.
p_map_is_local_t p_map_is_local_
RCP< const Epetra_Vector > getStateFunctionScalingVec() const
Get the state function scaling vector s_f (see above).
RCP< const LinearOpWithSolveFactoryBase< double > > get_W_factory() const
Teuchos::ArrayView< const std::string > get_g_names(int j) const
RCP< LinearOpBase< double > > create_DgDx_op_impl(int j) const
ModelEvaluatorBase::InArgs< double > createInArgs() const
RCP< const VectorSpaceBase< double > > get_f_space() const
RCP< const VectorSpaceBase< double > > get_p_space(int l) const
RCP< const Epetra_Vector > getStateVariableScalingVec() const
Get the inverse state variable scaling vector inv_s_x (see above).
RCP< Teuchos::ParameterList > unsetParameterList()
RCP< const Teuchos::ParameterList > getValidParameters() const
RCP< const Epetra_Vector > invStateVariableScalingVec_
ModelEvaluatorBase::InArgs< double > upperBounds_