Tempus_StepperBackwardEuler_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_StepperBackwardEuler_decl_hpp
#define Tempus_StepperBackwardEuler_decl_hpp

#include "Tempus_config.hpp"
#include "Tempus_StepperImplicit.hpp"
#include "Tempus_WrapperModelEvaluator.hpp"
#include "Tempus_StepperBackwardEulerAppAction.hpp"
#include "Tempus_StepperOptimizationInterface.hpp"

namespace Tempus {

template <class Scalar>
class StepperBackwardEuler
  : virtual public Tempus::StepperImplicit<Scalar>,
    virtual public Tempus::StepperOptimizationInterface<Scalar> {
 public:
  StepperBackwardEuler();

  StepperBackwardEuler(
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& appModel,
      const Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> >& solver,
      const Teuchos::RCP<Stepper<Scalar> >& predictorStepper, bool useFSAL,
      std::string ICConsistency, bool ICConsistencyCheck, bool zeroInitialGuess,
      const Teuchos::RCP<StepperBackwardEulerAppAction<Scalar> >&
          stepperBEAppAction);


  virtual void setAppAction(
      Teuchos::RCP<StepperBackwardEulerAppAction<Scalar> > appAction);

  virtual Teuchos::RCP<StepperBackwardEulerAppAction<Scalar> > getAppAction()
      const
  {
    return stepperBEAppAction_;
  }

  void setPredictor(std::string predictorType = "None");
  void setPredictor(Teuchos::RCP<Stepper<Scalar> > predictorStepper);

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

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

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

  virtual Teuchos::RCP<Tempus::StepperState<Scalar> > getDefaultStepperState()
      override;
  virtual Scalar getOrder() const override { return 1.0; }
  virtual Scalar getOrderMin() const override { return 1.0; }
  virtual Scalar getOrderMax() const override { return 1.0; }

  virtual bool isExplicit() const override { return false; }
  virtual bool isImplicit() const override { return true; }
  virtual bool isExplicitImplicit() const override
  {
    return isExplicit() && isImplicit();
  }
  virtual bool isOneStepMethod() const override { return true; }
  virtual bool isMultiStepMethod() const override { return !isOneStepMethod(); }
  virtual OrderODE getOrderODE() const override { return FIRST_ORDER_ODE; }

  virtual Scalar getAlpha(const Scalar dt) const override
  {
    return Scalar(1.0) / dt;
  }
  virtual Scalar getBeta(const Scalar) const override { return Scalar(1.0); }

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

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


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

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


  virtual int stencilLength() const override;
  virtual void computeStepResidual(
      Thyra::VectorBase<Scalar>& residual,
      const Teuchos::Array<Teuchos::RCP<const Thyra::VectorBase<Scalar> > >& x,
      const Teuchos::Array<Scalar>& t, const Thyra::VectorBase<Scalar>& p,
      const int param_index) const override;
  virtual void computeStepJacobian(
      Thyra::LinearOpBase<Scalar>& jacobian,
      const Teuchos::Array<Teuchos::RCP<const Thyra::VectorBase<Scalar> > >& x,
      const Teuchos::Array<Scalar>& t, const Thyra::VectorBase<Scalar>& p,
      const int param_index, const int deriv_index) const override;
  virtual void computeStepParamDeriv(
      Thyra::LinearOpBase<Scalar>& deriv,
      const Teuchos::Array<Teuchos::RCP<const Thyra::VectorBase<Scalar> > >& x,
      const Teuchos::Array<Scalar>& t, const Thyra::VectorBase<Scalar>& p,
      const int param_index) const override;
  virtual void computeStepSolver(
      Thyra::LinearOpWithSolveBase<Scalar>& jacobian_solver,
      const Teuchos::Array<Teuchos::RCP<const Thyra::VectorBase<Scalar> > >& x,
      const Teuchos::Array<Scalar>& t, const Thyra::VectorBase<Scalar>& p,
      const int param_index) const override;

 private:
  void computeStepResidDerivImpl(
      const Thyra::ModelEvaluatorBase::OutArgs<Scalar>& outArgs,
      const Teuchos::Array<Teuchos::RCP<const Thyra::VectorBase<Scalar> > >& x,
      const Teuchos::Array<Scalar>& t, const Thyra::VectorBase<Scalar>& p,
      const int param_index, const int deriv_index = 0) const;

 private:
  Teuchos::RCP<Stepper<Scalar> > predictorStepper_;
  Teuchos::RCP<StepperBackwardEulerAppAction<Scalar> > stepperBEAppAction_;
};

template <typename Scalar>
class StepperBackwardEulerTimeDerivative
  : virtual public Tempus::TimeDerivative<Scalar> {
 public:
  StepperBackwardEulerTimeDerivative(
      Scalar s, Teuchos::RCP<const Thyra::VectorBase<Scalar> > xOld)
  {
    initialize(s, xOld);
  }

  virtual ~StepperBackwardEulerTimeDerivative() {}

  virtual void compute(
      Teuchos::RCP<const Thyra::VectorBase<Scalar> > x,
      Teuchos::RCP<Thyra::VectorBase<Scalar> > xDot,
      Teuchos::RCP<Thyra::VectorBase<Scalar> > xDotDot = Teuchos::null)
  {
    xDotDot = Teuchos::null;
    // Calculate the Backward Euler x dot vector
    Thyra::V_StVpStV(xDot.ptr(), s_, *x, -s_, *xOld_);
  }

  virtual void initialize(Scalar s,
                          Teuchos::RCP<const Thyra::VectorBase<Scalar> > xOld)
  {
    s_    = s;
    xOld_ = xOld;
  }

 private:
  Teuchos::RCP<const Thyra::VectorBase<Scalar> > xOld_;
  Scalar s_;  // = 1.0/dt
};

// ------------------------------------------------------------------------
template <class Scalar>
Teuchos::RCP<StepperBackwardEuler<Scalar> > createStepperBackwardEuler(
    const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& model,
    Teuchos::RCP<Teuchos::ParameterList> pl);

}  // namespace Tempus

#endif  // Tempus_StepperBackwardEuler_decl_hpp