42 #include "Thyra_EpetraModelEvaluator.hpp" 43 #include "Thyra_LinearOpWithSolveFactoryHelpers.hpp" 45 #include "Thyra_EpetraLinearOp.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<
63 Thyra::EpetraModelEvaluator::EStateFunctionScaling
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,
133 :nominalValuesAndBoundsAreUpdated_(false), stateFunctionScaling_(STATE_FUNC_SCALING_NONE),
134 currentInArgsOutArgs_(false), finalPointWasSolved_(false)
141 const RCP<const EpetraExt::ModelEvaluator> &epetraModel,
145 using Teuchos::implicit_cast;
148 epetraModel_ = epetraModel;
150 W_factory_ = W_factory;
152 x_map_ = epetraModel_->get_x_map();
153 f_map_ = epetraModel_->get_f_map();
154 if (!is_null(x_map_)) {
159 EpetraExt::ModelEvaluator::InArgs inArgs = epetraModel_->createInArgs();
160 p_map_.resize(inArgs.Np()); p_space_.resize(inArgs.Np());
161 p_map_is_local_.resize(inArgs.Np(),
false);
162 for(
int l = 0; l < implicit_cast<int>(p_space_.size()); ++l ) {
163 RCP<const Epetra_Map>
164 p_map_l = ( p_map_[l] = epetraModel_->get_p_map(l) );
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!");
172 p_map_is_local_[l] = !p_map_l->DistributedGlobal();
176 EpetraExt::ModelEvaluator::OutArgs outArgs = epetraModel_->createOutArgs();
177 g_map_.resize(outArgs.Ng()); g_space_.resize(outArgs.Ng());
178 g_map_is_local_.resize(outArgs.Ng(),
false);
179 for(
int j = 0; j < implicit_cast<int>(g_space_.size()); ++j ) {
180 RCP<const Epetra_Map>
181 g_map_j = ( g_map_[j] = epetraModel_->get_g_map(j) );
182 g_map_is_local_[j] = !g_map_j->DistributedGlobal();
186 epetraInArgsScaling_ = epetraModel_->createInArgs();
187 epetraOutArgsScaling_ = epetraModel_->createOutArgs();
188 nominalValuesAndBoundsAreUpdated_ =
false;
189 finalPointWasSolved_ =
false;
190 stateFunctionScalingVec_ = Teuchos::null;
192 currentInArgsOutArgs_ =
false;
196 RCP<const EpetraExt::ModelEvaluator>
207 nominalValues_.
setArgs(nominalValues);
213 const RCP<const Epetra_Vector> &stateVariableScalingVec
218 TEUCHOS_TEST_FOR_EXCEPT( !this->
createInArgs().supports(MEB::IN_ARG_x) );
220 stateVariableScalingVec_ = stateVariableScalingVec.assert_not_null();
221 invStateVariableScalingVec_ = Teuchos::null;
222 nominalValuesAndBoundsAreUpdated_ =
false;
226 RCP<const Epetra_Vector>
229 return stateVariableScalingVec_;
233 RCP<const Epetra_Vector>
236 updateNominalValuesAndBounds();
237 return invStateVariableScalingVec_;
242 const RCP<const Epetra_Vector> &stateFunctionScalingVec
245 stateFunctionScalingVec_ = stateFunctionScalingVec;
249 RCP<const Epetra_Vector>
252 return stateFunctionScalingVec_;
257 RCP<const EpetraExt::ModelEvaluator> *epetraModel,
261 if(epetraModel) *epetraModel = epetraModel_;
262 if(W_factory) *W_factory = W_factory_;
263 epetraModel_ = Teuchos::null;
264 W_factory_ = Teuchos::null;
265 stateFunctionScalingVec_ = Teuchos::null;
266 stateVariableScalingVec_ = Teuchos::null;
267 invStateVariableScalingVec_ = Teuchos::null;
268 currentInArgsOutArgs_ =
false;
281 return finalPointWasSolved_;
290 std::ostringstream oss;
291 oss <<
"Thyra::EpetraModelEvaluator{";
292 oss <<
"epetraModel=";
293 if(epetraModel_.get())
294 oss <<
"\'"<<epetraModel_->description()<<
"\'";
297 oss <<
",W_factory=";
299 oss <<
"\'"<<W_factory_->description()<<
"\'";
311 RCP<Teuchos::ParameterList>
const& paramList
314 TEUCHOS_TEST_FOR_EXCEPT(is_null(paramList));
316 paramList_ = paramList;
317 const EStateFunctionScaling stateFunctionScaling_old = stateFunctionScaling_;
318 stateFunctionScaling_ = stateFunctionScalingValidator->getIntegralValue(
319 *paramList_, StateFunctionScaling_name, StateFunctionScaling_default
321 if( stateFunctionScaling_ != stateFunctionScaling_old )
322 stateFunctionScalingVec_ = Teuchos::null;
323 Teuchos::readVerboseObjectSublist(&*paramList_,
this);
326 #endif // TEUCHOS_DEBUG 330 RCP<Teuchos::ParameterList>
337 RCP<Teuchos::ParameterList>
340 RCP<Teuchos::ParameterList> _paramList = paramList_;
341 paramList_ = Teuchos::null;
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>(
380 STATE_FUNC_SCALING_NONE,
381 STATE_FUNC_SCALING_ROW_SUM
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);
405 return p_space_.size();
411 return g_space_.size();
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() );
445 return epetraModel_->get_p_names(l);
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() );
463 return epetraModel_->get_g_names(j);
470 updateNominalValuesAndBounds();
471 return nominalValues_;
478 updateNominalValuesAndBounds();
486 updateNominalValuesAndBounds();
491 RCP<LinearOpBase<double> >
494 return this->create_epetra_W_op();
498 RCP<PreconditionerBase<double> >
501 return Teuchos::null;
505 RCP<const LinearOpWithSolveFactoryBase<double> >
514 if (!currentInArgsOutArgs_)
515 updateInArgsOutArgs();
516 return prototypeInArgs_;
526 finalPoint_.
setArgs(finalPoint);
527 finalPointWasSolved_ = wasSolved;
534 RCP<LinearOpBase<double> >
535 EpetraModelEvaluator::create_DfDp_op_impl(
int l)
const 537 TEUCHOS_TEST_FOR_EXCEPT(
true);
538 return Teuchos::null;
542 RCP<LinearOpBase<double> >
543 EpetraModelEvaluator::create_DgDx_dot_op_impl(
int j)
const 545 TEUCHOS_TEST_FOR_EXCEPT(
true);
546 return Teuchos::null;
550 RCP<LinearOpBase<double> >
551 EpetraModelEvaluator::create_DgDx_op_impl(
int j)
const 553 TEUCHOS_TEST_FOR_EXCEPT(
true);
554 return Teuchos::null;
558 RCP<LinearOpBase<double> >
559 EpetraModelEvaluator::create_DgDp_op_impl(
int j,
int l )
const 561 TEUCHOS_TEST_FOR_EXCEPT(
true);
562 return Teuchos::null;
566 ModelEvaluatorBase::OutArgs<double>
567 EpetraModelEvaluator::createOutArgsImpl()
const 569 if (!currentInArgsOutArgs_)
570 updateInArgsOutArgs();
571 return prototypeOutArgs_;
575 void EpetraModelEvaluator::evalModelImpl(
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;
593 this->updateNominalValuesAndBounds();
604 inArgs.setArgs(inArgs_in);
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
624 stateFunctionScaling_ != STATE_FUNC_SCALING_NONE
625 && is_null(stateFunctionScalingVec_)
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();
648 convertInArgsFromThyraToEpetra( inArgs, &epetraScaledInArgs );
652 EME::InArgs epetraInArgs = epetraModel_->createInArgs();
653 EpetraExt::unscaleModelVars(
654 epetraScaledInArgs, epetraInArgsScaling_, &epetraInArgs,
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;
682 convertOutArgsFromThyraToEpetra(
684 &epetraUnscaledOutArgs,
692 if (firstTimeStateFuncScaling) {
693 preEvalScalingSetup(&epetraInArgs,&epetraUnscaledOutArgs,out,verbLevel);
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) {
731 postEvalScalingSetup(epetraUnscaledOutArgs,out,verbLevel);
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(
751 epetraUnscaledOutArgs, epetraInArgsScaling_, epetraOutArgsScaling_,
752 &epetraOutArgs, &allFuncsWhereScaled,
756 if (stateFunctionScaling_ != STATE_FUNC_SCALING_NONE)
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";
780 finishConvertingOutArgsFromEpetraToThyra(
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();
803 void EpetraModelEvaluator::convertInArgsFromEpetraToThyra(
804 const EpetraExt::ModelEvaluator::InArgs &epetraInArgs,
805 ModelEvaluatorBase::InArgs<double> *inArgs
809 using Teuchos::implicit_cast;
812 TEUCHOS_TEST_FOR_EXCEPT(!inArgs);
814 if(inArgs->supports(MEB::IN_ARG_x)) {
815 inArgs->set_x(
create_Vector( epetraInArgs.get_x(), x_space_ ) );
818 if(inArgs->supports(MEB::IN_ARG_x_dot)) {
819 inArgs->set_x_dot(
create_Vector( epetraInArgs.get_x_dot(), x_space_ ) );
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 ) {
832 inArgs->set_p( l,
create_Vector( epetraInArgs.get_p(l), p_space_[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());
846 void EpetraModelEvaluator::convertInArgsFromThyraToEpetra(
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 ) {
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;
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;
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 932 epetraInArgs->set_t(inArgs.get_t());
935 epetraInArgs->set_alpha(inArgs.get_alpha());
938 epetraInArgs->set_beta(inArgs.get_beta());
941 epetraInArgs->set_step_size(inArgs.get_step_size());
944 epetraInArgs->set_stage_number(inArgs.get_stage_number());
948 void EpetraModelEvaluator::convertOutArgsFromThyraToEpetra(
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 ) {
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)) {
1017 efwdW = rcp_const_cast<EpetraLinearOp>(
1018 rcp_dynamic_cast<
const EpetraLinearOp>(W_op,
true));
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 ) {
1040 && !(DfDp_l = outArgs.get_DfDp(l)).isEmpty() )
1042 epetraUnscaledOutArgs.set_DfDp(l,
convert(DfDp_l,f_map_,p_map_[l]));
1045 MPDerivative DfDp_mp_l;
1046 for(
int l = 0; l < outArgs.Np(); ++l ) {
1048 && !(DfDp_mp_l = outArgs.get_DfDp_mp(l)).isEmpty() )
1050 epetraUnscaledOutArgs.set_DfDp_mp(l,
convert(DfDp_mp_l,f_map_,p_map_[l]));
1057 Derivative<double> DgDx_dot_j;
1058 for(
int j = 0; j < outArgs.Ng(); ++j ) {
1060 && !(DgDx_dot_j = outArgs.get_DgDx_dot(j)).isEmpty() )
1062 epetraUnscaledOutArgs.set_DgDx_dot(j,
convert(DgDx_dot_j,g_map_[j],x_map_));
1065 MPDerivative DgDx_dot_mp_j;
1066 for(
int j = 0; j < outArgs.Ng(); ++j ) {
1068 && !(DgDx_dot_mp_j = outArgs.get_DgDx_dot_mp(j)).isEmpty() )
1070 epetraUnscaledOutArgs.set_DgDx_dot_mp(j,
convert(DgDx_dot_mp_j,g_map_[j],x_map_));
1077 Derivative<double> DgDx_j;
1078 for(
int j = 0; j < outArgs.Ng(); ++j ) {
1080 && !(DgDx_j = outArgs.get_DgDx(j)).isEmpty() )
1082 epetraUnscaledOutArgs.set_DgDx(j,
convert(DgDx_j,g_map_[j],x_map_));
1085 MPDerivative DgDx_mp_j;
1086 for(
int j = 0; j < outArgs.Ng(); ++j ) {
1088 && !(DgDx_mp_j = outArgs.get_DgDx_mp(j)).isEmpty() )
1090 epetraUnscaledOutArgs.set_DgDx_mp(j,
convert(DgDx_mp_j,g_map_[j],x_map_));
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() )
1104 epetraUnscaledOutArgs.set_DgDp(j,l,
convert(DgDp_j_l,g_map_[j],p_map_[l]));
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() )
1115 epetraUnscaledOutArgs.set_DgDp_mp(j,l,
convert(DgDp_mp_j_l,g_map_[j],p_map_[l]));
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 1143 void EpetraModelEvaluator::preEvalScalingSetup(
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;
1164 ( stateFunctionScaling_ == STATE_FUNC_SCALING_ROW_SUM )
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);
1206 void EpetraModelEvaluator::postEvalScalingSetup(
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;
1219 switch(stateFunctionScaling_) {
1221 case STATE_FUNC_SCALING_ROW_SUM: {
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";
1254 stateFunctionScalingVec_ = invRowSums;
1261 TEUCHOS_TEST_FOR_EXCEPT(
"Should never get here!");
1265 epetraOutArgsScaling_ = epetraModel_->createOutArgs();
1267 epetraOutArgsScaling_.set_f(
1268 rcp_const_cast<Epetra_Vector>(stateFunctionScalingVec_) );
1273 void EpetraModelEvaluator::finishConvertingOutArgsFromEpetraToThyra(
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);
1302 void EpetraModelEvaluator::updateNominalValuesAndBounds()
const 1306 using Teuchos::implicit_cast;
1308 typedef EpetraExt::ModelEvaluator EME;
1310 if( !nominalValuesAndBoundsAreUpdated_ ) {
1314 EME::InArgs epetraOrigNominalValues;
1315 EpetraExt::gatherModelNominalValues(
1316 *epetraModel_, &epetraOrigNominalValues );
1318 EME::InArgs epetraOrigLowerBounds;
1319 EME::InArgs epetraOrigUpperBounds;
1320 EpetraExt::gatherModelBounds(
1321 *epetraModel_, &epetraOrigLowerBounds, &epetraOrigUpperBounds );
1325 epetraInArgsScaling_ = epetraModel_->createInArgs();
1327 if( !is_null(stateVariableScalingVec_) ) {
1328 invStateVariableScalingVec_
1329 = EpetraExt::createInverseModelScalingVector(stateVariableScalingVec_);
1330 if( epetraOrigNominalValues.supports(EME::IN_ARG_x_dot) ) {
1331 epetraInArgsScaling_.set_x_dot(invStateVariableScalingVec_);
1333 if( epetraOrigNominalValues.supports(EME::IN_ARG_x) ) {
1334 epetraInArgsScaling_.set_x(invStateVariableScalingVec_);
1340 EME::InArgs epetraScaledNominalValues = epetraModel_->createInArgs();
1341 EpetraExt::scaleModelVars(
1342 epetraOrigNominalValues, epetraInArgsScaling_, &epetraScaledNominalValues
1345 EME::InArgs epetraScaledLowerBounds = epetraModel_->createInArgs();
1346 EME::InArgs epetraScaledUpperBounds = epetraModel_->createInArgs();
1347 EpetraExt::scaleModelBounds(
1348 epetraOrigLowerBounds, epetraOrigUpperBounds, epetraModel_->getInfBound(),
1349 epetraInArgsScaling_,
1350 &epetraScaledLowerBounds, &epetraScaledUpperBounds
1358 convertInArgsFromEpetraToThyra(epetraScaledNominalValues, &nominalValues_);
1359 convertInArgsFromEpetraToThyra(epetraScaledLowerBounds, &lowerBounds_);
1360 convertInArgsFromEpetraToThyra(epetraScaledUpperBounds, &upperBounds_);
1362 nominalValuesAndBoundsAreUpdated_ =
true;
1375 void EpetraModelEvaluator::updateInArgsOutArgs()
const 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 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));
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));
1410 prototypeInArgs_ = inArgs;
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));
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) {
1429 convert(epetraOutArgs.supports(EME::OUT_ARG_DfDp, l)));
1431 outArgs.set_DfDp_properties(l,
1432 convert(epetraOutArgs.get_DfDp_properties(l)));
1436 convert(epetraOutArgs.supports(EME::OUT_ARG_DfDp_mp, l)));
1438 outArgs.set_DfDp_mp_properties(l,
1439 convert(epetraOutArgs.get_DfDp_mp_properties(l)));
1444 for(
int j=0; j<l_Ng; ++j) {
1447 convert(epetraOutArgs.supports(EME::OUT_ARG_DgDx_dot, j)));
1449 outArgs.set_DgDx_dot_properties(j,
1450 convert(epetraOutArgs.get_DgDx_dot_properties(j)));
1453 convert(epetraOutArgs.supports(EME::OUT_ARG_DgDx, j)));
1455 outArgs.set_DgDx_properties(j,
1456 convert(epetraOutArgs.get_DgDx_properties(j)));
1459 convert(epetraOutArgs.supports(EME::OUT_ARG_DgDx_dot_mp, j)));
1461 outArgs.set_DgDx_dot_mp_properties(j,
1462 convert(epetraOutArgs.get_DgDx_dot_mp_properties(j)));
1465 convert(epetraOutArgs.supports(EME::OUT_ARG_DgDx_mp, j)));
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);
1475 convert(epetra_DgDp_j_l_support));
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);
1482 convert(epetra_DgDp_mp_j_l_support));
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 1492 epetraOutArgs.supports(EME::OUT_ARG_f_poly));
1493 #endif // HAVE_THYRA_ME_POLYNOMIAL 1494 prototypeOutArgs_ = outArgs;
1497 currentInArgsOutArgs_ =
true;
1503 EpetraModelEvaluator::create_epetra_W_op()
const 1505 return Thyra::partialNonconstEpetraLinearOp(
1507 create_and_assert_W(*epetraModel_)
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));
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;
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);
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 setNominalValues(const ModelEvaluatorBase::InArgs< double > &nominalValues)
Set the nominal values.
RCP< const EpetraExt::ModelEvaluator > getEpetraModel() const
bool finalPointWasSolved() const
RCP< const VectorSpaceBase< double > > get_g_space(int j) const
void reportFinalPoint(const ModelEvaluatorBase::InArgs< double > &finalPoint, const bool wasSolved)
RCP< LinearOpBase< double > > create_W_op() const
bool supports(EInArgsMembers arg) const
Determines if an input argument is supported or not.
RCP< const VectorSpaceBase< double > > get_x_space() const
RCP< Teuchos::ParameterList > getNonconstParameterList()
EDerivativeMultiVectorOrientation
RCP< const VectorSpaceBase< double > > create_VectorSpace(const RCP< const Epetra_Map > &epetra_map)
Create an VectorSpaceBase object given an Epetra_Map object.
std::string description() const
void setStateVariableScalingVec(const RCP< const Epetra_Vector > &stateVariableScalingVec)
Set the state variable scaling vector s_x (see above).
RCP< const Teuchos::Array< std::string > > get_p_names(int l) const
RCP< const Teuchos::ParameterList > getParameterList() const
const ModelEvaluatorBase::InArgs< double > & getFinalPoint() 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.
RCP< const Epetra_Vector > getStateVariableInvScalingVec() const
Get the state variable scaling vector s_x (see above).
ModelEvaluatorBase::InArgs< double > getNominalValues() const
void setArgs(const InArgs< Scalar > &inArgs, bool ignoreUnsupported=false, bool cloneObjects=false)
Set non-null arguments (does not overwrite non-NULLs with NULLs) .
void setStateFunctionScalingVec(const RCP< const Epetra_Vector > &stateFunctionScalingVec)
Set the state function scaling vector s_f (see above).
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
Simple public strict containing properties of a derivative object.
void setParameterList(RCP< Teuchos::ParameterList > const ¶mList)
Base subclass for ModelEvaluator that defines some basic types.
ModelEvaluatorBase::EDerivativeMultiVectorOrientation convert(const EpetraExt::ModelEvaluator::EDerivativeMultiVectorOrientation &mvOrientation)
void uninitialize(RCP< const EpetraExt::ModelEvaluator > *epetraModel=NULL, RCP< LinearOpWithSolveFactoryBase< double > > *W_factory=NULL)
ModelEvaluatorBase::InArgs< double > getUpperBounds() const
ModelEvaluatorBase()
constructor
Determines the forms of a general derivative that are supported.
RCP< PreconditionerBase< double > > create_W_prec() const
Returns null currently.
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
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