Thyra_ImplicitAdjointModelEvaluator.hpp

Go to the documentation of this file.

// @HEADER
// ****************************************************************************
//                Tempus: Copyright (2017) Sandia Corporation
//
// Distributed under BSD 3-clause license (See accompanying file Copyright.txt)
// ****************************************************************************
// @HEADER
 
#ifndef Thyra_ImplicitAdjointModelEvaluator_hpp
#define Thyra_ImplicitAdjointModelEvaluator_hpp
 
#include "Thyra_ModelEvaluatorDelegatorBase.hpp"
#include "Thyra_DefaultScaledAdjointLinearOp.hpp"
#include "Thyra_DefaultAdjointLinearOpWithSolve.hpp"
#include "Thyra_AdjointLinearOpWithSolveFactory.hpp"
#include "Thyra_AdjointPreconditionerFactory.hpp"
 
namespace Thyra {

template <typename Scalar>
class ImplicitAdjointModelEvaluator :
    public ModelEvaluatorDelegatorBase<Scalar>{
public:

  ImplicitAdjointModelEvaluator(
    const RCP<const ModelEvaluator<Scalar> >& model) :
    ModelEvaluatorDelegatorBase<Scalar>(model) {}

  ImplicitAdjointModelEvaluator(
    const RCP<ModelEvaluator<Scalar> >& model) :
    ModelEvaluatorDelegatorBase<Scalar>(model) {}

  virtual ~ImplicitAdjointModelEvaluator() = default;

  RCP<LinearOpWithSolveBase<Scalar> > create_W() const {
    return nonconstAdjointLows(this->getUnderlyingModel()->create_W());
  }

  RCP<LinearOpBase<Scalar> > create_W_op() const {
    return nonconstAdjoint(this->getUnderlyingModel()->create_W_op());
  }

  RCP<PreconditionerBase<Scalar> > create_W_prec() const {
    return nonconstAdjointPreconditioner(
      this->getUnderlyingModel()->create_W_prec());
  }

  RCP<const LinearOpWithSolveFactoryBase<Scalar> > get_W_factory() const {
    return adjointLinearOpWithSolveFactory(
      this->getUnderlyingModel()->get_W_factory());
  }
 
private:
 
  void evalModelImpl(
    const ModelEvaluatorBase::InArgs<Scalar> &inArgs,
    const ModelEvaluatorBase::OutArgs<Scalar> &outArgs) const
  {
    typedef Thyra::ModelEvaluatorBase MEB;
    MEB::OutArgs<Scalar> model_outArgs =
      this->getUnderlyingModel()->createOutArgs();;
 
    if (model_outArgs.supports(MEB::OUT_ARG_W) &&
        outArgs.get_W() != Teuchos::null) {
      RCP<DefaultAdjointLinearOpWithSolve<Scalar> > adjoint_op =
        Teuchos::rcp_dynamic_cast<DefaultAdjointLinearOpWithSolve<Scalar> >(
          outArgs.get_W(),true);
      model_outArgs.set_W(adjoint_op->getNonconstOp());
    }
 
    if (model_outArgs.supports(MEB::OUT_ARG_W_op) &&
        outArgs.get_W_op() != Teuchos::null) {
      RCP<DefaultScaledAdjointLinearOp<Scalar> > adjoint_op =
        Teuchos::rcp_dynamic_cast<DefaultScaledAdjointLinearOp<Scalar> >(
          outArgs.get_W_op(),true);
      model_outArgs.set_W_op(adjoint_op->getNonconstOp());
    }
 
    if (model_outArgs.supports(MEB::OUT_ARG_W_prec) &&
        outArgs.get_W_prec() != Teuchos::null) {
      RCP<AdjointPreconditioner<Scalar> > adjoint_op =
        Teuchos::rcp_dynamic_cast<AdjointPreconditioner<Scalar> >(
          outArgs.get_W_prec(),true);
      model_outArgs.set_W_prec(adjoint_op->getNonconstPreconditioner());
    }
 
    this->getUnderlyingModel()->evalModel(inArgs, model_outArgs);
  }
 
};
 
template <typename Scalar>
RCP<ImplicitAdjointModelEvaluator<Scalar> > implicitAdjointModelEvaluator(
  const RCP<const ModelEvaluator<Scalar> >& model)
{
  return Teuchos::rcp(new ImplicitAdjointModelEvaluator<Scalar>(model));
}
 
template <typename Scalar>
RCP<ImplicitAdjointModelEvaluator<Scalar> > implicitAdjointModelEvaluator(
  const RCP<ModelEvaluator<Scalar> >& model)
{
  return Teuchos::rcp(new ImplicitAdjointModelEvaluator<Scalar>(model));
}
 
} // namespace Thyra
 
#endif