Tempus_TimeStepControl_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_TimeStepControl_decl_hpp
#define Tempus_TimeStepControl_decl_hpp

#include <iostream>
#include <iterator>
#include <sstream>

#include "Teuchos_VerboseObject.hpp"
#include "Teuchos_Describable.hpp"

#include "Tempus_config.hpp"
#include "Tempus_SolutionHistory.hpp"
#include "Tempus_TimeStepControlStrategy.hpp"


namespace Tempus {

template<class Scalar>
class TimeStepControl
  : virtual public Teuchos::Describable,
    virtual public Teuchos::VerboseObject<Tempus::TimeStepControl<Scalar> >
{
public:

  TimeStepControl();

  TimeStepControl(
    Scalar              initTime,
    Scalar              finalTime,
    Scalar              minTimeStep,
    Scalar              initTimeStep,
    Scalar              maxTimeStep,
    int                 initIndex,
    int                 finalIndex,
    Scalar              maxAbsError,
    Scalar              maxRelError,
    int                 maxFailures,
    int                 maxConsecFailures,
    int                 numTimeSteps,
    bool                printDtChanges,
    bool                outputExactly,
    std::vector<int>    outputIndices,
    std::vector<Scalar> outputTimes,
    int                 outputIndexInterval,
    Scalar              outputTimeInterval,
    Teuchos::RCP<TimeStepControlStrategy<Scalar>> stepControlStrategy);

  virtual ~TimeStepControl() {}

#ifndef TEMPUS_HIDE_DEPRECATED_CODE
  virtual void getNextTimeStep(
    const Teuchos::RCP<SolutionHistory<Scalar> > & sh,
    Status & integratorStatus)
  {
    this->setNextTimeStep(sh, integratorStatus);
  };
#endif

  virtual void setNextTimeStep(
    const Teuchos::RCP<SolutionHistory<Scalar> > & solutionHistory,
    Status & integratorStatus);

  virtual bool timeInRange(const Scalar time) const;

  virtual bool indexInRange(const int iStep) const;

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


    std::string description() const;
    void describe(Teuchos::FancyOStream          &out,
                  const Teuchos::EVerbosityLevel verbLevel) const;


    virtual std::string getStepType() const { return stepControlStrategy_->getStepType(); }
    virtual Scalar getInitTime() const { return initTime_; }
    virtual Scalar getFinalTime() const { return finalTime_; }
    virtual Scalar getMinTimeStep() const { return minTimeStep_; }
    virtual Scalar getInitTimeStep() const { return initTimeStep_; }
    virtual Scalar getMaxTimeStep() const { return maxTimeStep_; }
    virtual int getInitIndex() const { return initIndex_; }
    virtual int getFinalIndex() const { return finalIndex_; }
    virtual Scalar getMaxAbsError() const { return maxAbsError_; }
    virtual Scalar getMaxRelError() const { return maxRelError_; }
    virtual bool getOutputExactly() const { return outputExactly_; }
    virtual std::vector<int> getOutputIndices() const { return outputIndices_; }
    virtual std::vector<Scalar> getOutputTimes() const { return outputTimes_; }
    virtual int getMaxFailures() const { return maxFailures_; }
    virtual int getMaxConsecFailures() const { return maxConsecFailures_; }
    virtual bool getPrintDtChanges() const { return printDtChanges_; }
    virtual int getNumTimeSteps() const { return numTimeSteps_; }

    virtual Teuchos::RCP<TimeStepControlStrategy<Scalar>>
       getTimeStepControlStrategy() const { return stepControlStrategy_;}
    virtual int getOutputIndexInterval() const { return outputIndexInterval_;}
    virtual Scalar getOutputTimeInterval() const { return outputTimeInterval_;}


    virtual void setInitTime(Scalar t) { initTime_ = t; isInitialized_ = false; }
    virtual void setFinalTime(Scalar t) { finalTime_ = t; isInitialized_ = false; }
    virtual void setMinTimeStep(Scalar t) { minTimeStep_ = t; isInitialized_ = false; }
    virtual void setInitTimeStep(Scalar t) { initTimeStep_ = t; isInitialized_ = false; }
    virtual void setMaxTimeStep(Scalar t) { maxTimeStep_ = t; isInitialized_ = false; }
    virtual void setInitIndex(int i) { initIndex_ = i; isInitialized_ = false; }
    virtual void setFinalIndex(int i) { finalIndex_ = i; isInitialized_ = false; }
    virtual void setMaxAbsError(Scalar e) { maxAbsError_ = e; isInitialized_ = false; }
    virtual void setMaxRelError(Scalar e) { maxRelError_ = e; isInitialized_ = false; }
    virtual void setMaxFailures(int i) { maxFailures_ = i; isInitialized_ = false; }
    virtual void setMaxConsecFailures(int i) { maxConsecFailures_ = i; isInitialized_ = false; }
    virtual void setPrintDtChanges(bool b) { printDtChanges_ = b; isInitialized_ = false; }
    virtual void setNumTimeSteps(int numTimeSteps);

    virtual void setOutputExactly(bool b) { outputExactly_ = b; isInitialized_ = false; }
    virtual void setOutputIndices(std::vector<int> v) { outputIndices_ = v; isInitialized_ = false; }
    virtual void setOutputTimes(std::vector<Scalar> v) { outputTimes_ = v; isInitialized_ = false; }
    virtual void setOutputIndexInterval(int i) { outputIndexInterval_ = i; isInitialized_ = false; }
    virtual void setOutputTimeInterval(Scalar t) { outputTimeInterval_ = t; isInitialized_ = false; }

    virtual void setTimeStepControlStrategy(
      Teuchos::RCP<TimeStepControlStrategy<Scalar> > tscs = Teuchos::null);

  virtual void printDtChanges(int istep, Scalar dt_old, Scalar dt_new,
                              std::string reason) const;

  virtual void initialize() const;
  virtual bool isInitialized() { return isInitialized_; }
  virtual void checkInitialized();

protected:

  mutable bool isInitialized_;     
  Scalar       initTime_;          
  Scalar       finalTime_;         
  Scalar       minTimeStep_;       
  Scalar       initTimeStep_;      
  Scalar       maxTimeStep_;       
  int          initIndex_;         
  int          finalIndex_;        
  Scalar       maxAbsError_;       
  Scalar       maxRelError_;       
  int          maxFailures_;       
  int          maxConsecFailures_; 
  int          numTimeSteps_;      
  bool         printDtChanges_;    

  bool                outputExactly_;  
  std::vector<int>    outputIndices_;  
  std::vector<Scalar> outputTimes_;    
  int outputIndexInterval_;
  Scalar outputTimeInterval_;

  bool outputAdjustedDt_; 
  Scalar dtAfterOutput_;  

  Teuchos::RCP<TimeStepControlStrategy<Scalar>> stepControlStrategy_;

};


// ------------------------------------------------------------------------
template<class Scalar>
Teuchos::RCP<TimeStepControl<Scalar> > createTimeStepControl(
  Teuchos::RCP<Teuchos::ParameterList> const& pList,
  bool runInitialize = true);

template<class Scalar>
Teuchos::RCP<Teuchos::ParameterList> getTimeStepControlPL()
{
  auto tsc = rcp(new Tempus::TimeStepControl<Scalar>());
  return Teuchos::rcp_const_cast<Teuchos::ParameterList> (tsc->getValidParameters());
}


} // namespace Tempus

#endif // Tempus_TimeStepControl_decl_hpp