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