Tempus_StepperImplicit_decl.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 Tempus_StepperImplicit_decl_hpp
#define Tempus_StepperImplicit_decl_hpp

// Tempus
#include "Tempus_config.hpp"
#include "Tempus_Stepper.hpp"
#include "Tempus_WrapperModelEvaluatorBasic.hpp"


namespace Tempus {


template<class Scalar>
class ImplicitODEParameters
{
  public:
    ImplicitODEParameters()
      : timeDer_(Teuchos::null), timeStepSize_(Scalar(0.0)),
        alpha_(Scalar(0.0)), beta_(Scalar(0.0)), evaluationType_(SOLVE_FOR_X),
        stageNumber_(0)
    {}
    ImplicitODEParameters(Teuchos::RCP<TimeDerivative<Scalar> > timeDer,
                          Scalar timeStepSize, Scalar alpha, Scalar beta,
                          EVALUATION_TYPE evaluationType = SOLVE_FOR_X,
                          int stageNumber = 0)
      : timeDer_(timeDer), timeStepSize_(timeStepSize),
        alpha_(alpha), beta_(beta), evaluationType_(evaluationType),
        stageNumber_(stageNumber)
    {}

    Teuchos::RCP<TimeDerivative<Scalar> > timeDer_;
    Scalar                                timeStepSize_;
    Scalar                                alpha_;
    Scalar                                beta_;
    EVALUATION_TYPE                       evaluationType_;
    int                                   stageNumber_;
};

template<class Scalar>
class StepperImplicit : virtual public Tempus::Stepper<Scalar>
{
public:


    virtual void setModel(
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& appModel);

    virtual Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > getModel()
    {
      Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > model;
      if (wrapperModel_ != Teuchos::null) model = wrapperModel_->getAppModel();
      return model;
    }

    virtual Teuchos::RCP<const WrapperModelEvaluator<Scalar> >
      getWrapperModel(){return wrapperModel_;}

    virtual void setDefaultSolver();

    virtual void setSolver(
      Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> > solver);

    virtual Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> > getSolver() const
      { return solver_; }

    virtual void setInitialConditions (
      const Teuchos::RCP<SolutionHistory<Scalar> >& solutionHistory);

    virtual Scalar getAlpha(const Scalar dt) const = 0;

    virtual Scalar getBeta (const Scalar dt) const = 0;

    const Thyra::SolveStatus<Scalar> solveImplicitODE(
      const Teuchos::RCP<Thyra::VectorBase<Scalar> > & x);

    const Thyra::SolveStatus<Scalar> solveImplicitODE(
      const Teuchos::RCP<Thyra::VectorBase<Scalar> > & x,
      const Teuchos::RCP<Thyra::VectorBase<Scalar> > & xDot,
      const Scalar time,
      const Teuchos::RCP<ImplicitODEParameters<Scalar> > & p );

    void evaluateImplicitODE(
            Teuchos::RCP<Thyra::VectorBase<Scalar> > & f,
      const Teuchos::RCP<Thyra::VectorBase<Scalar> > & x,
      const Teuchos::RCP<Thyra::VectorBase<Scalar> > & xDot,
      const Scalar time,
      const Teuchos::RCP<ImplicitODEParameters<Scalar> > & p );

    virtual void setInitialGuess(
      Teuchos::RCP<const Thyra::VectorBase<Scalar> > initialGuess)
    {
      initialGuess_ = initialGuess;
      this->isInitialized_ = false;
    }

    virtual void setZeroInitialGuess(bool zIG) {
      zeroInitialGuess_ = zIG;
      this->isInitialized_ = false;
    }

    virtual bool getZeroInitialGuess() const { return zeroInitialGuess_; }

    virtual Scalar getInitTimeStep(
      const Teuchos::RCP<SolutionHistory<Scalar> >& /* solutionHistory */) const
    {return Scalar(1.0e+99);}


    virtual void describe(Teuchos::FancyOStream        & out,
                          const Teuchos::EVerbosityLevel verbLevel) const;

  virtual bool isValidSetup(Teuchos::FancyOStream & out) const;

  virtual Teuchos::RCP<const Teuchos::ParameterList> getValidParameters() const;

  Teuchos::RCP<Teuchos::ParameterList> getValidParametersBasicImplicit() const;

  void setStepperImplicitValues(Teuchos::RCP<Teuchos::ParameterList> pl);

  void setStepperSolverValues(Teuchos::RCP<Teuchos::ParameterList> pl);

  void setSolverName(std::string i) { solverName_ = i; }
  std::string getSolverName() const { return solverName_; }

protected:

  Teuchos::RCP<WrapperModelEvaluator<Scalar> >        wrapperModel_;
  Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> >   solver_;
  Teuchos::RCP<const Thyra::VectorBase<Scalar> >      initialGuess_;
  bool zeroInitialGuess_;
  std::string solverName_;

};

} // namespace Tempus
#endif // Tempus_StepperImplicit_decl_hpp