Thyra::ModelEvaluatorBase::OutArgs<Scalar>
TimeDiscretizedBackwardEulerModelEvaluator<Scalar>::createOutArgsImpl() const
{
typedef Thyra::ModelEvaluatorBase MEB;
MEB::OutArgs<Scalar> daeOutArgs = daeModel_->createOutArgs();
MEB::OutArgsSetup<Scalar> outArgs;
outArgs.setModelEvalDescription(this->description());
outArgs.setSupports(MEB::OUT_ARG_f);
outArgs.setSupports(MEB::OUT_ARG_W_op);
outArgs.set_W_properties(daeOutArgs.get_W_properties());
return outArgs;
}
ModelEvaluatorBase::OutArgs<Scalar>
DefaultModelEvaluatorWithSolveFactory<Scalar>::createOutArgsImpl() const
{
typedef ModelEvaluatorBase MEB;
const RCP<const ModelEvaluator<Scalar> >
thyraModel = this->getUnderlyingModel();
const MEB::OutArgs<Scalar> wrappedOutArgs = thyraModel->createOutArgs();
MEB::OutArgsSetup<Scalar> outArgs;
outArgs.setModelEvalDescription(this->description());
outArgs.set_Np_Ng(wrappedOutArgs.Np(),wrappedOutArgs.Ng());
outArgs.setSupports(wrappedOutArgs);
outArgs.setSupports(MEB::OUT_ARG_W,
wrappedOutArgs.supports(MEB::OUT_ARG_W_op)&&W_factory_.get()!=NULL);
return outArgs;
}
Thyra::ModelEvaluatorBase::OutArgs<Scalar>
DiagonalROME<Scalar>::createOutArgsImpl() const
{
typedef Thyra::ModelEvaluatorBase MEB;
typedef MEB::DerivativeSupport DS;
MEB::OutArgsSetup<Scalar> outArgs;
outArgs.setModelEvalDescription(this->description());
outArgs.set_Np_Ng(Np_,Ng_);
outArgs.setSupports(MEB::OUT_ARG_DgDp, 0 ,0, MEB::DERIV_TRANS_MV_BY_ROW);
return outArgs;
}
Simple2DModelEvaluator<Scalar>::Simple2DModelEvaluator()
: x_space_(Thyra::defaultSpmdVectorSpace<Scalar>(2)),
f_space_(x_space_),
W_factory_(Thyra::defaultSerialDenseLinearOpWithSolveFactory<Scalar>()),
d_(0.0),
p_(x_space_->dim(), Teuchos::ScalarTraits<Scalar>::zero()),
showGetInvalidArg_(false)
{
using Teuchos::RCP;
using Thyra::VectorBase;
using Thyra::createMember;
typedef Thyra::ModelEvaluatorBase MEB;
typedef Teuchos::ScalarTraits<Scalar> ST;
MEB::InArgsSetup<Scalar> inArgs;
inArgs.setModelEvalDescription(this->description());
inArgs.setSupports(MEB::IN_ARG_x);
prototypeInArgs_ = inArgs;
MEB::OutArgsSetup<Scalar> outArgs;
outArgs.setModelEvalDescription(this->description());
outArgs.setSupports(MEB::OUT_ARG_f);
outArgs.setSupports(MEB::OUT_ARG_W_op);
outArgs.setSupports(MEB::OUT_ARG_W_prec);
prototypeOutArgs_ = outArgs;
nominalValues_ = inArgs;
x0_ = createMember(x_space_);
V_S(x0_.ptr(), ST::zero());
nominalValues_.set_x(x0_);
set_d(10.0);
set_p(Teuchos::tuple<Scalar>(2.0, 0.0)());
set_x0(Teuchos::tuple<Scalar>(1.0, 1.0)());
}
ModelEvaluatorBase::OutArgs<Scalar>
DefaultStateEliminationModelEvaluator<Scalar>::createOutArgsImpl() const
{
typedef ModelEvaluatorBase MEB;
const Teuchos::RCP<const ModelEvaluator<Scalar> >
thyraModel = this->getUnderlyingModel();
const MEB::OutArgs<Scalar> wrappedOutArgs = thyraModel->createOutArgs();
const int Np = wrappedOutArgs.Np(), Ng = wrappedOutArgs.Ng();
MEB::OutArgsSetup<Scalar> outArgs;
outArgs.setModelEvalDescription(this->description());
outArgs.set_Np_Ng(Np,Ng);
outArgs.setSupports(wrappedOutArgs);
outArgs.setUnsupportsAndRelated(MEB::IN_ARG_x); // wipe out DgDx ...
outArgs.setUnsupportsAndRelated(MEB::OUT_ARG_f); // wipe out f, W, DfDp ...
return outArgs;
}
Thyra::ModelEvaluatorBase::OutArgs<Scalar>
ForwardSensitivityExplicitModelEvaluator<Scalar>::createOutArgsImpl() const
{
TEUCHOS_ASSERT( !is_null(stateModel_) );
typedef Thyra::ModelEvaluatorBase MEB;
MEB::OutArgs<Scalar> stateModelOutArgs = stateModel_->createOutArgs();
MEB::OutArgsSetup<Scalar> outArgs;
outArgs.setModelEvalDescription(this->description());
outArgs.setSupports(MEB::OUT_ARG_f);
return outArgs;
}
void DiagonalImplicitRKModelEvaluator<Scalar>::initializeDIRKModel(
const RCP<const Thyra::ModelEvaluator<Scalar> >& daeModel,
const Thyra::ModelEvaluatorBase::InArgs<Scalar>& basePoint,
const RCP<Thyra::LinearOpWithSolveFactoryBase<Scalar> >& dirk_W_factory,
const RCP<const RKButcherTableauBase<Scalar> >& irkButcherTableau
)
{
typedef ScalarTraits<Scalar> ST;
// ToDo: Assert input arguments!
// How do I verify the basePoint is an authentic InArgs from daeModel?
TEUCHOS_TEST_FOR_EXCEPTION(
is_null(basePoint.get_x()),
std::logic_error,
"Error! The basepoint x vector is null!"
);
TEUCHOS_TEST_FOR_EXCEPTION(
is_null(daeModel),
std::logic_error,
"Error! The model evaluator pointer is null!"
);
TEUCHOS_TEST_FOR_EXCEPTION(
!daeModel->get_x_space()->isCompatible(*(basePoint.get_x()->space())),
std::logic_error,
"Error! The basepoint input arguments are incompatible with the model evaluator vector space!"
);
//TEUCHOS_TEST_FOR_EXCEPT(is_null(dirk_W_factory));
daeModel_ = daeModel;
basePoint_ = basePoint;
dirk_W_factory_ = dirk_W_factory;
dirkButcherTableau_ = irkButcherTableau;
const int numStages = dirkButcherTableau_->numStages();
using Teuchos::rcp_dynamic_cast;
stage_space_ = productVectorSpace(daeModel_->get_x_space(),numStages);
RCP<const Thyra::VectorSpaceBase<Scalar> > vs = rcp_dynamic_cast<const Thyra::VectorSpaceBase<Scalar> >(stage_space_,true);
stage_derivatives_ = rcp_dynamic_cast<Thyra::ProductVectorBase<Scalar> >(createMember(vs),true);
Thyra::V_S( rcp_dynamic_cast<Thyra::VectorBase<Scalar> >(stage_derivatives_).ptr(),ST::zero());
// Set up prototypical InArgs
{
typedef Thyra::ModelEvaluatorBase MEB;
MEB::InArgsSetup<Scalar> inArgs;
inArgs.setModelEvalDescription(this->description());
inArgs.setSupports(MEB::IN_ARG_x);
inArgs_ = inArgs;
}
// Set up prototypical OutArgs
{
typedef Thyra::ModelEvaluatorBase MEB;
MEB::OutArgsSetup<Scalar> outArgs;
outArgs.setModelEvalDescription(this->description());
outArgs.setSupports(MEB::OUT_ARG_f);
outArgs.setSupports(MEB::OUT_ARG_W_op);
outArgs_ = outArgs;
}
// Set up nominal values
nominalValues_ = inArgs_;
isInitialized_ = true;
}
void ImplicitRKModelEvaluator<Scalar>::initializeIRKModel(
const RCP<const Thyra::ModelEvaluator<Scalar> >& daeModel,
const Thyra::ModelEvaluatorBase::InArgs<Scalar>& basePoint,
const RCP<Thyra::LinearOpWithSolveFactoryBase<Scalar> >& irk_W_factory,
const RCP<const RKButcherTableauBase<Scalar> >& irkButcherTableau
)
{
// ToDo: Assert input arguments!
// How do I verify the basePoint is an authentic InArgs from daeModel?
TEST_FOR_EXCEPTION(
is_null(basePoint.get_x()),
std::logic_error,
"Error! The basepoint x vector is null!"
);
TEST_FOR_EXCEPTION(
is_null(daeModel),
std::logic_error,
"Error! The model evaluator pointer is null!"
);
TEST_FOR_EXCEPTION(
!daeModel->get_x_space()->isCompatible(*(basePoint.get_x()->space())),
std::logic_error,
"Error! The basepoint input arguments are incompatible with the model evaluator vector space!"
);
TEST_FOR_EXCEPT(is_null(irk_W_factory));
daeModel_ = daeModel;
basePoint_ = basePoint;
irk_W_factory_ = irk_W_factory;
irkButcherTableau_ = irkButcherTableau;
const int numStages = irkButcherTableau_->numStages();
x_bar_space_ = productVectorSpace(daeModel_->get_x_space(),numStages);
f_bar_space_ = productVectorSpace(daeModel_->get_f_space(),numStages);
// HACK! Remove the preconditioner factory for now!
if (irk_W_factory_->acceptsPreconditionerFactory())
irk_W_factory_->unsetPreconditionerFactory();
// ToDo: create the block diagonal preconditioner factory and set this on
// irk_W_factory_!
// Set up prototypical InArgs
{
typedef Thyra::ModelEvaluatorBase MEB;
MEB::InArgsSetup<Scalar> inArgs;
inArgs.setModelEvalDescription(this->description());
inArgs.setSupports(MEB::IN_ARG_x);
inArgs_ = inArgs;
}
// Set up prototypical OutArgs
{
typedef Thyra::ModelEvaluatorBase MEB;
MEB::OutArgsSetup<Scalar> outArgs;
outArgs.setModelEvalDescription(this->description());
outArgs.setSupports(MEB::OUT_ARG_f);
outArgs.setSupports(MEB::OUT_ARG_W_op);
outArgs_ = outArgs;
}
// Set up nominal values
nominalValues_ = inArgs_;
isInitialized_ = true;
}
void ModelEvaluatorDefaultBase<Scalar>::initializeDefaultBase()
{
typedef ModelEvaluatorBase MEB;
// In case we throw half way thorugh, set to uninitialized
isInitialized_ = false;
default_W_support_ = false;
//
// A) Get the InArgs and OutArgs from the subclass
//
const MEB::InArgs<Scalar> inArgs = this->createInArgs();
const MEB::OutArgs<Scalar> outArgsImpl = this->createOutArgsImpl();
//
// B) Validate the subclasses InArgs and OutArgs
//
#ifdef TEUCHOS_DEBUG
assertInArgsOutArgsSetup( this->description(), inArgs, outArgsImpl );
#endif // TEUCHOS_DEBUG
//
// C) Set up support for default derivative objects and prototype OutArgs
//
const int l_Ng = outArgsImpl.Ng();
const int l_Np = outArgsImpl.Np();
// Set support for all outputs supported in the underly implementation
MEB::OutArgsSetup<Scalar> outArgs;
outArgs.setModelEvalDescription(this->description());
outArgs.set_Np_Ng(l_Np,l_Ng);
outArgs.setSupports(outArgsImpl);
// DfDp
DfDp_default_op_support_.clear();
if (outArgs.supports(MEB::OUT_ARG_f)) {
for ( int l = 0; l < l_Np; ++l ) {
const MEB::DerivativeSupport DfDp_l_impl_support =
outArgsImpl.supports(MEB::OUT_ARG_DfDp,l);
const DefaultDerivLinearOpSupport DfDp_l_op_support =
determineDefaultDerivLinearOpSupport(DfDp_l_impl_support);
DfDp_default_op_support_.push_back(DfDp_l_op_support);
outArgs.setSupports(
MEB::OUT_ARG_DfDp, l,
updateDefaultLinearOpSupport(
DfDp_l_impl_support, DfDp_l_op_support
)
);
}
}
// DgDx_dot
DgDx_dot_default_op_support_.clear();
for ( int j = 0; j < l_Ng; ++j ) {
const MEB::DerivativeSupport DgDx_dot_j_impl_support =
outArgsImpl.supports(MEB::OUT_ARG_DgDx_dot,j);
const DefaultDerivLinearOpSupport DgDx_dot_j_op_support =
determineDefaultDerivLinearOpSupport(DgDx_dot_j_impl_support);
DgDx_dot_default_op_support_.push_back(DgDx_dot_j_op_support);
outArgs.setSupports(
MEB::OUT_ARG_DgDx_dot, j,
updateDefaultLinearOpSupport(
DgDx_dot_j_impl_support, DgDx_dot_j_op_support
)
);
}
// DgDx
DgDx_default_op_support_.clear();
for ( int j = 0; j < l_Ng; ++j ) {
const MEB::DerivativeSupport DgDx_j_impl_support =
outArgsImpl.supports(MEB::OUT_ARG_DgDx,j);
const DefaultDerivLinearOpSupport DgDx_j_op_support =
determineDefaultDerivLinearOpSupport(DgDx_j_impl_support);
DgDx_default_op_support_.push_back(DgDx_j_op_support);
outArgs.setSupports(
MEB::OUT_ARG_DgDx, j,
updateDefaultLinearOpSupport(
DgDx_j_impl_support, DgDx_j_op_support
)
);
}
// DgDp
DgDp_default_op_support_.clear();
DgDp_default_mv_support_.clear();
for ( int j = 0; j < l_Ng; ++j ) {
DgDp_default_op_support_.push_back(Array<DefaultDerivLinearOpSupport>());
DgDp_default_mv_support_.push_back(Array<DefaultDerivMvAdjointSupport>());
for ( int l = 0; l < l_Np; ++l ) {
const MEB::DerivativeSupport DgDp_j_l_impl_support =
outArgsImpl.supports(MEB::OUT_ARG_DgDp,j,l);
// LinearOpBase support
const DefaultDerivLinearOpSupport DgDp_j_l_op_support =
determineDefaultDerivLinearOpSupport(DgDp_j_l_impl_support);
DgDp_default_op_support_[j].push_back(DgDp_j_l_op_support);
outArgs.setSupports(
MEB::OUT_ARG_DgDp, j, l,
updateDefaultLinearOpSupport(
DgDp_j_l_impl_support, DgDp_j_l_op_support
)
);
// MultiVectorBase
const DefaultDerivMvAdjointSupport DgDp_j_l_mv_support =
determineDefaultDerivMvAdjointSupport(
DgDp_j_l_impl_support, *this->get_g_space(j), *this->get_p_space(l)
);
DgDp_default_mv_support_[j].push_back(DgDp_j_l_mv_support);
outArgs.setSupports(
MEB::OUT_ARG_DgDp, j, l,
updateDefaultDerivMvAdjointSupport(
outArgs.supports(MEB::OUT_ARG_DgDp, j, l),
DgDp_j_l_mv_support
)
);
}
}
// 2007/09/09: rabart: ToDo: Move the above code into a private helper
// function!
// W (given W_op and W_factory)
default_W_support_ = false;
if ( outArgsImpl.supports(MEB::OUT_ARG_W_op) && !is_null(this->get_W_factory())
&& !outArgsImpl.supports(MEB::OUT_ARG_W) )
{
default_W_support_ = true;
outArgs.setSupports(MEB::OUT_ARG_W);
outArgs.set_W_properties(outArgsImpl.get_W_properties());
}
//
// D) All done!
//
prototypeOutArgs_ = outArgs;
isInitialized_ = true;
}