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