Tempus_WrapperModelEvaluatorPairPartIMEX_Basic_decl.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 Tempus_ModelEvaluatorPairPartIMEX_Basic_decl_hpp
#define Tempus_ModelEvaluatorPairPartIMEX_Basic_decl_hpp
 
#include "Tempus_config.hpp"
#include "Tempus_WrapperModelEvaluatorPairIMEX.hpp"
#include "Thyra_StateFuncModelEvaluatorBase.hpp"
 
namespace Tempus {
 
template <typename Scalar>
class WrapperModelEvaluatorPairPartIMEX_Basic
  : public Tempus::WrapperModelEvaluatorPairIMEX<Scalar> {
 public:
  WrapperModelEvaluatorPairPartIMEX_Basic();
 
  WrapperModelEvaluatorPairPartIMEX_Basic(
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& explicitModel,
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& implicitModel,
      int numExplicitOnlyBlocks = 0, int parameterIndex = -1);
 
  virtual ~WrapperModelEvaluatorPairPartIMEX_Basic() {}
 
  virtual void initialize();
 
 
  virtual void setAppModel(
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& me);
  virtual Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > getAppModel()
      const;
 
  virtual Thyra::ModelEvaluatorBase::InArgs<Scalar> getInArgs()
  {
    return wrapperImplicitInArgs_;
  }
 
  virtual Thyra::ModelEvaluatorBase::OutArgs<Scalar> getOutArgs()
  {
    return wrapperImplicitOutArgs_;
  }
 
  void setForSolve(
      const Teuchos::RCP<Thyra::VectorBase<Scalar> >& x,
      const Teuchos::RCP<Thyra::VectorBase<Scalar> >& xDot, const Scalar time,
      const Teuchos::RCP<ImplicitODEParameters<Scalar> >& p,
      const Teuchos::RCP<Thyra::VectorBase<Scalar> >& y = Teuchos::null,
      const int index                                   = -1 /* index and y are for IMEX_RK_Partition */)
  {
    timeDer_ = p->timeDer_;
 
    typedef Thyra::ModelEvaluatorBase MEB;
    MEB::InArgs<Scalar> inArgs   = this->createInArgs();
    MEB::OutArgs<Scalar> outArgs = this->createOutArgs();
    inArgs.set_x(x);
    if (y != Teuchos::null) inArgs.set_p(index, y);
    if (inArgs.supports(MEB::IN_ARG_x_dot)) inArgs.set_x_dot(xDot);
    if (inArgs.supports(MEB::IN_ARG_t)) inArgs.set_t(time);
    if (inArgs.supports(MEB::IN_ARG_step_size))
      inArgs.set_step_size(p->timeStepSize_);
    if (inArgs.supports(MEB::IN_ARG_alpha)) inArgs.set_alpha(p->alpha_);
    if (inArgs.supports(MEB::IN_ARG_beta)) inArgs.set_beta(p->beta_);
    if (inArgs.supports(MEB::IN_ARG_stage_number))
      inArgs.set_stage_number(p->stageNumber_);
 
    wrapperImplicitInArgs_.setArgs(inArgs);
    wrapperImplicitOutArgs_.setArgs(outArgs);
 
    useImplicitModel_ = true;
  }
 
 
 
 
  virtual Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> > get_x_space()
      const;
 
  virtual Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> > get_g_space(
      int i) const;
 
  virtual Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> > get_p_space(
      int i) const;
 
  virtual void setNumExplicitOnlyBlocks(int numExp)
  {
    numExplicitOnlyBlocks_ = numExp;
  }
  virtual void setExplicitModel(
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& model)
  {
    explicitModel_ = model;
  }
  virtual void setImplicitModel(
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& model);
  virtual Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > getExplicitModel()
      const
  {
    return explicitModel_;
  }
  virtual Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > getImplicitModel()
      const
  {
    return implicitModel_;
  }
  virtual int getNumExplicitOnlyBlocks() const
  {
    return numExplicitOnlyBlocks_;
  }
 
  virtual Teuchos::RCP<Thyra::VectorBase<Scalar> > getIMEXVector(
      const Teuchos::RCP<Thyra::VectorBase<Scalar> >& full) const;
 
  virtual Teuchos::RCP<const Thyra::VectorBase<Scalar> > getIMEXVector(
      const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& full) const;
 
  virtual Teuchos::RCP<Thyra::VectorBase<Scalar> > getExplicitOnlyVector(
      const Teuchos::RCP<Thyra::VectorBase<Scalar> >& full) const;
 
  virtual Teuchos::RCP<const Thyra::VectorBase<Scalar> > getExplicitOnlyVector(
      const Teuchos::RCP<const Thyra::VectorBase<Scalar> >& full) const;
 
  virtual void setParameterIndex(int parameterIndex = -1);
  virtual int getParameterIndex() const { return parameterIndex_; }
 
  virtual void setUseImplicitModel(bool tf) { useImplicitModel_ = tf; }
  virtual bool getUseImplicitModel() const { return useImplicitModel_; }
 
 
  virtual Teuchos::RCP<Thyra::LinearOpBase<Scalar> > create_W_op() const
  {
    return implicitModel_->create_W_op();
  }
 
  Teuchos::RCP<const Thyra::LinearOpWithSolveFactoryBase<Scalar> >
  get_W_factory() const
  {
    return implicitModel_->get_W_factory();
  }
 
  virtual Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> > get_f_space()
      const;
 
  virtual Thyra::ModelEvaluatorBase::InArgs<Scalar> getNominalValues() const;
  virtual Thyra::ModelEvaluatorBase::InArgs<Scalar> createInArgs() const;
  virtual Thyra::ModelEvaluatorBase::OutArgs<Scalar> createOutArgsImpl() const;
 
  virtual void evalModelImpl(
      const Thyra::ModelEvaluatorBase::InArgs<Scalar>& in,
      const Thyra::ModelEvaluatorBase::OutArgs<Scalar>& out) const;
 
 protected:
  void setup(
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& explicitModel,
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& implicitModel,
      int numExplicitOnlyBlocks = 0, int parameterIndex = -1);
 
  Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > explicitModel_;
  Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > implicitModel_;
 
  Teuchos::RCP<TimeDerivative<Scalar> > timeDer_;
  Thyra::ModelEvaluatorBase::InArgs<Scalar> wrapperImplicitInArgs_;
  Thyra::ModelEvaluatorBase::OutArgs<Scalar> wrapperImplicitOutArgs_;
 
  int numExplicitOnlyBlocks_;
  int parameterIndex_;     
  bool useImplicitModel_;  
};
 
}  // namespace Tempus
 
#endif  // Tempus_ModelEvaluatorPairPartIMEX_Basic_decl_hpp