Thyra_ScaledIdentityLinearOpWithSolveFactory.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_ScaledIdentityLinearOpWithSolveFactory_hpp
#define Thyra_ScaledIdentityLinearOpWithSolveFactory_hpp

#include "Thyra_LinearOpWithSolveFactoryBase.hpp"
#include "Thyra_MultiVectorLinearOp.hpp"
#include "Thyra_MultiVectorPreconditioner.hpp"
#include "Thyra_MultiVectorPreconditionerFactory.hpp"
#include "Thyra_ScaledIdentityLinearOpWithSolve.hpp"
#include "Thyra_DefaultLinearOpSource.hpp"

namespace Thyra {

template<class Scalar>
class ScaledIdentityLinearOpWithSolveFactory
  : virtual public LinearOpWithSolveFactoryBase<Scalar>
{
public:


  ScaledIdentityLinearOpWithSolveFactory() {}


  void initialize(const RCP<const VectorSpaceBase<Scalar> >& space,
                  const Scalar& s)
  {
    space_ = space;
    s_ = s;
  }



  void setParameterList(RCP<ParameterList> const& /* paramList */) {}
  RCP<ParameterList> getNonconstParameterList() { return Teuchos::parameterList(); }
  RCP<ParameterList> unsetParameterList() { return Teuchos::parameterList(); }
  RCP<const ParameterList> getParameterList() const { return Teuchos::parameterList(); }
  RCP<const ParameterList> getValidParameters() const { return Teuchos::parameterList(); }



  virtual bool acceptsPreconditionerFactory() const { return false; }

  virtual void setPreconditionerFactory(
    const RCP<PreconditionerFactoryBase<Scalar> > &/* precFactory */,
    const std::string &/* precFactoryName */
    ) {}

  virtual RCP<PreconditionerFactoryBase<Scalar> >
  getPreconditionerFactory() const { return Teuchos::null; }

  virtual void unsetPreconditionerFactory(
    RCP<PreconditionerFactoryBase<Scalar> > * /* precFactory */,
    std::string * /* precFactoryName */
    ) {}

  virtual bool isCompatible(
    const LinearOpSourceBase<Scalar> &fwdOpSrc
    ) const
  {
    return !is_null(
      Teuchos::rcp_dynamic_cast<const ScaledIdentityLinearOpWithSolve<Scalar> >(fwdOpSrc.getOp()));
  }

  virtual RCP<LinearOpWithSolveBase<Scalar> > createOp() const
  { return scaledIdentity(space_, s_); }

  virtual void initializeOp(
    const RCP<const LinearOpSourceBase<Scalar> > &fwdOpSrc,
    LinearOpWithSolveBase<Scalar> *Op,
    const ESupportSolveUse supportSolveUse
    ) const;

  virtual void initializeAndReuseOp(
    const RCP<const LinearOpSourceBase<Scalar> > &fwdOpSrc,
    LinearOpWithSolveBase<Scalar> *Op
    ) const
    {
      initializeOp(fwdOpSrc, Op, SUPPORT_SOLVE_UNSPECIFIED);
    }

  virtual void uninitializeOp(
    LinearOpWithSolveBase<Scalar> *Op,
    RCP<const LinearOpSourceBase<Scalar> > *fwdOpSrc,
    RCP<const PreconditionerBase<Scalar> > *prec,
    RCP<const LinearOpSourceBase<Scalar> > *approxFwdOpSrc,
    ESupportSolveUse *supportSolveUse
    ) const;

  virtual bool supportsPreconditionerInputType(
    const EPreconditionerInputType /* precOpType */
    ) const { return false; }

  virtual void initializePreconditionedOp(
    const RCP<const LinearOpSourceBase<Scalar> > &/* fwdOpSrc */,
    const RCP<const PreconditionerBase<Scalar> > &/* prec */,
    LinearOpWithSolveBase<Scalar> * /* Op */,
    const ESupportSolveUse /* supportSolveUse */
    ) const {}

  virtual void initializeApproxPreconditionedOp(
    const RCP<const LinearOpSourceBase<Scalar> > &/* fwdOpSrc */,
    const RCP<const LinearOpSourceBase<Scalar> > &/* approxFwdOpSrc */,
    LinearOpWithSolveBase<Scalar> * /* Op */,
    const ESupportSolveUse /* supportSolveUse */
    ) const {}


protected:


  void informUpdatedVerbosityState() const {}


private:

  RCP<const VectorSpaceBase<Scalar> > space_;
  Scalar s_;

};

template<class Scalar>
RCP<ScaledIdentityLinearOpWithSolveFactory<Scalar> >
scaledIdentitySolveFactory(
  const RCP<const VectorSpaceBase<Scalar> >& space,
  const Scalar& s)
{
  RCP<ScaledIdentityLinearOpWithSolveFactory<Scalar> > lowsf =
    Teuchos::rcp(new ScaledIdentityLinearOpWithSolveFactory<Scalar>);
  lowsf->initialize(space,s);
  return lowsf;
}

// Overridden from LinearOpWithSolveFactoyBase

template<class Scalar>
void
ScaledIdentityLinearOpWithSolveFactory<Scalar>::
initializeOp(
  const RCP<const LinearOpSourceBase<Scalar> > &fwdOpSrc,
  LinearOpWithSolveBase<Scalar> *Op,
  const ESupportSolveUse /* supportSolveUse */
  ) const
{
  using Teuchos::dyn_cast;
  using Teuchos::rcp_dynamic_cast;

#ifdef TEUCHOS_DEBUG
  TEUCHOS_TEST_FOR_EXCEPT(0==Op);
#endif

  const RCP<const LinearOpBase<Scalar> > tmpFwdOp = fwdOpSrc->getOp();
  RCP<const LinearOpBase<Scalar> > fwdOp;
  Scalar fwdOp_scalar = 0.0;
  EOpTransp fwdOp_transp;
  unwrap<Scalar>(tmpFwdOp, &fwdOp_scalar, &fwdOp_transp, &fwdOp);

  const RCP<const ScaledIdentityLinearOpWithSolve<Scalar> > fwdSi =
    rcp_dynamic_cast<const ScaledIdentityLinearOpWithSolve<Scalar> >(fwdOp, true);

  dyn_cast<ScaledIdentityLinearOpWithSolve<Scalar> >(*Op).initialize(
    fwdSi->space(), fwdSi->scale());
}

template<class Scalar>
void
ScaledIdentityLinearOpWithSolveFactory<Scalar>::
uninitializeOp(
  LinearOpWithSolveBase<Scalar> * Op,
  RCP<const LinearOpSourceBase<Scalar> > *fwdOpSrc,
  RCP<const PreconditionerBase<Scalar> > *prec,
  RCP<const LinearOpSourceBase<Scalar> > *approxFwdOpSrc,
  ESupportSolveUse * /* supportSolveUse */
  ) const
{
  using Teuchos::dyn_cast;
  using Teuchos::is_null;
#ifdef TEUCHOS_DEBUG
  TEUCHOS_TEST_FOR_EXCEPT(0==Op);
#else
  (void)Op;
#endif // TEUCHOS_DEBUG
  if (fwdOpSrc) *fwdOpSrc = Teuchos::null;
  if (prec) *prec = Teuchos::null;
  if (approxFwdOpSrc) *approxFwdOpSrc = Teuchos::null;
}



} // namespace Thyra

#endif