Thyra_AdjointPreconditioner.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_AdjointPreconditioner_hpp
#define Thyra_AdjointPreconditioner_hpp

#include "Thyra_PreconditionerBase.hpp"
#include "Teuchos_ConstNonconstObjectContainer.hpp"
#include "Thyra_DefaultScaledAdjointLinearOp.hpp"

namespace Thyra {

template <class Scalar>
class AdjointPreconditioner : virtual public PreconditionerBase<Scalar> {
 public:

  AdjointPreconditioner() {}

  void nonconstInitialize(const RCP<PreconditionerBase<Scalar> > &prec)
  {
    validateInitialize(prec);
    prec_ = prec;
  }

  void initialize(const RCP<const PreconditionerBase<Scalar> > &prec)
  {
    validateInitialize(prec);
    prec_ = prec;
  }

  RCP<PreconditionerBase<Scalar> > getNonconstPreconditioner()
  {
    return prec_.getNonconstObj();
  }

  RCP<const PreconditionerBase<Scalar> > getPreconditioner() const
  {
    return prec_.getConstObj();
  }

  void uninitialize() { prec_.uninitialize(); }



  bool isLeftPrecOpConst() const
  {
    return prec_.getConstObj()->isLeftPrecOpConst();
  }

  Teuchos::RCP<LinearOpBase<Scalar> > getNonconstLeftPrecOp()
  {
    return nonconstAdjoint(prec_.getNonconstObj()->getNonconstLeftPrecOp());
  }

  Teuchos::RCP<const LinearOpBase<Scalar> > getLeftPrecOp() const
  {
    return adjoint(prec_.getConstObj()->getLeftPrecOp());
  }

  bool isRightPrecOpConst() const
  {
    return prec_.getConstObj()->isRightPrecOpConst();
  }

  Teuchos::RCP<LinearOpBase<Scalar> > getNonconstRightPrecOp()
  {
    return nonconstAdjoint(prec_.getNonconstObj()->getNonconstRightPrecOp());
  }

  Teuchos::RCP<const LinearOpBase<Scalar> > getRightPrecOp() const
  {
    return adjoint(prec_.getConstObj()->getRightPrecOp());
  }

  bool isUnspecifiedPrecOpConst() const
  {
    return prec_.getConstObj()->isUnspecifiedPrecOpConst();
  }

  Teuchos::RCP<LinearOpBase<Scalar> > getNonconstUnspecifiedPrecOp()
  {
    return nonconstAdjoint(
        prec_.getNonconstObj()->getNonconstUnspecifiedPrecOp());
  }

  Teuchos::RCP<const LinearOpBase<Scalar> > getUnspecifiedPrecOp() const
  {
    return adjoint(prec_.getNonconstObj()->getUnspecifiedPrecOp());
  }


 private:
  // //////////////////////////////
  // Private types

  typedef Teuchos::ConstNonconstObjectContainer<PreconditionerBase<Scalar> >
      CNPB;

  // //////////////////////////////
  // Private data members

  CNPB prec_;

  // //////////////////////////////
  // Private member functions

  static void validateInitialize(
      const RCP<const PreconditionerBase<Scalar> > &prec)
  {
#ifdef TEUCHOS_DEBUG
    TEUCHOS_TEST_FOR_EXCEPT(is_null(prec));
#else
    (void)prec;
#endif
  }
};

template <class Scalar>
RCP<AdjointPreconditioner<Scalar> > adjointPreconditioner()
{
  return Teuchos::rcp(new AdjointPreconditioner<Scalar>());
}

template <class Scalar>
RCP<AdjointPreconditioner<Scalar> > nonconstAdjointPreconditioner(
    const RCP<PreconditionerBase<Scalar> > &prec)
{
  RCP<AdjointPreconditioner<Scalar> > aprec =
      Teuchos::rcp(new AdjointPreconditioner<Scalar>());
  aprec->nonconstInitialize(prec);
  return aprec;
}

template <class Scalar>
RCP<AdjointPreconditioner<Scalar> > adjointPreconditioner(
    const RCP<const PreconditionerBase<Scalar> > &prec)
{
  RCP<AdjointPreconditioner<Scalar> > aprec =
      Teuchos::rcp(new AdjointPreconditioner<Scalar>());
  aprec->initialize(prec);
  return aprec;
}

}  // end namespace Thyra

#endif