Tempus_Stepper_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_Stepper_decl_hpp
#define Tempus_Stepper_decl_hpp
 
#include "Teuchos_TimeMonitor.hpp"
 
#include "Thyra_ModelEvaluator.hpp"
#include "Thyra_NonlinearSolverBase.hpp"
 
#include "Tempus_config.hpp"
#include "Tempus_SolutionHistory.hpp"
 
namespace Tempus {
 
enum OrderODE {
  FIRST_ORDER_ODE  = 1,  
  SECOND_ORDER_ODE = 2,  
};
 
template <class Scalar>
class Stepper : virtual public Teuchos::Describable,
                virtual public Teuchos::VerboseObject<Stepper<Scalar> > {
 public:
 
  virtual void setModel(
      const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& appModel)
  {
  }
 
  virtual Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > getModel() const
  {
    return Teuchos::null;
  }
 
  virtual void setSolver(
      Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> > solver)
  {
  }
 
  virtual Teuchos::RCP<Thyra::NonlinearSolverBase<Scalar> > getSolver() const
  {
    return Teuchos::null;
  }
 
  virtual void initialize();
 
  virtual bool isInitialized() { return isInitialized_; }
 
  virtual void checkInitialized();
 
  virtual void setInitialConditions(
      const Teuchos::RCP<SolutionHistory<Scalar> >& solutionHistory) = 0;
 
  virtual void takeStep(
      const Teuchos::RCP<SolutionHistory<Scalar> >& solutionHistory) = 0;
 
  virtual void setInitialGuess(Teuchos::RCP<const Thyra::VectorBase<Scalar> >
                                   initialGuess = Teuchos::null) = 0;
 
  virtual Teuchos::RCP<Tempus::StepperState<Scalar> >
  getDefaultStepperState()           = 0;
  virtual Scalar getOrder() const    = 0;
  virtual Scalar getOrderMin() const = 0;
  virtual Scalar getOrderMax() const = 0;
  virtual Scalar getInitTimeStep(
      const Teuchos::RCP<SolutionHistory<Scalar> >& solutionHistory) const = 0;
 
  virtual bool isExplicit() const         = 0;
  virtual bool isImplicit() const         = 0;
  virtual bool isExplicitImplicit() const = 0;
 
  virtual bool isOneStepMethod() const   = 0;
  virtual bool isMultiStepMethod() const = 0;
 
  void setStepperName(std::string s)
  {
    stepperName_   = s;
    isInitialized_ = false;
  }
 
  std::string getStepperName() const { return stepperName_; }
 
 protected:
  void setStepperType(std::string s)
  {
    stepperType_   = s;
    isInitialized_ = false;
  }
 
 public:
  std::string getStepperType() const { return stepperType_; }
 
  virtual void setUseFSAL(bool a) { setUseFSALFalseOnly(a); }
  void setUseFSALTrueOnly(bool a);
  void setUseFSALFalseOnly(bool a);
  bool getUseFSAL() const { return useFSAL_; }
 
  void setICConsistency(std::string s)
  {
    ICConsistency_ = s;
    isInitialized_ = false;
  }
  std::string getICConsistency() const { return ICConsistency_; }
 
  void setICConsistencyCheck(bool c)
  {
    ICConsistencyCheck_ = c;
    isInitialized_      = false;
  }
  bool getICConsistencyCheck() const { return ICConsistencyCheck_; }
 
  virtual OrderODE getOrderODE() const = 0;
 
  virtual Teuchos::RCP<Thyra::VectorBase<Scalar> > getStepperX();
 
  virtual Teuchos::RCP<Thyra::VectorBase<Scalar> > getStepperXDot();
 
  virtual Teuchos::RCP<Thyra::VectorBase<Scalar> > getStepperXDotDot();
 
  virtual Teuchos::RCP<Thyra::VectorBase<Scalar> > getStepperXDotDot(
      Teuchos::RCP<SolutionState<Scalar> > state);
 
 
  virtual std::string description() const { return stepperType_; }
 
 
  virtual void describe(Teuchos::FancyOStream& out,
                        const Teuchos::EVerbosityLevel verbLevel) const;
 
  virtual bool isValidSetup(Teuchos::FancyOStream& out) const;
 
  void setStepperValues(const Teuchos::RCP<Teuchos::ParameterList> pl);
 
  virtual Teuchos::RCP<const Teuchos::ParameterList> getValidParameters() const;
 
  Teuchos::RCP<Teuchos::ParameterList> getValidParametersBasic() const;
 
 private:
  std::string stepperName_;  
  std::string stepperType_;  
  std::string ICConsistency_ =
      std::string("None");  
  bool ICConsistencyCheck_ =
      false;  
 
  // RCP to SolutionState memory or Stepper temporary memory (if needed).
  Teuchos::RCP<Thyra::VectorBase<Scalar> > stepperX_;
  Teuchos::RCP<Thyra::VectorBase<Scalar> > stepperXDot_;
  Teuchos::RCP<Thyra::VectorBase<Scalar> > stepperXDotDot_;
 
 protected:
  virtual void setStepperX(Teuchos::RCP<Thyra::VectorBase<Scalar> > x)
  {
    stepperX_ = x;
  }
 
  virtual void setStepperXDot(Teuchos::RCP<Thyra::VectorBase<Scalar> > xDot)
  {
    stepperXDot_ = xDot;
  }
 
  virtual void setStepperXDotDot(
      Teuchos::RCP<Thyra::VectorBase<Scalar> > xDotDot)
  {
    stepperXDotDot_ = xDotDot;
  }
 
  bool useFSAL_ = false;  
  bool isInitialized_ =
      false;  
};
 
 
 
template <class Scalar>
void validExplicitODE(
    const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& model);
 
 
template <class Scalar>
void validSecondOrderExplicitODE(
    const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& model);
 
template <class Scalar>
void validImplicitODE_DAE(
    const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& model);
 
template <class Scalar>
void validSecondOrderODE_DAE(
    const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >& model);
 
Teuchos::RCP<Teuchos::ParameterList> defaultSolverParameters();
 
}  // namespace Tempus
#endif  // Tempus_Stepper_decl_hpp