Tempus_StepperBackwardEuler_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_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