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