Tempus_Stepper_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_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) {}

#ifndef TEMPUS_HIDE_DEPRECATED_CODE
    virtual void setNonConstModel(
      const Teuchos::RCP<Thyra::ModelEvaluator<Scalar> >& /* appModel */){}

#endif
    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