Tempus_IntegratorBasic_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_IntegratorBasic_decl_hpp
#define Tempus_IntegratorBasic_decl_hpp


#include "Teuchos_Time.hpp"

#include "Thyra_ModelEvaluator.hpp"

#include "Tempus_config.hpp"
#include "Tempus_Stepper.hpp"
#include "Tempus_Integrator.hpp"
#include "Tempus_TimeStepControl.hpp"
#include "Tempus_IntegratorObserverBasic.hpp"


namespace Tempus {


template<class Scalar>
class IntegratorBasic : virtual public Tempus::Integrator<Scalar>
{
public:

  IntegratorBasic();

  IntegratorBasic(
    Teuchos::RCP<Stepper<Scalar> >            stepper,
    Teuchos::RCP<SolutionHistory<Scalar> >    solutionHistory,
    Teuchos::RCP<TimeStepControl<Scalar> >    timeStepControl,
    Teuchos::RCP<IntegratorObserver<Scalar> > integratorObserver,
    std::vector<int>                          outputScreenIndices,
    int                                       outputScreenInterval);

  virtual void copy(Teuchos::RCP<IntegratorBasic<Scalar> > iB);

  virtual ~IntegratorBasic() {}


    virtual bool advanceTime();
    virtual bool advanceTime(const Scalar timeFinal) override;
    virtual void startIntegrator();
    virtual void startTimeStep();
    virtual void checkTimeStep();
    virtual void endIntegrator();


    virtual Scalar getTime() const override
    {return solutionHistory_->getCurrentTime();}
    virtual int getIndex() const override
    {return solutionHistory_->getCurrentIndex();}
    virtual Status getStatus() const override
    {return integratorStatus_;}
    virtual void setStatus(const Status st) override { integratorStatus_ = st; }
    virtual Teuchos::RCP<Stepper<Scalar> > getStepper() const override
    {return stepper_;}
    virtual void setModel(Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > model);
    virtual void setStepper(Teuchos::RCP<Stepper<Scalar> > stepper);
    virtual void initializeSolutionHistory(
      Teuchos::RCP<SolutionState<Scalar> > state = Teuchos::null);
    virtual void initializeSolutionHistory(Scalar t0,
      Teuchos::RCP<const Thyra::VectorBase<Scalar> > x0,
      Teuchos::RCP<const Thyra::VectorBase<Scalar> > xdot0 = Teuchos::null,
      Teuchos::RCP<const Thyra::VectorBase<Scalar> > xdotdot0 = Teuchos::null);
    virtual Teuchos::RCP<const SolutionHistory<Scalar> > getSolutionHistory() const override
      {return solutionHistory_;}
    virtual Teuchos::RCP<SolutionHistory<Scalar> > getNonConstSolutionHistory() override
      {return solutionHistory_;}
    virtual void setSolutionHistory(
      Teuchos::RCP<SolutionHistory<Scalar> > sh = Teuchos::null);
    virtual Teuchos::RCP<const TimeStepControl<Scalar> > getTimeStepControl() const override
      {return timeStepControl_;}
    virtual Teuchos::RCP<TimeStepControl<Scalar> > getNonConstTimeStepControl() override
      {return timeStepControl_;}
    virtual void setTimeStepControl(
      Teuchos::RCP<TimeStepControl<Scalar> > tsc = Teuchos::null);
    virtual Teuchos::RCP<IntegratorObserver<Scalar> > getObserver()
      {return integratorObserver_;}
    virtual void setObserver(
      Teuchos::RCP<IntegratorObserver<Scalar> > obs = Teuchos::null);
    virtual void initialize();
    bool isInitialized() { return isInitialized_; }

    //TODO: finish this
    virtual Teuchos::RCP<Teuchos::Time> getIntegratorTimer() const override
    { return integratorTimer_;}
    virtual Teuchos::RCP<Teuchos::Time> getStepperTimer() const override
    { return stepperTimer_;}

    virtual Teuchos::RCP<Thyra::VectorBase<Scalar> > getX() const
      {return solutionHistory_->getCurrentState()->getX();}
    virtual Teuchos::RCP<Thyra::VectorBase<Scalar> > getXDot() const
      {return solutionHistory_->getCurrentState()->getXDot();}
    virtual Teuchos::RCP<Thyra::VectorBase<Scalar> > getXDotDot() const
      {return solutionHistory_->getCurrentState()->getXDotDot();}

    virtual Teuchos::RCP<SolutionState<Scalar> > getCurrentState()
      {return solutionHistory_->getCurrentState();}

    virtual void setScreenOutputIndexInterval(int i)
    { outputScreenInterval_ = i; }

    virtual int getScreenOutputIndexInterval() const
    { return outputScreenInterval_; }

    virtual void setScreenOutputIndexList(std::vector<int> indices)
    { outputScreenIndices_ = indices; }

    virtual void setScreenOutputIndexList(std::string str);

    virtual std::vector<int> getScreenOutputIndexList() const
    { return outputScreenIndices_; }

    virtual std::string getScreenOutputIndexListString() const;

  void parseScreenOutput()
  {  TEUCHOS_TEST_FOR_EXCEPTION( true, std::logic_error,
       "  IntegratorBasic::parseScreenOutput() --  Should call setScreenOutputIndexList()\n");
  }

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


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

  void setIntegratorName(std::string i) { integratorName_ = i; }
  std::string getIntegratorName() const { return integratorName_; }

  std::string getIntegratorType() const { return integratorType_; }

protected:

  void setIntegratorType(std::string i);
  std::string      integratorName_;        
  std::string      integratorType_;        

  Teuchos::RCP<Stepper<Scalar> >            stepper_;
  Teuchos::RCP<SolutionHistory<Scalar> >    solutionHistory_;
  Teuchos::RCP<TimeStepControl<Scalar> >    timeStepControl_;
  Teuchos::RCP<IntegratorObserver<Scalar> > integratorObserver_;

  std::vector<int> outputScreenIndices_;   
  int              outputScreenInterval_;  

  Status integratorStatus_;
  bool isInitialized_;

  Teuchos::RCP<Teuchos::Time> integratorTimer_;
  Teuchos::RCP<Teuchos::Time> stepperTimer_;

};


template<class Scalar>
Teuchos::RCP<IntegratorBasic<Scalar> > createIntegratorBasic(
  Teuchos::RCP<Teuchos::ParameterList>                pList,
  bool runInitialize=true);


template<class Scalar>
Teuchos::RCP<IntegratorBasic<Scalar> > createIntegratorBasic(
  Teuchos::RCP<Teuchos::ParameterList>                pList,
  const Teuchos::RCP<Thyra::ModelEvaluator<Scalar> >& model,
  bool runInitialize=true);


template<class Scalar>
Teuchos::RCP<IntegratorBasic<Scalar> > createIntegratorBasic(
  const Teuchos::RCP<Thyra::ModelEvaluator<Scalar> >& model,
  std::string stepperType);


template<class Scalar>
Teuchos::RCP<IntegratorBasic<Scalar> > createIntegratorBasic();


template<class Scalar>
Teuchos::RCP<IntegratorBasic<Scalar> > createIntegratorBasic(
  Teuchos::RCP<Teuchos::ParameterList>                pList,
  std::vector<Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> > > models,
  bool runInitialize=true);


} // namespace Tempus

#endif // Tempus_IntegratorBasic_decl_hpp