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"
#include "Tempus_TimeEventComposite.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<TimeEventComposite<Scalar>> timeEvent,
      Teuchos::RCP<TimeStepControlStrategy<Scalar>> stepControlStrategy);

  virtual ~TimeStepControl() {}

  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;
  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;

  virtual std::vector<int> getOutputIndices() const;
  virtual std::vector<Scalar> getOutputTimes() const;
  virtual int getOutputIndexInterval() const;
  virtual Scalar getOutputTimeInterval() const;
  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<TimeEventComposite<Scalar>> getTimeEvents() const
  {
    return timeEvent_;
  }
  virtual Teuchos::RCP<TimeStepControlStrategy<Scalar>>
  getTimeStepControlStrategy() const
  {
    return stepControlStrategy_;
  }


  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);
  virtual void setOutputIndices(std::vector<int> v);
  virtual void setOutputTimes(std::vector<Scalar> outputTimes);
  virtual void setOutputIndexInterval(int i);
  virtual void setOutputTimeInterval(Scalar t);
  virtual void setTimeEvents(
      Teuchos::RCP<TimeEventComposite<Scalar>> teb = Teuchos::null);
  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_;         

  Teuchos::RCP<TimeEventComposite<Scalar>> timeEvent_;

  bool teAdjustedDt_;        
  Scalar dtAfterTimeEvent_;  

  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