Thyra_AdjointPreconditioner.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_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