Thyra_ImplicitAdjointModelEvaluator.hpp

Go to the documentation of this file.

//@HEADER
// *****************************************************************************
//          Tempus: Time Integration and Sensitivity Analysis Package
//
// Copyright 2017 NTESS and the Tempus contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
//@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